/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace FraudDetector { /** *

This is the Amazon Fraud Detector API Reference. This guide is for developers * who need detailed information about Amazon Fraud Detector API actions, data * types, and errors. For more information about Amazon Fraud Detector features, * see the Amazon * Fraud Detector User Guide.

We provide the Query API as well as AWS * software development kits (SDK) for Amazon Fraud Detector in Java and Python * programming languages.

The Amazon Fraud Detector Query API provides HTTPS * requests that use the HTTP verb GET or POST and a Query parameter * Action. AWS SDK provides libraries, sample code, tutorials, and * other resources for software developers who prefer to build applications using * language-specific APIs instead of submitting a request over HTTP or HTTPS. These * libraries provide basic functions that automatically take care of tasks such as * cryptographically signing your requests, retrying requests, and handling error * responses, so that it is easier for you to get started. For more information * about the AWS SDKs, go to Tools to build on AWS page, * scroll down to the SDK section, and choose plus (+) sign to expand the * section.

*/ class AWS_FRAUDDETECTOR_API FraudDetectorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef FraudDetectorClientConfiguration ClientConfigurationType; typedef FraudDetectorEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ FraudDetectorClient(const Aws::FraudDetector::FraudDetectorClientConfiguration& clientConfiguration = Aws::FraudDetector::FraudDetectorClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ FraudDetectorClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::FraudDetector::FraudDetectorClientConfiguration& clientConfiguration = Aws::FraudDetector::FraudDetectorClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ FraudDetectorClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::FraudDetector::FraudDetectorClientConfiguration& clientConfiguration = Aws::FraudDetector::FraudDetectorClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ FraudDetectorClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ FraudDetectorClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ FraudDetectorClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~FraudDetectorClient(); /** *

Creates a batch of variables.

See Also:

AWS * API Reference

*/ virtual Model::BatchCreateVariableOutcome BatchCreateVariable(const Model::BatchCreateVariableRequest& request) const; /** * A Callable wrapper for BatchCreateVariable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchCreateVariableOutcomeCallable BatchCreateVariableCallable(const BatchCreateVariableRequestT& request) const { return SubmitCallable(&FraudDetectorClient::BatchCreateVariable, request); } /** * An Async wrapper for BatchCreateVariable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchCreateVariableAsync(const BatchCreateVariableRequestT& request, const BatchCreateVariableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::BatchCreateVariable, request, handler, context); } /** *

Gets a batch of variables.

See Also:

AWS * API Reference

*/ virtual Model::BatchGetVariableOutcome BatchGetVariable(const Model::BatchGetVariableRequest& request) const; /** * A Callable wrapper for BatchGetVariable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetVariableOutcomeCallable BatchGetVariableCallable(const BatchGetVariableRequestT& request) const { return SubmitCallable(&FraudDetectorClient::BatchGetVariable, request); } /** * An Async wrapper for BatchGetVariable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetVariableAsync(const BatchGetVariableRequestT& request, const BatchGetVariableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::BatchGetVariable, request, handler, context); } /** *

Cancels an in-progress batch import job.

See Also:

AWS * API Reference

*/ virtual Model::CancelBatchImportJobOutcome CancelBatchImportJob(const Model::CancelBatchImportJobRequest& request) const; /** * A Callable wrapper for CancelBatchImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelBatchImportJobOutcomeCallable CancelBatchImportJobCallable(const CancelBatchImportJobRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CancelBatchImportJob, request); } /** * An Async wrapper for CancelBatchImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelBatchImportJobAsync(const CancelBatchImportJobRequestT& request, const CancelBatchImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CancelBatchImportJob, request, handler, context); } /** *

Cancels the specified batch prediction job.

See Also:

AWS * API Reference

*/ virtual Model::CancelBatchPredictionJobOutcome CancelBatchPredictionJob(const Model::CancelBatchPredictionJobRequest& request) const; /** * A Callable wrapper for CancelBatchPredictionJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelBatchPredictionJobOutcomeCallable CancelBatchPredictionJobCallable(const CancelBatchPredictionJobRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CancelBatchPredictionJob, request); } /** * An Async wrapper for CancelBatchPredictionJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelBatchPredictionJobAsync(const CancelBatchPredictionJobRequestT& request, const CancelBatchPredictionJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CancelBatchPredictionJob, request, handler, context); } /** *

Creates a batch import job.

See Also:

AWS * API Reference

*/ virtual Model::CreateBatchImportJobOutcome CreateBatchImportJob(const Model::CreateBatchImportJobRequest& request) const; /** * A Callable wrapper for CreateBatchImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBatchImportJobOutcomeCallable CreateBatchImportJobCallable(const CreateBatchImportJobRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateBatchImportJob, request); } /** * An Async wrapper for CreateBatchImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBatchImportJobAsync(const CreateBatchImportJobRequestT& request, const CreateBatchImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateBatchImportJob, request, handler, context); } /** *

Creates a batch prediction job.

See Also:

AWS * API Reference

*/ virtual Model::CreateBatchPredictionJobOutcome CreateBatchPredictionJob(const Model::CreateBatchPredictionJobRequest& request) const; /** * A Callable wrapper for CreateBatchPredictionJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBatchPredictionJobOutcomeCallable CreateBatchPredictionJobCallable(const CreateBatchPredictionJobRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateBatchPredictionJob, request); } /** * An Async wrapper for CreateBatchPredictionJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBatchPredictionJobAsync(const CreateBatchPredictionJobRequestT& request, const CreateBatchPredictionJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateBatchPredictionJob, request, handler, context); } /** *

Creates a detector version. The detector version starts in a * DRAFT status.

See Also:

AWS * API Reference

*/ virtual Model::CreateDetectorVersionOutcome CreateDetectorVersion(const Model::CreateDetectorVersionRequest& request) const; /** * A Callable wrapper for CreateDetectorVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDetectorVersionOutcomeCallable CreateDetectorVersionCallable(const CreateDetectorVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateDetectorVersion, request); } /** * An Async wrapper for CreateDetectorVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDetectorVersionAsync(const CreateDetectorVersionRequestT& request, const CreateDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateDetectorVersion, request, handler, context); } /** *

Creates a list.

List is a set of input data for a variable in your * event dataset. You use the input data in a rule that's associated with your * detector. For more information, see Lists.

See * Also:

AWS * API Reference

*/ virtual Model::CreateListOutcome CreateList(const Model::CreateListRequest& request) const; /** * A Callable wrapper for CreateList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateListOutcomeCallable CreateListCallable(const CreateListRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateList, request); } /** * An Async wrapper for CreateList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateListAsync(const CreateListRequestT& request, const CreateListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateList, request, handler, context); } /** *

Creates a model using the specified model type.

See Also:

AWS * API Reference

*/ virtual Model::CreateModelOutcome CreateModel(const Model::CreateModelRequest& request) const; /** * A Callable wrapper for CreateModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelOutcomeCallable CreateModelCallable(const CreateModelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateModel, request); } /** * An Async wrapper for CreateModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelAsync(const CreateModelRequestT& request, const CreateModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateModel, request, handler, context); } /** *

Creates a version of the model using the specified model type and model id. *

See Also:

AWS * API Reference

*/ virtual Model::CreateModelVersionOutcome CreateModelVersion(const Model::CreateModelVersionRequest& request) const; /** * A Callable wrapper for CreateModelVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelVersionOutcomeCallable CreateModelVersionCallable(const CreateModelVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateModelVersion, request); } /** * An Async wrapper for CreateModelVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelVersionAsync(const CreateModelVersionRequestT& request, const CreateModelVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateModelVersion, request, handler, context); } /** *

Creates a rule for use with the specified detector.

See Also:

* AWS * API Reference

*/ virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const; /** * A Callable wrapper for CreateRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateRule, request); } /** * An Async wrapper for CreateRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateRule, request, handler, context); } /** *

Creates a variable.

See Also:

AWS * API Reference

*/ virtual Model::CreateVariableOutcome CreateVariable(const Model::CreateVariableRequest& request) const; /** * A Callable wrapper for CreateVariable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVariableOutcomeCallable CreateVariableCallable(const CreateVariableRequestT& request) const { return SubmitCallable(&FraudDetectorClient::CreateVariable, request); } /** * An Async wrapper for CreateVariable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVariableAsync(const CreateVariableRequestT& request, const CreateVariableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::CreateVariable, request, handler, context); } /** *

Deletes the specified batch import job ID record. This action does not delete * the data that was batch imported.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBatchImportJobOutcome DeleteBatchImportJob(const Model::DeleteBatchImportJobRequest& request) const; /** * A Callable wrapper for DeleteBatchImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBatchImportJobOutcomeCallable DeleteBatchImportJobCallable(const DeleteBatchImportJobRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteBatchImportJob, request); } /** * An Async wrapper for DeleteBatchImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBatchImportJobAsync(const DeleteBatchImportJobRequestT& request, const DeleteBatchImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteBatchImportJob, request, handler, context); } /** *

Deletes a batch prediction job.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBatchPredictionJobOutcome DeleteBatchPredictionJob(const Model::DeleteBatchPredictionJobRequest& request) const; /** * A Callable wrapper for DeleteBatchPredictionJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBatchPredictionJobOutcomeCallable DeleteBatchPredictionJobCallable(const DeleteBatchPredictionJobRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteBatchPredictionJob, request); } /** * An Async wrapper for DeleteBatchPredictionJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBatchPredictionJobAsync(const DeleteBatchPredictionJobRequestT& request, const DeleteBatchPredictionJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteBatchPredictionJob, request, handler, context); } /** *

Deletes the detector. Before deleting a detector, you must first delete all * detector versions and rule versions associated with the detector.

When * you delete a detector, Amazon Fraud Detector permanently deletes the detector * and the data is no longer stored in Amazon Fraud Detector.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteDetectorOutcome DeleteDetector(const Model::DeleteDetectorRequest& request) const; /** * A Callable wrapper for DeleteDetector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDetectorOutcomeCallable DeleteDetectorCallable(const DeleteDetectorRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteDetector, request); } /** * An Async wrapper for DeleteDetector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDetectorAsync(const DeleteDetectorRequestT& request, const DeleteDetectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteDetector, request, handler, context); } /** *

Deletes the detector version. You cannot delete detector versions that are in * ACTIVE status.

When you delete a detector version, Amazon * Fraud Detector permanently deletes the detector and the data is no longer stored * in Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDetectorVersionOutcome DeleteDetectorVersion(const Model::DeleteDetectorVersionRequest& request) const; /** * A Callable wrapper for DeleteDetectorVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDetectorVersionOutcomeCallable DeleteDetectorVersionCallable(const DeleteDetectorVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteDetectorVersion, request); } /** * An Async wrapper for DeleteDetectorVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDetectorVersionAsync(const DeleteDetectorVersionRequestT& request, const DeleteDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteDetectorVersion, request, handler, context); } /** *

Deletes an entity type.

You cannot delete an entity type that is * included in an event type.

When you delete an entity type, Amazon Fraud * Detector permanently deletes that entity type and the data is no longer stored * in Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEntityTypeOutcome DeleteEntityType(const Model::DeleteEntityTypeRequest& request) const; /** * A Callable wrapper for DeleteEntityType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEntityTypeOutcomeCallable DeleteEntityTypeCallable(const DeleteEntityTypeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteEntityType, request); } /** * An Async wrapper for DeleteEntityType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEntityTypeAsync(const DeleteEntityTypeRequestT& request, const DeleteEntityTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteEntityType, request, handler, context); } /** *

Deletes the specified event.

When you delete an event, Amazon Fraud * Detector permanently deletes that event and the event data is no longer stored * in Amazon Fraud Detector. If deleteAuditHistory is * True, event data is available through search for up to 30 seconds * after the delete operation is completed.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEventOutcome DeleteEvent(const Model::DeleteEventRequest& request) const; /** * A Callable wrapper for DeleteEvent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventOutcomeCallable DeleteEventCallable(const DeleteEventRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteEvent, request); } /** * An Async wrapper for DeleteEvent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventAsync(const DeleteEventRequestT& request, const DeleteEventResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteEvent, request, handler, context); } /** *

Deletes an event type.

You cannot delete an event type that is used in * a detector or a model.

When you delete an event type, Amazon Fraud * Detector permanently deletes that event type and the data is no longer stored in * Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEventTypeOutcome DeleteEventType(const Model::DeleteEventTypeRequest& request) const; /** * A Callable wrapper for DeleteEventType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventTypeOutcomeCallable DeleteEventTypeCallable(const DeleteEventTypeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteEventType, request); } /** * An Async wrapper for DeleteEventType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventTypeAsync(const DeleteEventTypeRequestT& request, const DeleteEventTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteEventType, request, handler, context); } /** *

Deletes all events of a particular event type.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEventsByEventTypeOutcome DeleteEventsByEventType(const Model::DeleteEventsByEventTypeRequest& request) const; /** * A Callable wrapper for DeleteEventsByEventType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventsByEventTypeOutcomeCallable DeleteEventsByEventTypeCallable(const DeleteEventsByEventTypeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteEventsByEventType, request); } /** * An Async wrapper for DeleteEventsByEventType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventsByEventTypeAsync(const DeleteEventsByEventTypeRequestT& request, const DeleteEventsByEventTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteEventsByEventType, request, handler, context); } /** *

Removes a SageMaker model from Amazon Fraud Detector.

You can remove * an Amazon SageMaker model if it is not associated with a detector version. * Removing a SageMaker model disconnects it from Amazon Fraud Detector, but the * model remains available in SageMaker.

See Also:

AWS * API Reference

*/ virtual Model::DeleteExternalModelOutcome DeleteExternalModel(const Model::DeleteExternalModelRequest& request) const; /** * A Callable wrapper for DeleteExternalModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteExternalModelOutcomeCallable DeleteExternalModelCallable(const DeleteExternalModelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteExternalModel, request); } /** * An Async wrapper for DeleteExternalModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteExternalModelAsync(const DeleteExternalModelRequestT& request, const DeleteExternalModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteExternalModel, request, handler, context); } /** *

Deletes a label.

You cannot delete labels that are included in an * event type in Amazon Fraud Detector.

You cannot delete a label assigned * to an event ID. You must first delete the relevant event ID.

When you * delete a label, Amazon Fraud Detector permanently deletes that label and the * data is no longer stored in Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLabelOutcome DeleteLabel(const Model::DeleteLabelRequest& request) const; /** * A Callable wrapper for DeleteLabel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLabelOutcomeCallable DeleteLabelCallable(const DeleteLabelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteLabel, request); } /** * An Async wrapper for DeleteLabel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLabelAsync(const DeleteLabelRequestT& request, const DeleteLabelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteLabel, request, handler, context); } /** *

Deletes the list, provided it is not used in a rule.

When you * delete a list, Amazon Fraud Detector permanently deletes that list and the * elements in the list.

See Also:

AWS * API Reference

*/ virtual Model::DeleteListOutcome DeleteList(const Model::DeleteListRequest& request) const; /** * A Callable wrapper for DeleteList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteListOutcomeCallable DeleteListCallable(const DeleteListRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteList, request); } /** * An Async wrapper for DeleteList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteListAsync(const DeleteListRequestT& request, const DeleteListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteList, request, handler, context); } /** *

Deletes a model.

You can delete models and model versions in Amazon * Fraud Detector, provided that they are not associated with a detector * version.

When you delete a model, Amazon Fraud Detector permanently * deletes that model and the data is no longer stored in Amazon Fraud * Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelOutcome DeleteModel(const Model::DeleteModelRequest& request) const; /** * A Callable wrapper for DeleteModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelOutcomeCallable DeleteModelCallable(const DeleteModelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteModel, request); } /** * An Async wrapper for DeleteModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelAsync(const DeleteModelRequestT& request, const DeleteModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteModel, request, handler, context); } /** *

Deletes a model version.

You can delete models and model versions in * Amazon Fraud Detector, provided that they are not associated with a detector * version.

When you delete a model version, Amazon Fraud Detector * permanently deletes that model version and the data is no longer stored in * Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelVersionOutcome DeleteModelVersion(const Model::DeleteModelVersionRequest& request) const; /** * A Callable wrapper for DeleteModelVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelVersionOutcomeCallable DeleteModelVersionCallable(const DeleteModelVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteModelVersion, request); } /** * An Async wrapper for DeleteModelVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelVersionAsync(const DeleteModelVersionRequestT& request, const DeleteModelVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteModelVersion, request, handler, context); } /** *

Deletes an outcome.

You cannot delete an outcome that is used in a * rule version.

When you delete an outcome, Amazon Fraud Detector * permanently deletes that outcome and the data is no longer stored in Amazon * Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOutcomeOutcome DeleteOutcome(const Model::DeleteOutcomeRequest& request) const; /** * A Callable wrapper for DeleteOutcome that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOutcomeOutcomeCallable DeleteOutcomeCallable(const DeleteOutcomeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteOutcome, request); } /** * An Async wrapper for DeleteOutcome that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOutcomeAsync(const DeleteOutcomeRequestT& request, const DeleteOutcomeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteOutcome, request, handler, context); } /** *

Deletes the rule. You cannot delete a rule if it is used by an * ACTIVE or INACTIVE detector version.

When you * delete a rule, Amazon Fraud Detector permanently deletes that rule and the data * is no longer stored in Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const; /** * A Callable wrapper for DeleteRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteRule, request); } /** * An Async wrapper for DeleteRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteRule, request, handler, context); } /** *

Deletes a variable.

You can't delete variables that are included in an * event type in Amazon Fraud Detector.

Amazon Fraud Detector automatically * deletes model output variables and SageMaker model output variables when you * delete the model. You can't delete these variables manually.

When you * delete a variable, Amazon Fraud Detector permanently deletes that variable and * the data is no longer stored in Amazon Fraud Detector.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteVariableOutcome DeleteVariable(const Model::DeleteVariableRequest& request) const; /** * A Callable wrapper for DeleteVariable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVariableOutcomeCallable DeleteVariableCallable(const DeleteVariableRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DeleteVariable, request); } /** * An Async wrapper for DeleteVariable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVariableAsync(const DeleteVariableRequestT& request, const DeleteVariableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DeleteVariable, request, handler, context); } /** *

Gets all versions for a specified detector.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDetectorOutcome DescribeDetector(const Model::DescribeDetectorRequest& request) const; /** * A Callable wrapper for DescribeDetector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDetectorOutcomeCallable DescribeDetectorCallable(const DescribeDetectorRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DescribeDetector, request); } /** * An Async wrapper for DescribeDetector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDetectorAsync(const DescribeDetectorRequestT& request, const DescribeDetectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DescribeDetector, request, handler, context); } /** *

Gets all of the model versions for the specified model type or for the * specified model type and model ID. You can also get details for a single, * specified model version.

See Also:

AWS * API Reference

*/ virtual Model::DescribeModelVersionsOutcome DescribeModelVersions(const Model::DescribeModelVersionsRequest& request) const; /** * A Callable wrapper for DescribeModelVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelVersionsOutcomeCallable DescribeModelVersionsCallable(const DescribeModelVersionsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::DescribeModelVersions, request); } /** * An Async wrapper for DescribeModelVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelVersionsAsync(const DescribeModelVersionsRequestT& request, const DescribeModelVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::DescribeModelVersions, request, handler, context); } /** *

Gets all batch import jobs or a specific job of the specified ID. This is a * paginated API. If you provide a null maxResults, this action * retrieves a maximum of 50 records per page. If you provide a * maxResults, the value must be between 1 and 50. To get the next * page results, provide the pagination token from the * GetBatchImportJobsResponse as part of your request. A null * pagination token fetches the records from the beginning.

See * Also:

AWS * API Reference

*/ virtual Model::GetBatchImportJobsOutcome GetBatchImportJobs(const Model::GetBatchImportJobsRequest& request) const; /** * A Callable wrapper for GetBatchImportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBatchImportJobsOutcomeCallable GetBatchImportJobsCallable(const GetBatchImportJobsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetBatchImportJobs, request); } /** * An Async wrapper for GetBatchImportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBatchImportJobsAsync(const GetBatchImportJobsRequestT& request, const GetBatchImportJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetBatchImportJobs, request, handler, context); } /** *

Gets all batch prediction jobs or a specific job if you specify a job ID. * This is a paginated API. If you provide a null maxResults, this action retrieves * a maximum of 50 records per page. If you provide a maxResults, the value must be * between 1 and 50. To get the next page results, provide the pagination token * from the GetBatchPredictionJobsResponse as part of your request. A null * pagination token fetches the records from the beginning.

See * Also:

AWS * API Reference

*/ virtual Model::GetBatchPredictionJobsOutcome GetBatchPredictionJobs(const Model::GetBatchPredictionJobsRequest& request) const; /** * A Callable wrapper for GetBatchPredictionJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBatchPredictionJobsOutcomeCallable GetBatchPredictionJobsCallable(const GetBatchPredictionJobsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetBatchPredictionJobs, request); } /** * An Async wrapper for GetBatchPredictionJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBatchPredictionJobsAsync(const GetBatchPredictionJobsRequestT& request, const GetBatchPredictionJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetBatchPredictionJobs, request, handler, context); } /** *

Retrieves the status of a DeleteEventsByEventType * action.

See Also:

AWS * API Reference

*/ virtual Model::GetDeleteEventsByEventTypeStatusOutcome GetDeleteEventsByEventTypeStatus(const Model::GetDeleteEventsByEventTypeStatusRequest& request) const; /** * A Callable wrapper for GetDeleteEventsByEventTypeStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDeleteEventsByEventTypeStatusOutcomeCallable GetDeleteEventsByEventTypeStatusCallable(const GetDeleteEventsByEventTypeStatusRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetDeleteEventsByEventTypeStatus, request); } /** * An Async wrapper for GetDeleteEventsByEventTypeStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDeleteEventsByEventTypeStatusAsync(const GetDeleteEventsByEventTypeStatusRequestT& request, const GetDeleteEventsByEventTypeStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetDeleteEventsByEventTypeStatus, request, handler, context); } /** *

Gets a particular detector version.

See Also:

AWS * API Reference

*/ virtual Model::GetDetectorVersionOutcome GetDetectorVersion(const Model::GetDetectorVersionRequest& request) const; /** * A Callable wrapper for GetDetectorVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDetectorVersionOutcomeCallable GetDetectorVersionCallable(const GetDetectorVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetDetectorVersion, request); } /** * An Async wrapper for GetDetectorVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDetectorVersionAsync(const GetDetectorVersionRequestT& request, const GetDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetDetectorVersion, request, handler, context); } /** *

Gets all detectors or a single detector if a detectorId is * specified. This is a paginated API. If you provide a null * maxResults, this action retrieves a maximum of 10 records per page. * If you provide a maxResults, the value must be between 5 and 10. To * get the next page results, provide the pagination token from the * GetDetectorsResponse as part of your request. A null pagination * token fetches the records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetDetectorsOutcome GetDetectors(const Model::GetDetectorsRequest& request) const; /** * A Callable wrapper for GetDetectors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDetectorsOutcomeCallable GetDetectorsCallable(const GetDetectorsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetDetectors, request); } /** * An Async wrapper for GetDetectors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDetectorsAsync(const GetDetectorsRequestT& request, const GetDetectorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetDetectors, request, handler, context); } /** *

Gets all entity types or a specific entity type if a name is specified. This * is a paginated API. If you provide a null maxResults, this action * retrieves a maximum of 10 records per page. If you provide a * maxResults, the value must be between 5 and 10. To get the next * page results, provide the pagination token from the * GetEntityTypesResponse as part of your request. A null pagination * token fetches the records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetEntityTypesOutcome GetEntityTypes(const Model::GetEntityTypesRequest& request) const; /** * A Callable wrapper for GetEntityTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEntityTypesOutcomeCallable GetEntityTypesCallable(const GetEntityTypesRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetEntityTypes, request); } /** * An Async wrapper for GetEntityTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEntityTypesAsync(const GetEntityTypesRequestT& request, const GetEntityTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetEntityTypes, request, handler, context); } /** *

Retrieves details of events stored with Amazon Fraud Detector. This action * does not retrieve prediction results.

See Also:

AWS * API Reference

*/ virtual Model::GetEventOutcome GetEvent(const Model::GetEventRequest& request) const; /** * A Callable wrapper for GetEvent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventOutcomeCallable GetEventCallable(const GetEventRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetEvent, request); } /** * An Async wrapper for GetEvent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventAsync(const GetEventRequestT& request, const GetEventResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetEvent, request, handler, context); } /** *

Evaluates an event against a detector version. If a version ID is not * provided, the detector’s (ACTIVE) version is used.

See * Also:

AWS * API Reference

*/ virtual Model::GetEventPredictionOutcome GetEventPrediction(const Model::GetEventPredictionRequest& request) const; /** * A Callable wrapper for GetEventPrediction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventPredictionOutcomeCallable GetEventPredictionCallable(const GetEventPredictionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetEventPrediction, request); } /** * An Async wrapper for GetEventPrediction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventPredictionAsync(const GetEventPredictionRequestT& request, const GetEventPredictionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetEventPrediction, request, handler, context); } /** *

Gets details of the past fraud predictions for the specified event ID, event * type, detector ID, and detector version ID that was generated in the specified * time period.

See Also:

AWS * API Reference

*/ virtual Model::GetEventPredictionMetadataOutcome GetEventPredictionMetadata(const Model::GetEventPredictionMetadataRequest& request) const; /** * A Callable wrapper for GetEventPredictionMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventPredictionMetadataOutcomeCallable GetEventPredictionMetadataCallable(const GetEventPredictionMetadataRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetEventPredictionMetadata, request); } /** * An Async wrapper for GetEventPredictionMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventPredictionMetadataAsync(const GetEventPredictionMetadataRequestT& request, const GetEventPredictionMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetEventPredictionMetadata, request, handler, context); } /** *

Gets all event types or a specific event type if name is provided. This is a * paginated API. If you provide a null maxResults, this action * retrieves a maximum of 10 records per page. If you provide a * maxResults, the value must be between 5 and 10. To get the next * page results, provide the pagination token from the * GetEventTypesResponse as part of your request. A null pagination * token fetches the records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetEventTypesOutcome GetEventTypes(const Model::GetEventTypesRequest& request) const; /** * A Callable wrapper for GetEventTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventTypesOutcomeCallable GetEventTypesCallable(const GetEventTypesRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetEventTypes, request); } /** * An Async wrapper for GetEventTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventTypesAsync(const GetEventTypesRequestT& request, const GetEventTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetEventTypes, request, handler, context); } /** *

Gets the details for one or more Amazon SageMaker models that have been * imported into the service. This is a paginated API. If you provide a null * maxResults, this actions retrieves a maximum of 10 records per * page. If you provide a maxResults, the value must be between 5 and * 10. To get the next page results, provide the pagination token from the * GetExternalModelsResult as part of your request. A null pagination * token fetches the records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetExternalModelsOutcome GetExternalModels(const Model::GetExternalModelsRequest& request) const; /** * A Callable wrapper for GetExternalModels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetExternalModelsOutcomeCallable GetExternalModelsCallable(const GetExternalModelsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetExternalModels, request); } /** * An Async wrapper for GetExternalModels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetExternalModelsAsync(const GetExternalModelsRequestT& request, const GetExternalModelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetExternalModels, request, handler, context); } /** *

Gets the encryption key if a KMS key has been specified to be used to encrypt * content in Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::GetKMSEncryptionKeyOutcome GetKMSEncryptionKey() const; /** * A Callable wrapper for GetKMSEncryptionKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetKMSEncryptionKeyOutcomeCallable GetKMSEncryptionKeyCallable() const { return SubmitCallable(&FraudDetectorClient::GetKMSEncryptionKey); } /** * An Async wrapper for GetKMSEncryptionKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetKMSEncryptionKeyAsync(const GetKMSEncryptionKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetKMSEncryptionKey, handler, context); } /** *

Gets all labels or a specific label if name is provided. This is a paginated * API. If you provide a null maxResults, this action retrieves a * maximum of 50 records per page. If you provide a maxResults, the * value must be between 10 and 50. To get the next page results, provide the * pagination token from the GetGetLabelsResponse as part of your * request. A null pagination token fetches the records from the beginning. *

See Also:

AWS * API Reference

*/ virtual Model::GetLabelsOutcome GetLabels(const Model::GetLabelsRequest& request) const; /** * A Callable wrapper for GetLabels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLabelsOutcomeCallable GetLabelsCallable(const GetLabelsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetLabels, request); } /** * An Async wrapper for GetLabels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLabelsAsync(const GetLabelsRequestT& request, const GetLabelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetLabels, request, handler, context); } /** *

Gets all the elements in the specified list.

See Also:

AWS * API Reference

*/ virtual Model::GetListElementsOutcome GetListElements(const Model::GetListElementsRequest& request) const; /** * A Callable wrapper for GetListElements that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetListElementsOutcomeCallable GetListElementsCallable(const GetListElementsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetListElements, request); } /** * An Async wrapper for GetListElements that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetListElementsAsync(const GetListElementsRequestT& request, const GetListElementsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetListElements, request, handler, context); } /** *

Gets the metadata of either all the lists under the account or the specified * list.

See Also:

AWS * API Reference

*/ virtual Model::GetListsMetadataOutcome GetListsMetadata(const Model::GetListsMetadataRequest& request) const; /** * A Callable wrapper for GetListsMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetListsMetadataOutcomeCallable GetListsMetadataCallable(const GetListsMetadataRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetListsMetadata, request); } /** * An Async wrapper for GetListsMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetListsMetadataAsync(const GetListsMetadataRequestT& request, const GetListsMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetListsMetadata, request, handler, context); } /** *

Gets the details of the specified model version.

See Also:

* AWS * API Reference

*/ virtual Model::GetModelVersionOutcome GetModelVersion(const Model::GetModelVersionRequest& request) const; /** * A Callable wrapper for GetModelVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetModelVersionOutcomeCallable GetModelVersionCallable(const GetModelVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetModelVersion, request); } /** * An Async wrapper for GetModelVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetModelVersionAsync(const GetModelVersionRequestT& request, const GetModelVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetModelVersion, request, handler, context); } /** *

Gets one or more models. Gets all models for the Amazon Web Services account * if no model type and no model id provided. Gets all models for the Amazon Web * Services account and model type, if the model type is specified but model id is * not provided. Gets a specific model if (model type, model id) tuple is * specified.

This is a paginated API. If you provide a null * maxResults, this action retrieves a maximum of 10 records per page. * If you provide a maxResults, the value must be between 1 and 10. To * get the next page results, provide the pagination token from the response as * part of your request. A null pagination token fetches the records from the * beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetModelsOutcome GetModels(const Model::GetModelsRequest& request) const; /** * A Callable wrapper for GetModels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetModelsOutcomeCallable GetModelsCallable(const GetModelsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetModels, request); } /** * An Async wrapper for GetModels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetModelsAsync(const GetModelsRequestT& request, const GetModelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetModels, request, handler, context); } /** *

Gets one or more outcomes. This is a paginated API. If you provide a null * maxResults, this actions retrieves a maximum of 100 records per * page. If you provide a maxResults, the value must be between 50 and * 100. To get the next page results, provide the pagination token from the * GetOutcomesResult as part of your request. A null pagination token * fetches the records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetOutcomesOutcome GetOutcomes(const Model::GetOutcomesRequest& request) const; /** * A Callable wrapper for GetOutcomes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOutcomesOutcomeCallable GetOutcomesCallable(const GetOutcomesRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetOutcomes, request); } /** * An Async wrapper for GetOutcomes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOutcomesAsync(const GetOutcomesRequestT& request, const GetOutcomesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetOutcomes, request, handler, context); } /** *

Get all rules for a detector (paginated) if ruleId and * ruleVersion are not specified. Gets all rules for the detector and * the ruleId if present (paginated). Gets a specific rule if both the * ruleId and the ruleVersion are specified.

This * is a paginated API. Providing null maxResults results in retrieving maximum of * 100 records per page. If you provide maxResults the value must be between 50 and * 100. To get the next page result, a provide a pagination token from * GetRulesResult as part of your request. Null pagination token fetches the * records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetRulesOutcome GetRules(const Model::GetRulesRequest& request) const; /** * A Callable wrapper for GetRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRulesOutcomeCallable GetRulesCallable(const GetRulesRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetRules, request); } /** * An Async wrapper for GetRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRulesAsync(const GetRulesRequestT& request, const GetRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetRules, request, handler, context); } /** *

Gets all of the variables or the specific variable. This is a paginated API. * Providing null maxSizePerPage results in retrieving maximum of 100 * records per page. If you provide maxSizePerPage the value must be * between 50 and 100. To get the next page result, a provide a pagination token * from GetVariablesResult as part of your request. Null pagination * token fetches the records from the beginning.

See Also:

AWS * API Reference

*/ virtual Model::GetVariablesOutcome GetVariables(const Model::GetVariablesRequest& request) const; /** * A Callable wrapper for GetVariables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVariablesOutcomeCallable GetVariablesCallable(const GetVariablesRequestT& request) const { return SubmitCallable(&FraudDetectorClient::GetVariables, request); } /** * An Async wrapper for GetVariables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVariablesAsync(const GetVariablesRequestT& request, const GetVariablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::GetVariables, request, handler, context); } /** *

Gets a list of past predictions. The list can be filtered by detector ID, * detector version ID, event ID, event type, or by specifying a time period. If * filter is not specified, the most recent prediction is returned.

For * example, the following filter lists all past predictions for xyz * event type - { "eventType":{ "value": "xyz" }” }

This is a * paginated API. If you provide a null maxResults, this action will * retrieve a maximum of 10 records per page. If you provide a * maxResults, the value must be between 50 and 100. To get the next * page results, provide the nextToken from the response as part of * your request. A null nextToken fetches the records from the * beginning.

See Also:

AWS * API Reference

*/ virtual Model::ListEventPredictionsOutcome ListEventPredictions(const Model::ListEventPredictionsRequest& request) const; /** * A Callable wrapper for ListEventPredictions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEventPredictionsOutcomeCallable ListEventPredictionsCallable(const ListEventPredictionsRequestT& request) const { return SubmitCallable(&FraudDetectorClient::ListEventPredictions, request); } /** * An Async wrapper for ListEventPredictions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEventPredictionsAsync(const ListEventPredictionsRequestT& request, const ListEventPredictionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::ListEventPredictions, request, handler, context); } /** *

Lists all tags associated with the resource. This is a paginated API. To get * the next page results, provide the pagination token from the response as part of * your request. A null pagination token fetches the records from the beginning. *

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&FraudDetectorClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::ListTagsForResource, request, handler, context); } /** *

Creates or updates a detector.

See Also:

AWS * API Reference

*/ virtual Model::PutDetectorOutcome PutDetector(const Model::PutDetectorRequest& request) const; /** * A Callable wrapper for PutDetector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDetectorOutcomeCallable PutDetectorCallable(const PutDetectorRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutDetector, request); } /** * An Async wrapper for PutDetector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDetectorAsync(const PutDetectorRequestT& request, const PutDetectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutDetector, request, handler, context); } /** *

Creates or updates an entity type. An entity represents who is performing the * event. As part of a fraud prediction, you pass the entity ID to indicate the * specific entity who performed the event. An entity type classifies the entity. * Example classifications include customer, merchant, or account.

See * Also:

AWS * API Reference

*/ virtual Model::PutEntityTypeOutcome PutEntityType(const Model::PutEntityTypeRequest& request) const; /** * A Callable wrapper for PutEntityType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutEntityTypeOutcomeCallable PutEntityTypeCallable(const PutEntityTypeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutEntityType, request); } /** * An Async wrapper for PutEntityType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutEntityTypeAsync(const PutEntityTypeRequestT& request, const PutEntityTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutEntityType, request, handler, context); } /** *

Creates or updates an event type. An event is a business activity that is * evaluated for fraud risk. With Amazon Fraud Detector, you generate fraud * predictions for events. An event type defines the structure for an event sent to * Amazon Fraud Detector. This includes the variables sent as part of the event, * the entity performing the event (such as a customer), and the labels that * classify the event. Example event types include online payment transactions, * account registrations, and authentications.

See Also:

AWS * API Reference

*/ virtual Model::PutEventTypeOutcome PutEventType(const Model::PutEventTypeRequest& request) const; /** * A Callable wrapper for PutEventType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutEventTypeOutcomeCallable PutEventTypeCallable(const PutEventTypeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutEventType, request); } /** * An Async wrapper for PutEventType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutEventTypeAsync(const PutEventTypeRequestT& request, const PutEventTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutEventType, request, handler, context); } /** *

Creates or updates an Amazon SageMaker model endpoint. You can also use this * action to update the configuration of the model endpoint, including the IAM role * and/or the mapped variables.

See Also:

AWS * API Reference

*/ virtual Model::PutExternalModelOutcome PutExternalModel(const Model::PutExternalModelRequest& request) const; /** * A Callable wrapper for PutExternalModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutExternalModelOutcomeCallable PutExternalModelCallable(const PutExternalModelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutExternalModel, request); } /** * An Async wrapper for PutExternalModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutExternalModelAsync(const PutExternalModelRequestT& request, const PutExternalModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutExternalModel, request, handler, context); } /** *

Specifies the KMS key to be used to encrypt content in Amazon Fraud * Detector.

See Also:

AWS * API Reference

*/ virtual Model::PutKMSEncryptionKeyOutcome PutKMSEncryptionKey(const Model::PutKMSEncryptionKeyRequest& request) const; /** * A Callable wrapper for PutKMSEncryptionKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutKMSEncryptionKeyOutcomeCallable PutKMSEncryptionKeyCallable(const PutKMSEncryptionKeyRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutKMSEncryptionKey, request); } /** * An Async wrapper for PutKMSEncryptionKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutKMSEncryptionKeyAsync(const PutKMSEncryptionKeyRequestT& request, const PutKMSEncryptionKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutKMSEncryptionKey, request, handler, context); } /** *

Creates or updates label. A label classifies an event as fraudulent or * legitimate. Labels are associated with event types and used to train supervised * machine learning models in Amazon Fraud Detector.

See Also:

AWS * API Reference

*/ virtual Model::PutLabelOutcome PutLabel(const Model::PutLabelRequest& request) const; /** * A Callable wrapper for PutLabel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutLabelOutcomeCallable PutLabelCallable(const PutLabelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutLabel, request); } /** * An Async wrapper for PutLabel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutLabelAsync(const PutLabelRequestT& request, const PutLabelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutLabel, request, handler, context); } /** *

Creates or updates an outcome.

See Also:

AWS * API Reference

*/ virtual Model::PutOutcomeOutcome PutOutcome(const Model::PutOutcomeRequest& request) const; /** * A Callable wrapper for PutOutcome that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutOutcomeOutcomeCallable PutOutcomeCallable(const PutOutcomeRequestT& request) const { return SubmitCallable(&FraudDetectorClient::PutOutcome, request); } /** * An Async wrapper for PutOutcome that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutOutcomeAsync(const PutOutcomeRequestT& request, const PutOutcomeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::PutOutcome, request, handler, context); } /** *

Stores events in Amazon Fraud Detector without generating fraud predictions * for those events. For example, you can use SendEvent to upload a * historical dataset, which you can then later use to train a model.

See * Also:

AWS * API Reference

*/ virtual Model::SendEventOutcome SendEvent(const Model::SendEventRequest& request) const; /** * A Callable wrapper for SendEvent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendEventOutcomeCallable SendEventCallable(const SendEventRequestT& request) const { return SubmitCallable(&FraudDetectorClient::SendEvent, request); } /** * An Async wrapper for SendEvent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendEventAsync(const SendEventRequestT& request, const SendEventResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::SendEvent, request, handler, context); } /** *

Assigns tags to a resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&FraudDetectorClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::TagResource, request, handler, context); } /** *

Removes tags from a resource.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UntagResource, request, handler, context); } /** *

Updates a detector version. The detector version attributes that you can * update include models, external model endpoints, rules, rule execution mode, and * description. You can only update a DRAFT detector * version.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDetectorVersionOutcome UpdateDetectorVersion(const Model::UpdateDetectorVersionRequest& request) const; /** * A Callable wrapper for UpdateDetectorVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDetectorVersionOutcomeCallable UpdateDetectorVersionCallable(const UpdateDetectorVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateDetectorVersion, request); } /** * An Async wrapper for UpdateDetectorVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDetectorVersionAsync(const UpdateDetectorVersionRequestT& request, const UpdateDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateDetectorVersion, request, handler, context); } /** *

Updates the detector version's description. You can update the metadata for * any detector version (DRAFT, ACTIVE, or INACTIVE). *

See Also:

AWS * API Reference

*/ virtual Model::UpdateDetectorVersionMetadataOutcome UpdateDetectorVersionMetadata(const Model::UpdateDetectorVersionMetadataRequest& request) const; /** * A Callable wrapper for UpdateDetectorVersionMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDetectorVersionMetadataOutcomeCallable UpdateDetectorVersionMetadataCallable(const UpdateDetectorVersionMetadataRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateDetectorVersionMetadata, request); } /** * An Async wrapper for UpdateDetectorVersionMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDetectorVersionMetadataAsync(const UpdateDetectorVersionMetadataRequestT& request, const UpdateDetectorVersionMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateDetectorVersionMetadata, request, handler, context); } /** *

Updates the detector version’s status. You can perform the following * promotions or demotions using UpdateDetectorVersionStatus: * DRAFT to ACTIVE, ACTIVE to * INACTIVE, and INACTIVE to * ACTIVE.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDetectorVersionStatusOutcome UpdateDetectorVersionStatus(const Model::UpdateDetectorVersionStatusRequest& request) const; /** * A Callable wrapper for UpdateDetectorVersionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDetectorVersionStatusOutcomeCallable UpdateDetectorVersionStatusCallable(const UpdateDetectorVersionStatusRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateDetectorVersionStatus, request); } /** * An Async wrapper for UpdateDetectorVersionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDetectorVersionStatusAsync(const UpdateDetectorVersionStatusRequestT& request, const UpdateDetectorVersionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateDetectorVersionStatus, request, handler, context); } /** *

Updates the specified event with a new label.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEventLabelOutcome UpdateEventLabel(const Model::UpdateEventLabelRequest& request) const; /** * A Callable wrapper for UpdateEventLabel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEventLabelOutcomeCallable UpdateEventLabelCallable(const UpdateEventLabelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateEventLabel, request); } /** * An Async wrapper for UpdateEventLabel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEventLabelAsync(const UpdateEventLabelRequestT& request, const UpdateEventLabelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateEventLabel, request, handler, context); } /** *

Updates a list.

See Also:

AWS * API Reference

*/ virtual Model::UpdateListOutcome UpdateList(const Model::UpdateListRequest& request) const; /** * A Callable wrapper for UpdateList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateListOutcomeCallable UpdateListCallable(const UpdateListRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateList, request); } /** * An Async wrapper for UpdateList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateListAsync(const UpdateListRequestT& request, const UpdateListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateList, request, handler, context); } /** *

Updates model description.

See Also:

AWS * API Reference

*/ virtual Model::UpdateModelOutcome UpdateModel(const Model::UpdateModelRequest& request) const; /** * A Callable wrapper for UpdateModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateModelOutcomeCallable UpdateModelCallable(const UpdateModelRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateModel, request); } /** * An Async wrapper for UpdateModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateModelAsync(const UpdateModelRequestT& request, const UpdateModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateModel, request, handler, context); } /** *

Updates a model version. Updating a model version retrains an existing model * version using updated training data and produces a new minor version of the * model. You can update the training data set location and data access role * attributes using this action. This action creates and trains a new minor version * of the model, for example version 1.01, 1.02, 1.03.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateModelVersionOutcome UpdateModelVersion(const Model::UpdateModelVersionRequest& request) const; /** * A Callable wrapper for UpdateModelVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateModelVersionOutcomeCallable UpdateModelVersionCallable(const UpdateModelVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateModelVersion, request); } /** * An Async wrapper for UpdateModelVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateModelVersionAsync(const UpdateModelVersionRequestT& request, const UpdateModelVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateModelVersion, request, handler, context); } /** *

Updates the status of a model version.

You can perform the following * status updates:

  1. Change the TRAINING_IN_PROGRESS * status to TRAINING_CANCELLED.

  2. Change the * TRAINING_COMPLETE status to ACTIVE.

  3. *

    Change ACTIVE to INACTIVE.

    4. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateModelVersionStatusOutcome UpdateModelVersionStatus(const Model::UpdateModelVersionStatusRequest& request) const; /** * A Callable wrapper for UpdateModelVersionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateModelVersionStatusOutcomeCallable UpdateModelVersionStatusCallable(const UpdateModelVersionStatusRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateModelVersionStatus, request); } /** * An Async wrapper for UpdateModelVersionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateModelVersionStatusAsync(const UpdateModelVersionStatusRequestT& request, const UpdateModelVersionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateModelVersionStatus, request, handler, context); } /** *

Updates a rule's metadata. The description attribute can be * updated.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRuleMetadataOutcome UpdateRuleMetadata(const Model::UpdateRuleMetadataRequest& request) const; /** * A Callable wrapper for UpdateRuleMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRuleMetadataOutcomeCallable UpdateRuleMetadataCallable(const UpdateRuleMetadataRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateRuleMetadata, request); } /** * An Async wrapper for UpdateRuleMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRuleMetadataAsync(const UpdateRuleMetadataRequestT& request, const UpdateRuleMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateRuleMetadata, request, handler, context); } /** *

Updates a rule version resulting in a new rule version. Updates a rule * version resulting in a new rule version (version 1, 2, 3 ...).

See * Also:

AWS * API Reference

*/ virtual Model::UpdateRuleVersionOutcome UpdateRuleVersion(const Model::UpdateRuleVersionRequest& request) const; /** * A Callable wrapper for UpdateRuleVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRuleVersionOutcomeCallable UpdateRuleVersionCallable(const UpdateRuleVersionRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateRuleVersion, request); } /** * An Async wrapper for UpdateRuleVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRuleVersionAsync(const UpdateRuleVersionRequestT& request, const UpdateRuleVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateRuleVersion, request, handler, context); } /** *

Updates a variable.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVariableOutcome UpdateVariable(const Model::UpdateVariableRequest& request) const; /** * A Callable wrapper for UpdateVariable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVariableOutcomeCallable UpdateVariableCallable(const UpdateVariableRequestT& request) const { return SubmitCallable(&FraudDetectorClient::UpdateVariable, request); } /** * An Async wrapper for UpdateVariable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVariableAsync(const UpdateVariableRequestT& request, const UpdateVariableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&FraudDetectorClient::UpdateVariable, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const FraudDetectorClientConfiguration& clientConfiguration); FraudDetectorClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace FraudDetector } // namespace Aws