text:
#pragma once
#include <aws/ce/CostExplorer_EXPORTS.h>
#include <aws/ce/CostExplorerErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ce/model/CreateAnomalyMonitorResult.h>
#include <aws/ce/model/CreateAnomalySubscriptionResult.h>
#include <aws/ce/model/CreateCostCategoryDefinitionResult.h>
#include <aws/ce/model/DeleteAnomalyMonitorResult.h>
#include <aws/ce/model/DeleteAnomalySubscriptionResult.h>
#include <aws/ce/model/DeleteCostCategoryDefinitionResult.h>
#include <aws/ce/model/DescribeCostCategoryDefinitionResult.h>
#include <aws/ce/model/GetAnomaliesResult.h>
#include <aws/ce/model/GetAnomalyMonitorsResult.h>
#include <aws/ce/model/GetAnomalySubscriptionsResult.h>
#include <aws/ce/model/GetCostAndUsageResult.h>
#include <aws/ce/model/GetCostAndUsageWithResourcesResult.h>
#include <aws/ce/model/GetCostCategoriesResult.h>
#include <aws/ce/model/GetCostForecastResult.h>
#include <aws/ce/model/GetDimensionValuesResult.h>
#include <aws/ce/model/GetReservationCoverageResult.h>
#include <aws/ce/model/GetReservationPurchaseRecommendationResult.h>
#include <aws/ce/model/GetReservationUtilizationResult.h>
#include <aws/ce/model/GetRightsizingRecommendationResult.h>
#include <aws/ce/model/GetSavingsPlansCoverageResult.h>
#include <aws/ce/model/GetSavingsPlansPurchaseRecommendationResult.h>
#include <aws/ce/model/GetSavingsPlansUtilizationResult.h>
#include <aws/ce/model/GetSavingsPlansUtilizationDetailsResult.h>
#include <aws/ce/model/GetTagsResult.h>
#include <aws/ce/model/GetUsageForecastResult.h>
#include <aws/ce/model/ListCostCategoryDefinitionsResult.h>
#include <aws/ce/model/ProvideAnomalyFeedbackResult.h>
#include <aws/ce/model/UpdateAnomalyMonitorResult.h>
#include <aws/ce/model/UpdateAnomalySubscriptionResult.h>
#include <aws/ce/model/UpdateCostCategoryDefinitionResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>

namespace Aws
{

namespace Http
{
  class HttpClient;
  class HttpClientFactory;
} // namespace Http

namespace Utils
{
  template< typename R, typename E> class Outcome;
namespace Threading
{
  class Executor;
} // namespace Threading
} // namespace Utils

namespace Auth
{
  class AWSCredentials;
  class AWSCredentialsProvider;
} // namespace Auth

namespace Client
{
  class RetryStrategy;
} // namespace Client

namespace CostExplorer
{

namespace Model
{
        class CreateAnomalyMonitorRequest;
        class CreateAnomalySubscriptionRequest;
        class CreateCostCategoryDefinitionRequest;
        class DeleteAnomalyMonitorRequest;
        class DeleteAnomalySubscriptionRequest;
        class DeleteCostCategoryDefinitionRequest;
        class DescribeCostCategoryDefinitionRequest;
        class GetAnomaliesRequest;
        class GetAnomalyMonitorsRequest;
        class GetAnomalySubscriptionsRequest;
        class GetCostAndUsageRequest;
        class GetCostAndUsageWithResourcesRequest;
        class GetCostCategoriesRequest;
        class GetCostForecastRequest;
        class GetDimensionValuesRequest;
        class GetReservationCoverageRequest;
        class GetReservationPurchaseRecommendationRequest;
        class GetReservationUtilizationRequest;
        class GetRightsizingRecommendationRequest;
        class GetSavingsPlansCoverageRequest;
        class GetSavingsPlansPurchaseRecommendationRequest;
        class GetSavingsPlansUtilizationRequest;
        class GetSavingsPlansUtilizationDetailsRequest;
        class GetTagsRequest;
        class GetUsageForecastRequest;
        class ListCostCategoryDefinitionsRequest;
        class ProvideAnomalyFeedbackRequest;
        class UpdateAnomalyMonitorRequest;
        class UpdateAnomalySubscriptionRequest;
        class UpdateCostCategoryDefinitionRequest;

        typedef Aws::Utils::Outcome<CreateAnomalyMonitorResult, CostExplorerError> CreateAnomalyMonitorOutcome;
        typedef Aws::Utils::Outcome<CreateAnomalySubscriptionResult, CostExplorerError> CreateAnomalySubscriptionOutcome;
        typedef Aws::Utils::Outcome<CreateCostCategoryDefinitionResult, CostExplorerError> CreateCostCategoryDefinitionOutcome;
        typedef Aws::Utils::Outcome<DeleteAnomalyMonitorResult, CostExplorerError> DeleteAnomalyMonitorOutcome;
        typedef Aws::Utils::Outcome<DeleteAnomalySubscriptionResult, CostExplorerError> DeleteAnomalySubscriptionOutcome;
        typedef Aws::Utils::Outcome<DeleteCostCategoryDefinitionResult, CostExplorerError> DeleteCostCategoryDefinitionOutcome;
        typedef Aws::Utils::Outcome<DescribeCostCategoryDefinitionResult, CostExplorerError> DescribeCostCategoryDefinitionOutcome;
        typedef Aws::Utils::Outcome<GetAnomaliesResult, CostExplorerError> GetAnomaliesOutcome;
        typedef Aws::Utils::Outcome<GetAnomalyMonitorsResult, CostExplorerError> GetAnomalyMonitorsOutcome;
        typedef Aws::Utils::Outcome<GetAnomalySubscriptionsResult, CostExplorerError> GetAnomalySubscriptionsOutcome;
        typedef Aws::Utils::Outcome<GetCostAndUsageResult, CostExplorerError> GetCostAndUsageOutcome;
        typedef Aws::Utils::Outcome<GetCostAndUsageWithResourcesResult, CostExplorerError> GetCostAndUsageWithResourcesOutcome;
        typedef Aws::Utils::Outcome<GetCostCategoriesResult, CostExplorerError> GetCostCategoriesOutcome;
        typedef Aws::Utils::Outcome<GetCostForecastResult, CostExplorerError> GetCostForecastOutcome;
        typedef Aws::Utils::Outcome<GetDimensionValuesResult, CostExplorerError> GetDimensionValuesOutcome;
        typedef Aws::Utils::Outcome<GetReservationCoverageResult, CostExplorerError> GetReservationCoverageOutcome;
        typedef Aws::Utils::Outcome<GetReservationPurchaseRecommendationResult, CostExplorerError> GetReservationPurchaseRecommendationOutcome;
        typedef Aws::Utils::Outcome<GetReservationUtilizationResult, CostExplorerError> GetReservationUtilizationOutcome;
        typedef Aws::Utils::Outcome<GetRightsizingRecommendationResult, CostExplorerError> GetRightsizingRecommendationOutcome;
        typedef Aws::Utils::Outcome<GetSavingsPlansCoverageResult, CostExplorerError> GetSavingsPlansCoverageOutcome;
        typedef Aws::Utils::Outcome<GetSavingsPlansPurchaseRecommendationResult, CostExplorerError> GetSavingsPlansPurchaseRecommendationOutcome;
        typedef Aws::Utils::Outcome<GetSavingsPlansUtilizationResult, CostExplorerError> GetSavingsPlansUtilizationOutcome;
        typedef Aws::Utils::Outcome<GetSavingsPlansUtilizationDetailsResult, CostExplorerError> GetSavingsPlansUtilizationDetailsOutcome;
        typedef Aws::Utils::Outcome<GetTagsResult, CostExplorerError> GetTagsOutcome;
        typedef Aws::Utils::Outcome<GetUsageForecastResult, CostExplorerError> GetUsageForecastOutcome;
        typedef Aws::Utils::Outcome<ListCostCategoryDefinitionsResult, CostExplorerError> ListCostCategoryDefinitionsOutcome;
        typedef Aws::Utils::Outcome<ProvideAnomalyFeedbackResult, CostExplorerError> ProvideAnomalyFeedbackOutcome;
        typedef Aws::Utils::Outcome<UpdateAnomalyMonitorResult, CostExplorerError> UpdateAnomalyMonitorOutcome;
        typedef Aws::Utils::Outcome<UpdateAnomalySubscriptionResult, CostExplorerError> UpdateAnomalySubscriptionOutcome;
        typedef Aws::Utils::Outcome<UpdateCostCategoryDefinitionResult, CostExplorerError> UpdateCostCategoryDefinitionOutcome;

        typedef std::future<CreateAnomalyMonitorOutcome> CreateAnomalyMonitorOutcomeCallable;
        typedef std::future<CreateAnomalySubscriptionOutcome> CreateAnomalySubscriptionOutcomeCallable;
        typedef std::future<CreateCostCategoryDefinitionOutcome> CreateCostCategoryDefinitionOutcomeCallable;
        typedef std::future<DeleteAnomalyMonitorOutcome> DeleteAnomalyMonitorOutcomeCallable;
        typedef std::future<DeleteAnomalySubscriptionOutcome> DeleteAnomalySubscriptionOutcomeCallable;
        typedef std::future<DeleteCostCategoryDefinitionOutcome> DeleteCostCategoryDefinitionOutcomeCallable;
        typedef std::future<DescribeCostCategoryDefinitionOutcome> DescribeCostCategoryDefinitionOutcomeCallable;
        typedef std::future<GetAnomaliesOutcome> GetAnomaliesOutcomeCallable;
        typedef std::future<GetAnomalyMonitorsOutcome> GetAnomalyMonitorsOutcomeCallable;
        typedef std::future<GetAnomalySubscriptionsOutcome> GetAnomalySubscriptionsOutcomeCallable;
        typedef std::future<GetCostAndUsageOutcome> GetCostAndUsageOutcomeCallable;
        typedef std::future<GetCostAndUsageWithResourcesOutcome> GetCostAndUsageWithResourcesOutcomeCallable;
        typedef std::future<GetCostCategoriesOutcome> GetCostCategoriesOutcomeCallable;
        typedef std::future<GetCostForecastOutcome> GetCostForecastOutcomeCallable;
        typedef std::future<GetDimensionValuesOutcome> GetDimensionValuesOutcomeCallable;
        typedef std::future<GetReservationCoverageOutcome> GetReservationCoverageOutcomeCallable;
        typedef std::future<GetReservationPurchaseRecommendationOutcome> GetReservationPurchaseRecommendationOutcomeCallable;
        typedef std::future<GetReservationUtilizationOutcome> GetReservationUtilizationOutcomeCallable;
        typedef std::future<GetRightsizingRecommendationOutcome> GetRightsizingRecommendationOutcomeCallable;
        typedef std::future<GetSavingsPlansCoverageOutcome> GetSavingsPlansCoverageOutcomeCallable;
        typedef std::future<GetSavingsPlansPurchaseRecommendationOutcome> GetSavingsPlansPurchaseRecommendationOutcomeCallable;
        typedef std::future<GetSavingsPlansUtilizationOutcome> GetSavingsPlansUtilizationOutcomeCallable;
        typedef std::future<GetSavingsPlansUtilizationDetailsOutcome> GetSavingsPlansUtilizationDetailsOutcomeCallable;
        typedef std::future<GetTagsOutcome> GetTagsOutcomeCallable;
        typedef std::future<GetUsageForecastOutcome> GetUsageForecastOutcomeCallable;
        typedef std::future<ListCostCategoryDefinitionsOutcome> ListCostCategoryDefinitionsOutcomeCallable;
        typedef std::future<ProvideAnomalyFeedbackOutcome> ProvideAnomalyFeedbackOutcomeCallable;
        typedef std::future<UpdateAnomalyMonitorOutcome> UpdateAnomalyMonitorOutcomeCallable;
        typedef std::future<UpdateAnomalySubscriptionOutcome> UpdateAnomalySubscriptionOutcomeCallable;
        typedef std::future<UpdateCostCategoryDefinitionOutcome> UpdateCostCategoryDefinitionOutcomeCallable;
} // namespace Model

  class CostExplorerClient;

    typedef std::function<void(const CostExplorerClient*, const Model::CreateAnomalyMonitorRequest&, const Model::CreateAnomalyMonitorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateAnomalyMonitorResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::CreateAnomalySubscriptionRequest&, const Model::CreateAnomalySubscriptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateAnomalySubscriptionResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::CreateCostCategoryDefinitionRequest&, const Model::CreateCostCategoryDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateCostCategoryDefinitionResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::DeleteAnomalyMonitorRequest&, const Model::DeleteAnomalyMonitorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAnomalyMonitorResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::DeleteAnomalySubscriptionRequest&, const Model::DeleteAnomalySubscriptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAnomalySubscriptionResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::DeleteCostCategoryDefinitionRequest&, const Model::DeleteCostCategoryDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteCostCategoryDefinitionResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::DescribeCostCategoryDefinitionRequest&, const Model::DescribeCostCategoryDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeCostCategoryDefinitionResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetAnomaliesRequest&, const Model::GetAnomaliesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetAnomaliesResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetAnomalyMonitorsRequest&, const Model::GetAnomalyMonitorsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetAnomalyMonitorsResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetAnomalySubscriptionsRequest&, const Model::GetAnomalySubscriptionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetAnomalySubscriptionsResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetCostAndUsageRequest&, const Model::GetCostAndUsageOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCostAndUsageResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetCostAndUsageWithResourcesRequest&, const Model::GetCostAndUsageWithResourcesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCostAndUsageWithResourcesResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetCostCategoriesRequest&, const Model::GetCostCategoriesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCostCategoriesResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetCostForecastRequest&, const Model::GetCostForecastOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCostForecastResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetDimensionValuesRequest&, const Model::GetDimensionValuesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetDimensionValuesResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetReservationCoverageRequest&, const Model::GetReservationCoverageOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetReservationCoverageResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetReservationPurchaseRecommendationRequest&, const Model::GetReservationPurchaseRecommendationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetReservationPurchaseRecommendationResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetReservationUtilizationRequest&, const Model::GetReservationUtilizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetReservationUtilizationResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetRightsizingRecommendationRequest&, const Model::GetRightsizingRecommendationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetRightsizingRecommendationResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetSavingsPlansCoverageRequest&, const Model::GetSavingsPlansCoverageOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetSavingsPlansCoverageResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetSavingsPlansPurchaseRecommendationRequest&, const Model::GetSavingsPlansPurchaseRecommendationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetSavingsPlansPurchaseRecommendationResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetSavingsPlansUtilizationRequest&, const Model::GetSavingsPlansUtilizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetSavingsPlansUtilizationResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetSavingsPlansUtilizationDetailsRequest&, const Model::GetSavingsPlansUtilizationDetailsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetSavingsPlansUtilizationDetailsResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetTagsRequest&, const Model::GetTagsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetTagsResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::GetUsageForecastRequest&, const Model::GetUsageForecastOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetUsageForecastResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::ListCostCategoryDefinitionsRequest&, const Model::ListCostCategoryDefinitionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListCostCategoryDefinitionsResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::ProvideAnomalyFeedbackRequest&, const Model::ProvideAnomalyFeedbackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ProvideAnomalyFeedbackResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::UpdateAnomalyMonitorRequest&, const Model::UpdateAnomalyMonitorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateAnomalyMonitorResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::UpdateAnomalySubscriptionRequest&, const Model::UpdateAnomalySubscriptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateAnomalySubscriptionResponseReceivedHandler;
    typedef std::function<void(const CostExplorerClient*, const Model::UpdateCostCategoryDefinitionRequest&, const Model::UpdateCostCategoryDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateCostCategoryDefinitionResponseReceivedHandler;

  /**
   *
The Cost Explorer API enables you to programmatically query your cost and
   * usage data. You can query for aggregated data such as total monthly costs or
   * total daily usage. You can also query for granular data, such as the number of
   * daily write operations for Amazon DynamoDB database tables in your production
   * environment.

Service Endpoint

The Cost Explorer API provides the
   * following endpoint:

   * https://ce.us-east-1.amazonaws.com

For
   * information about costs associated with the Cost Explorer API, see AWS Cost Management
   * Pricing.

   */
  class AWS_COSTEXPLORER_API CostExplorerClient : public Aws::Client::AWSJsonClient
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;

       /**
        * 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.
        */
        CostExplorerClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::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.
        */
        CostExplorerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::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
        */
        CostExplorerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

        virtual ~CostExplorerClient();

        /**
         *
Creates a new cost anomaly detection monitor with the requested type and
         * monitor specification.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateAnomalyMonitorOutcome CreateAnomalyMonitor(const Model::CreateAnomalyMonitorRequest& request) const;

        /**
         *
Creates a new cost anomaly detection monitor with the requested type and
         * monitor specification.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateAnomalyMonitorOutcomeCallable CreateAnomalyMonitorCallable(const Model::CreateAnomalyMonitorRequest& request) const;

        /**
         *
Creates a new cost anomaly detection monitor with the requested type and
         * monitor specification.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateAnomalyMonitorAsync(const Model::CreateAnomalyMonitorRequest& request, const CreateAnomalyMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Adds a subscription to a cost anomaly detection monitor. You can use each
         * subscription to define subscribers with email or SNS notifications. Email
         * subscribers can set a dollar threshold and a time frequency for receiving
         * notifications.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateAnomalySubscriptionOutcome CreateAnomalySubscription(const Model::CreateAnomalySubscriptionRequest& request) const;

        /**
         *
Adds a subscription to a cost anomaly detection monitor. You can use each
         * subscription to define subscribers with email or SNS notifications. Email
         * subscribers can set a dollar threshold and a time frequency for receiving
         * notifications.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateAnomalySubscriptionOutcomeCallable CreateAnomalySubscriptionCallable(const Model::CreateAnomalySubscriptionRequest& request) const;

        /**
         *
Adds a subscription to a cost anomaly detection monitor. You can use each
         * subscription to define subscribers with email or SNS notifications. Email
         * subscribers can set a dollar threshold and a time frequency for receiving
         * notifications.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateAnomalySubscriptionAsync(const Model::CreateAnomalySubscriptionRequest& request, const CreateAnomalySubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a new Cost Category with the requested name and rules.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::CreateCostCategoryDefinitionOutcome CreateCostCategoryDefinition(const Model::CreateCostCategoryDefinitionRequest& request) const;

        /**
         *
Creates a new Cost Category with the requested name and rules.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateCostCategoryDefinitionOutcomeCallable CreateCostCategoryDefinitionCallable(const Model::CreateCostCategoryDefinitionRequest& request) const;

        /**
         *
Creates a new Cost Category with the requested name and rules.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateCostCategoryDefinitionAsync(const Model::CreateCostCategoryDefinitionRequest& request, const CreateCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a cost anomaly monitor.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteAnomalyMonitorOutcome DeleteAnomalyMonitor(const Model::DeleteAnomalyMonitorRequest& request) const;

        /**
         *
Deletes a cost anomaly monitor.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteAnomalyMonitorOutcomeCallable DeleteAnomalyMonitorCallable(const Model::DeleteAnomalyMonitorRequest& request) const;

        /**
         *
Deletes a cost anomaly monitor.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteAnomalyMonitorAsync(const Model::DeleteAnomalyMonitorRequest& request, const DeleteAnomalyMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a cost anomaly subscription.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteAnomalySubscriptionOutcome DeleteAnomalySubscription(const Model::DeleteAnomalySubscriptionRequest& request) const;

        /**
         *
Deletes a cost anomaly subscription.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteAnomalySubscriptionOutcomeCallable DeleteAnomalySubscriptionCallable(const Model::DeleteAnomalySubscriptionRequest& request) const;

        /**
         *
Deletes a cost anomaly subscription.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteAnomalySubscriptionAsync(const Model::DeleteAnomalySubscriptionRequest& request, const DeleteAnomalySubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a Cost Category. Expenses from this month going forward will no
         * longer be categorized with this Cost Category.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteCostCategoryDefinitionOutcome DeleteCostCategoryDefinition(const Model::DeleteCostCategoryDefinitionRequest& request) const;

        /**
         *
Deletes a Cost Category. Expenses from this month going forward will no
         * longer be categorized with this Cost Category.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteCostCategoryDefinitionOutcomeCallable DeleteCostCategoryDefinitionCallable(const Model::DeleteCostCategoryDefinitionRequest& request) const;

        /**
         *
Deletes a Cost Category. Expenses from this month going forward will no
         * longer be categorized with this Cost Category.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteCostCategoryDefinitionAsync(const Model::DeleteCostCategoryDefinitionRequest& request, const DeleteCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns the name, ARN, rules, definition, and effective dates of a Cost
         * Category that's defined in the account.

You have the option to use
         * EffectiveOn to return a Cost Category that is active on a specific
         * date. If there is no EffectiveOn specified, you'll see a Cost
         * Category that is effective on the current date. If Cost Category is still
         * effective, EffectiveEnd is omitted in the response.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeCostCategoryDefinitionOutcome DescribeCostCategoryDefinition(const Model::DescribeCostCategoryDefinitionRequest& request) const;

        /**
         *
Returns the name, ARN, rules, definition, and effective dates of a Cost
         * Category that's defined in the account.

You have the option to use
         * EffectiveOn to return a Cost Category that is active on a specific
         * date. If there is no EffectiveOn specified, you'll see a Cost
         * Category that is effective on the current date. If Cost Category is still
         * effective, EffectiveEnd is omitted in the response.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeCostCategoryDefinitionOutcomeCallable DescribeCostCategoryDefinitionCallable(const Model::DescribeCostCategoryDefinitionRequest& request) const;

        /**
         *
Returns the name, ARN, rules, definition, and effective dates of a Cost
         * Category that's defined in the account.

You have the option to use
         * EffectiveOn to return a Cost Category that is active on a specific
         * date. If there is no EffectiveOn specified, you'll see a Cost
         * Category that is effective on the current date. If Cost Category is still
         * effective, EffectiveEnd is omitted in the response.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeCostCategoryDefinitionAsync(const Model::DescribeCostCategoryDefinitionRequest& request, const DescribeCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves all of the cost anomalies detected on your account, during the time
         * period specified by the DateInterval object.

See
         * Also:
   AWS API
         * Reference

         */
        virtual Model::GetAnomaliesOutcome GetAnomalies(const Model::GetAnomaliesRequest& request) const;

        /**
         *
Retrieves all of the cost anomalies detected on your account, during the time
         * period specified by the DateInterval object.

See
         * Also:
   AWS API
         * Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetAnomaliesOutcomeCallable GetAnomaliesCallable(const Model::GetAnomaliesRequest& request) const;

        /**
         *
Retrieves all of the cost anomalies detected on your account, during the time
         * period specified by the DateInterval object.

See
         * Also:
   AWS API
         * Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetAnomaliesAsync(const Model::GetAnomaliesRequest& request, const GetAnomaliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the cost anomaly monitor definitions for your account. You can
         * filter using a list of cost anomaly monitor Amazon Resource Names (ARNs).
         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetAnomalyMonitorsOutcome GetAnomalyMonitors(const Model::GetAnomalyMonitorsRequest& request) const;

        /**
         *
Retrieves the cost anomaly monitor definitions for your account. You can
         * filter using a list of cost anomaly monitor Amazon Resource Names (ARNs).
         *

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetAnomalyMonitorsOutcomeCallable GetAnomalyMonitorsCallable(const Model::GetAnomalyMonitorsRequest& request) const;

        /**
         *
Retrieves the cost anomaly monitor definitions for your account. You can
         * filter using a list of cost anomaly monitor Amazon Resource Names (ARNs).
         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetAnomalyMonitorsAsync(const Model::GetAnomalyMonitorsRequest& request, const GetAnomalyMonitorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the cost anomaly subscription objects for your account. You can
         * filter using a list of cost anomaly monitor Amazon Resource Names (ARNs).
         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetAnomalySubscriptionsOutcome GetAnomalySubscriptions(const Model::GetAnomalySubscriptionsRequest& request) const;

        /**
         *
Retrieves the cost anomaly subscription objects for your account. You can
         * filter using a list of cost anomaly monitor Amazon Resource Names (ARNs).
         *

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetAnomalySubscriptionsOutcomeCallable GetAnomalySubscriptionsCallable(const Model::GetAnomalySubscriptionsRequest& request) const;

        /**
         *
Retrieves the cost anomaly subscription objects for your account. You can
         * filter using a list of cost anomaly monitor Amazon Resource Names (ARNs).
         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetAnomalySubscriptionsAsync(const Model::GetAnomalySubscriptionsRequest& request, const GetAnomalySubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves cost and usage metrics for your account. You can specify which cost
         * and usage-related metric, such as BlendedCosts or
         * UsageQuantity, that you want the request to return. You can also
         * filter and group your data by various dimensions, such as SERVICE
         * or AZ, in a specific time range. For a complete list of valid
         * dimensions, see the GetDimensionValues
         * operation. Management account in an organization in AWS Organizations have
         * access to all member accounts.

For information about filter limitations,
         * see Quotas
         * and restrictions in the Billing and Cost Management User
         * Guide.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetCostAndUsageOutcome GetCostAndUsage(const Model::GetCostAndUsageRequest& request) const;

        /**
         *
Retrieves cost and usage metrics for your account. You can specify which cost
         * and usage-related metric, such as BlendedCosts or
         * UsageQuantity, that you want the request to return. You can also
         * filter and group your data by various dimensions, such as SERVICE
         * or AZ, in a specific time range. For a complete list of valid
         * dimensions, see the GetDimensionValues
         * operation. Management account in an organization in AWS Organizations have
         * access to all member accounts.

For information about filter limitations,
         * see Quotas
         * and restrictions in the Billing and Cost Management User
         * Guide.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetCostAndUsageOutcomeCallable GetCostAndUsageCallable(const Model::GetCostAndUsageRequest& request) const;

        /**
         *
Retrieves cost and usage metrics for your account. You can specify which cost
         * and usage-related metric, such as BlendedCosts or
         * UsageQuantity, that you want the request to return. You can also
         * filter and group your data by various dimensions, such as SERVICE
         * or AZ, in a specific time range. For a complete list of valid
         * dimensions, see the GetDimensionValues
         * operation. Management account in an organization in AWS Organizations have
         * access to all member accounts.

For information about filter limitations,
         * see Quotas
         * and restrictions in the Billing and Cost Management User
         * Guide.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetCostAndUsageAsync(const Model::GetCostAndUsageRequest& request, const GetCostAndUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves cost and usage metrics with resources for your account. You can
         * specify which cost and usage-related metric, such as BlendedCosts
         * or UsageQuantity, that you want the request to return. You can also
         * filter and group your data by various dimensions, such as SERVICE
         * or AZ, in a specific time range. For a complete list of valid
         * dimensions, see the GetDimensionValues
         * operation. Management account in an organization in AWS Organizations have
         * access to all member accounts. This API is currently available for the Amazon
         * Elastic Compute Cloud – Compute service only.

This is an opt-in
         * only feature. You can enable this feature from the Cost Explorer Settings page.
         * For information on how to access the Settings page, see Controlling
         * Access for Cost Explorer in the AWS Billing and Cost Management User
         * Guide.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetCostAndUsageWithResourcesOutcome GetCostAndUsageWithResources(const Model::GetCostAndUsageWithResourcesRequest& request) const;

        /**
         *
Retrieves cost and usage metrics with resources for your account. You can
         * specify which cost and usage-related metric, such as BlendedCosts
         * or UsageQuantity, that you want the request to return. You can also
         * filter and group your data by various dimensions, such as SERVICE
         * or AZ, in a specific time range. For a complete list of valid
         * dimensions, see the GetDimensionValues
         * operation. Management account in an organization in AWS Organizations have
         * access to all member accounts. This API is currently available for the Amazon
         * Elastic Compute Cloud – Compute service only.

This is an opt-in
         * only feature. You can enable this feature from the Cost Explorer Settings page.
         * For information on how to access the Settings page, see Controlling
         * Access for Cost Explorer in the AWS Billing and Cost Management User
         * Guide.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetCostAndUsageWithResourcesOutcomeCallable GetCostAndUsageWithResourcesCallable(const Model::GetCostAndUsageWithResourcesRequest& request) const;

        /**
         *
Retrieves cost and usage metrics with resources for your account. You can
         * specify which cost and usage-related metric, such as BlendedCosts
         * or UsageQuantity, that you want the request to return. You can also
         * filter and group your data by various dimensions, such as SERVICE
         * or AZ, in a specific time range. For a complete list of valid
         * dimensions, see the GetDimensionValues
         * operation. Management account in an organization in AWS Organizations have
         * access to all member accounts. This API is currently available for the Amazon
         * Elastic Compute Cloud – Compute service only.

This is an opt-in
         * only feature. You can enable this feature from the Cost Explorer Settings page.
         * For information on how to access the Settings page, see Controlling
         * Access for Cost Explorer in the AWS Billing and Cost Management User
         * Guide.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetCostAndUsageWithResourcesAsync(const Model::GetCostAndUsageWithResourcesRequest& request, const GetCostAndUsageWithResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves an array of Cost Category names and values incurred cost.

         *
If some Cost Category names and values are not associated with any
         * cost, they will not be returned by this API.

See Also:

         * AWS
         * API Reference

         */
        virtual Model::GetCostCategoriesOutcome GetCostCategories(const Model::GetCostCategoriesRequest& request) const;

        /**
         *
Retrieves an array of Cost Category names and values incurred cost.

         *
If some Cost Category names and values are not associated with any
         * cost, they will not be returned by this API.

See Also:

         * AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetCostCategoriesOutcomeCallable GetCostCategoriesCallable(const Model::GetCostCategoriesRequest& request) const;

        /**
         *
Retrieves an array of Cost Category names and values incurred cost.

         *
If some Cost Category names and values are not associated with any
         * cost, they will not be returned by this API.

See Also:

         * AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetCostCategoriesAsync(const Model::GetCostCategoriesRequest& request, const GetCostCategoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves a forecast for how much Amazon Web Services predicts that you will
         * spend over the forecast time period that you select, based on your past costs.
         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetCostForecastOutcome GetCostForecast(const Model::GetCostForecastRequest& request) const;

        /**
         *
Retrieves a forecast for how much Amazon Web Services predicts that you will
         * spend over the forecast time period that you select, based on your past costs.
         *

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetCostForecastOutcomeCallable GetCostForecastCallable(const Model::GetCostForecastRequest& request) const;

        /**
         *
Retrieves a forecast for how much Amazon Web Services predicts that you will
         * spend over the forecast time period that you select, based on your past costs.
         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetCostForecastAsync(const Model::GetCostForecastRequest& request, const GetCostForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves all available filter values for a specified filter over a period of
         * time. You can search the dimension values for an arbitrary string.
         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetDimensionValuesOutcome GetDimensionValues(const Model::GetDimensionValuesRequest& request) const;

        /**
         *
Retrieves all available filter values for a specified filter over a period of
         * time. You can search the dimension values for an arbitrary string.
         *

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetDimensionValuesOutcomeCallable GetDimensionValuesCallable(const Model::GetDimensionValuesRequest& request) const;

        /**
         *
Retrieves all available filter values for a specified filter over a period of
         * time. You can search the dimension values for an arbitrary string.
         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetDimensionValuesAsync(const Model::GetDimensionValuesRequest& request, const GetDimensionValuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the reservation coverage for your account. This enables you to see
         * how much of your Amazon Elastic Compute Cloud, Amazon ElastiCache, Amazon
         * Relational Database Service, or Amazon Redshift usage is covered by a
         * reservation. An organization's management account can see the coverage of the
         * associated member accounts. This supports dimensions, Cost Categories, and
         * nested expressions. For any time period, you can filter data about reservation
         * usage by the following dimensions:

AZ

         *
CACHE_ENGINE

DATABASE_ENGINE

         *
DEPLOYMENT_OPTION

INSTANCE_TYPE

         *
LINKED_ACCOUNT

OPERATING_SYSTEM

         *
PLATFORM

REGION

SERVICE

         *
TAG

TENANCY

To determine valid values
         * for a dimension, use the GetDimensionValues operation.
         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetReservationCoverageOutcome GetReservationCoverage(const Model::GetReservationCoverageRequest& request) const;

        /**
         *
Retrieves the reservation coverage for your account. This enables you to see
         * how much of your Amazon Elastic Compute Cloud, Amazon ElastiCache, Amazon
         * Relational Database Service, or Amazon Redshift usage is covered by a
         * reservation. An organization's management account can see the coverage of the
         * associated member accounts. This supports dimensions, Cost Categories, and
         * nested expressions. For any time period, you can filter data about reservation
         * usage by the following dimensions:

AZ

         *
CACHE_ENGINE

DATABASE_ENGINE

         *
DEPLOYMENT_OPTION

INSTANCE_TYPE

         *
LINKED_ACCOUNT

OPERATING_SYSTEM

         *
PLATFORM

REGION

SERVICE

         *
TAG

TENANCY

To determine valid values
         * for a dimension, use the GetDimensionValues operation.
         *

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetReservationCoverageOutcomeCallable GetReservationCoverageCallable(const Model::GetReservationCoverageRequest& request) const;

        /**
         *
Retrieves the reservation coverage for your account. This enables you to see
         * how much of your Amazon Elastic Compute Cloud, Amazon ElastiCache, Amazon
         * Relational Database Service, or Amazon Redshift usage is covered by a
         * reservation. An organization's management account can see the coverage of the
         * associated member accounts. This supports dimensions, Cost Categories, and
         * nested expressions. For any time period, you can filter data about reservation
         * usage by the following dimensions:

AZ

         *
CACHE_ENGINE

DATABASE_ENGINE

         *
DEPLOYMENT_OPTION

INSTANCE_TYPE

         *
LINKED_ACCOUNT

OPERATING_SYSTEM

         *
PLATFORM

REGION

SERVICE

         *
TAG

TENANCY

To determine valid values
         * for a dimension, use the GetDimensionValues operation.
         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetReservationCoverageAsync(const Model::GetReservationCoverageRequest& request, const GetReservationCoverageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Gets recommendations for which reservations to purchase. These
         * recommendations could help you reduce your costs. Reservations provide a
         * discounted hourly rate (up to 75%) compared to On-Demand pricing.

AWS
         * generates your recommendations by identifying your On-Demand usage during a
         * specific time period and collecting your usage into categories that are eligible
         * for a reservation. After AWS has these categories, it simulates every
         * combination of reservations in each category of usage to identify the best
         * number of each type of RI to purchase to maximize your estimated savings.

         *
For example, AWS automatically aggregates your Amazon EC2 Linux, shared
         * tenancy, and c4 family usage in the US West (Oregon) Region and recommends that
         * you buy size-flexible regional reservations to apply to the c4 family usage. AWS
         * recommends the smallest size instance in an instance family. This makes it
         * easier to purchase a size-flexible RI. AWS also shows the equal number of
         * normalized units so that you can purchase any instance size that you want. For
         * this example, your RI recommendation would be for c4.large because
         * that is the smallest size instance in the c4 instance family.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::GetReservationPurchaseRecommendationOutcome GetReservationPurchaseRecommendation(const Model::GetReservationPurchaseRecommendationRequest& request) const;

        /**
         *
Gets recommendations for which reservations to purchase. These
         * recommendations could help you reduce your costs. Reservations provide a
         * discounted hourly rate (up to 75%) compared to On-Demand pricing.

AWS
         * generates your recommendations by identifying your On-Demand usage during a
         * specific time period and collecting your usage into categories that are eligible
         * for a reservation. After AWS has these categories, it simulates every
         * combination of reservations in each category of usage to identify the best
         * number of each type of RI to purchase to maximize your estimated savings.

         *
For example, AWS automatically aggregates your Amazon EC2 Linux, shared
         * tenancy, and c4 family usage in the US West (Oregon) Region and recommends that
         * you buy size-flexible regional reservations to apply to the c4 family usage. AWS
         * recommends the smallest size instance in an instance family. This makes it
         * easier to purchase a size-flexible RI. AWS also shows the equal number of
         * normalized units so that you can purchase any instance size that you want. For
         * this example, your RI recommendation would be for c4.large because
         * that is the smallest size instance in the c4 instance family.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetReservationPurchaseRecommendationOutcomeCallable GetReservationPurchaseRecommendationCallable(const Model::GetReservationPurchaseRecommendationRequest& request) const;

        /**
         *
Gets recommendations for which reservations to purchase. These
         * recommendations could help you reduce your costs. Reservations provide a
         * discounted hourly rate (up to 75%) compared to On-Demand pricing.

AWS
         * generates your recommendations by identifying your On-Demand usage during a
         * specific time period and collecting your usage into categories that are eligible
         * for a reservation. After AWS has these categories, it simulates every
         * combination of reservations in each category of usage to identify the best
         * number of each type of RI to purchase to maximize your estimated savings.

         *
For example, AWS automatically aggregates your Amazon EC2 Linux, shared
         * tenancy, and c4 family usage in the US West (Oregon) Region and recommends that
         * you buy size-flexible regional reservations to apply to the c4 family usage. AWS
         * recommends the smallest size instance in an instance family. This makes it
         * easier to purchase a size-flexible RI. AWS also shows the equal number of
         * normalized units so that you can purchase any instance size that you want. For
         * this example, your RI recommendation would be for c4.large because
         * that is the smallest size instance in the c4 instance family.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetReservationPurchaseRecommendationAsync(const Model::GetReservationPurchaseRecommendationRequest& request, const GetReservationPurchaseRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the reservation utilization for your account. Management account in
         * an organization have access to member accounts. You can filter data by
         * dimensions in a time period. You can use GetDimensionValues to
         * determine the possible dimension values. Currently, you can group only by
         * SUBSCRIPTION_ID.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetReservationUtilizationOutcome GetReservationUtilization(const Model::GetReservationUtilizationRequest& request) const;

        /**
         *
Retrieves the reservation utilization for your account. Management account in
         * an organization have access to member accounts. You can filter data by
         * dimensions in a time period. You can use GetDimensionValues to
         * determine the possible dimension values. Currently, you can group only by
         * SUBSCRIPTION_ID.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetReservationUtilizationOutcomeCallable GetReservationUtilizationCallable(const Model::GetReservationUtilizationRequest& request) const;

        /**
         *
Retrieves the reservation utilization for your account. Management account in
         * an organization have access to member accounts. You can filter data by
         * dimensions in a time period. You can use GetDimensionValues to
         * determine the possible dimension values. Currently, you can group only by
         * SUBSCRIPTION_ID.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetReservationUtilizationAsync(const Model::GetReservationUtilizationRequest& request, const GetReservationUtilizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates recommendations that help you save cost by identifying idle and
         * underutilized Amazon EC2 instances.

Recommendations are generated to
         * either downsize or terminate instances, along with providing savings detail and
         * metrics. For details on calculation and function, see Optimizing
         * Your Cost with Rightsizing Recommendations in the AWS Billing and Cost
         * Management User Guide.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetRightsizingRecommendationOutcome GetRightsizingRecommendation(const Model::GetRightsizingRecommendationRequest& request) const;

        /**
         *
Creates recommendations that help you save cost by identifying idle and
         * underutilized Amazon EC2 instances.

Recommendations are generated to
         * either downsize or terminate instances, along with providing savings detail and
         * metrics. For details on calculation and function, see Optimizing
         * Your Cost with Rightsizing Recommendations in the AWS Billing and Cost
         * Management User Guide.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetRightsizingRecommendationOutcomeCallable GetRightsizingRecommendationCallable(const Model::GetRightsizingRecommendationRequest& request) const;

        /**
         *
Creates recommendations that help you save cost by identifying idle and
         * underutilized Amazon EC2 instances.

Recommendations are generated to
         * either downsize or terminate instances, along with providing savings detail and
         * metrics. For details on calculation and function, see Optimizing
         * Your Cost with Rightsizing Recommendations in the AWS Billing and Cost
         * Management User Guide.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetRightsizingRecommendationAsync(const Model::GetRightsizingRecommendationRequest& request, const GetRightsizingRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the Savings Plans covered for your account. This enables you to see
         * how much of your cost is covered by a Savings Plan. An organization's management
         * account can see the coverage of the associated member accounts. This supports
         * dimensions, Cost Categories, and nested expressions. For any time period, you
         * can filter data for Savings Plans usage with the following dimensions:

         *

 LINKED_ACCOUNT

 REGION
         *

 SERVICE

         * INSTANCE_FAMILY

To determine valid values for a
         * dimension, use the GetDimensionValues operation.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::GetSavingsPlansCoverageOutcome GetSavingsPlansCoverage(const Model::GetSavingsPlansCoverageRequest& request) const;

        /**
         *
Retrieves the Savings Plans covered for your account. This enables you to see
         * how much of your cost is covered by a Savings Plan. An organization's management
         * account can see the coverage of the associated member accounts. This supports
         * dimensions, Cost Categories, and nested expressions. For any time period, you
         * can filter data for Savings Plans usage with the following dimensions:

         *

 LINKED_ACCOUNT

 REGION
         *

 SERVICE

         * INSTANCE_FAMILY

To determine valid values for a
         * dimension, use the GetDimensionValues operation.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetSavingsPlansCoverageOutcomeCallable GetSavingsPlansCoverageCallable(const Model::GetSavingsPlansCoverageRequest& request) const;

        /**
         *
Retrieves the Savings Plans covered for your account. This enables you to see
         * how much of your cost is covered by a Savings Plan. An organization's management
         * account can see the coverage of the associated member accounts. This supports
         * dimensions, Cost Categories, and nested expressions. For any time period, you
         * can filter data for Savings Plans usage with the following dimensions:

         *

 LINKED_ACCOUNT

 REGION
         *

 SERVICE

         * INSTANCE_FAMILY

To determine valid values for a
         * dimension, use the GetDimensionValues operation.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetSavingsPlansCoverageAsync(const Model::GetSavingsPlansCoverageRequest& request, const GetSavingsPlansCoverageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves your request parameters, Savings Plan Recommendations Summary and
         * Details.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetSavingsPlansPurchaseRecommendationOutcome GetSavingsPlansPurchaseRecommendation(const Model::GetSavingsPlansPurchaseRecommendationRequest& request) const;

        /**
         *
Retrieves your request parameters, Savings Plan Recommendations Summary and
         * Details.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetSavingsPlansPurchaseRecommendationOutcomeCallable GetSavingsPlansPurchaseRecommendationCallable(const Model::GetSavingsPlansPurchaseRecommendationRequest& request) const;

        /**
         *
Retrieves your request parameters, Savings Plan Recommendations Summary and
         * Details.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetSavingsPlansPurchaseRecommendationAsync(const Model::GetSavingsPlansPurchaseRecommendationRequest& request, const GetSavingsPlansPurchaseRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the Savings Plans utilization for your account across date ranges
         * with daily or monthly granularity. Management account in an organization have
         * access to member accounts. You can use GetDimensionValues in
         * SAVINGS_PLANS to determine the possible dimension values.

         *
You cannot group by any dimension values for
         * GetSavingsPlansUtilization.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetSavingsPlansUtilizationOutcome GetSavingsPlansUtilization(const Model::GetSavingsPlansUtilizationRequest& request) const;

        /**
         *
Retrieves the Savings Plans utilization for your account across date ranges
         * with daily or monthly granularity. Management account in an organization have
         * access to member accounts. You can use GetDimensionValues in
         * SAVINGS_PLANS to determine the possible dimension values.

         *
You cannot group by any dimension values for
         * GetSavingsPlansUtilization.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetSavingsPlansUtilizationOutcomeCallable GetSavingsPlansUtilizationCallable(const Model::GetSavingsPlansUtilizationRequest& request) const;

        /**
         *
Retrieves the Savings Plans utilization for your account across date ranges
         * with daily or monthly granularity. Management account in an organization have
         * access to member accounts. You can use GetDimensionValues in
         * SAVINGS_PLANS to determine the possible dimension values.

         *
You cannot group by any dimension values for
         * GetSavingsPlansUtilization.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetSavingsPlansUtilizationAsync(const Model::GetSavingsPlansUtilizationRequest& request, const GetSavingsPlansUtilizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves attribute data along with aggregate utilization and savings data
         * for a given time period. This doesn't support granular or grouped data
         * (daily/monthly) in response. You can't retrieve data by dates in a single
         * response similar to GetSavingsPlanUtilization, but you have the
         * option to make multiple calls to GetSavingsPlanUtilizationDetails
         * by providing individual dates. You can use GetDimensionValues in
         * SAVINGS_PLANS to determine the possible dimension values.

         *
 GetSavingsPlanUtilizationDetails internally groups data
         * by SavingsPlansArn.

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetSavingsPlansUtilizationDetailsOutcome GetSavingsPlansUtilizationDetails(const Model::GetSavingsPlansUtilizationDetailsRequest& request) const;

        /**
         *
Retrieves attribute data along with aggregate utilization and savings data
         * for a given time period. This doesn't support granular or grouped data
         * (daily/monthly) in response. You can't retrieve data by dates in a single
         * response similar to GetSavingsPlanUtilization, but you have the
         * option to make multiple calls to GetSavingsPlanUtilizationDetails
         * by providing individual dates. You can use GetDimensionValues in
         * SAVINGS_PLANS to determine the possible dimension values.

         *
 GetSavingsPlanUtilizationDetails internally groups data
         * by SavingsPlansArn.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetSavingsPlansUtilizationDetailsOutcomeCallable GetSavingsPlansUtilizationDetailsCallable(const Model::GetSavingsPlansUtilizationDetailsRequest& request) const;

        /**
         *
Retrieves attribute data along with aggregate utilization and savings data
         * for a given time period. This doesn't support granular or grouped data
         * (daily/monthly) in response. You can't retrieve data by dates in a single
         * response similar to GetSavingsPlanUtilization, but you have the
         * option to make multiple calls to GetSavingsPlanUtilizationDetails
         * by providing individual dates. You can use GetDimensionValues in
         * SAVINGS_PLANS to determine the possible dimension values.

         *
 GetSavingsPlanUtilizationDetails internally groups data
         * by SavingsPlansArn.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetSavingsPlansUtilizationDetailsAsync(const Model::GetSavingsPlansUtilizationDetailsRequest& request, const GetSavingsPlansUtilizationDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Queries for available tag keys and tag values for a specified period. You can
         * search the tag values for an arbitrary string.

See Also:
   AWS API
         * Reference

         */
        virtual Model::GetTagsOutcome GetTags(const Model::GetTagsRequest& request) const;

        /**
         *
Queries for available tag keys and tag values for a specified period. You can
         * search the tag values for an arbitrary string.

See Also:
   AWS API
         * Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetTagsOutcomeCallable GetTagsCallable(const Model::GetTagsRequest& request) const;

        /**
         *
Queries for available tag keys and tag values for a specified period. You can
         * search the tag values for an arbitrary string.

See Also:
   AWS API
         * Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetTagsAsync(const Model::GetTagsRequest& request, const GetTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves a forecast for how much Amazon Web Services predicts that you will
         * use over the forecast time period that you select, based on your past usage.
         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::GetUsageForecastOutcome GetUsageForecast(const Model::GetUsageForecastRequest& request) const;

        /**
         *
Retrieves a forecast for how much Amazon Web Services predicts that you will
         * use over the forecast time period that you select, based on your past usage.
         *

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetUsageForecastOutcomeCallable GetUsageForecastCallable(const Model::GetUsageForecastRequest& request) const;

        /**
         *
Retrieves a forecast for how much Amazon Web Services predicts that you will
         * use over the forecast time period that you select, based on your past usage.
         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetUsageForecastAsync(const Model::GetUsageForecastRequest& request, const GetUsageForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns the name, ARN, NumberOfRules and effective dates of all
         * Cost Categories defined in the account. You have the option to use
         * EffectiveOn to return a list of Cost Categories that were active on
         * a specific date. If there is no EffectiveOn specified, you'll see
         * Cost Categories that are effective on the current date. If Cost Category is
         * still effective, EffectiveEnd is omitted in the response.
         * ListCostCategoryDefinitions supports pagination. The request can
         * have a MaxResults range up to 100.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListCostCategoryDefinitionsOutcome ListCostCategoryDefinitions(const Model::ListCostCategoryDefinitionsRequest& request) const;

        /**
         *
Returns the name, ARN, NumberOfRules and effective dates of all
         * Cost Categories defined in the account. You have the option to use
         * EffectiveOn to return a list of Cost Categories that were active on
         * a specific date. If there is no EffectiveOn specified, you'll see
         * Cost Categories that are effective on the current date. If Cost Category is
         * still effective, EffectiveEnd is omitted in the response.
         * ListCostCategoryDefinitions supports pagination. The request can
         * have a MaxResults range up to 100.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListCostCategoryDefinitionsOutcomeCallable ListCostCategoryDefinitionsCallable(const Model::ListCostCategoryDefinitionsRequest& request) const;

        /**
         *
Returns the name, ARN, NumberOfRules and effective dates of all
         * Cost Categories defined in the account. You have the option to use
         * EffectiveOn to return a list of Cost Categories that were active on
         * a specific date. If there is no EffectiveOn specified, you'll see
         * Cost Categories that are effective on the current date. If Cost Category is
         * still effective, EffectiveEnd is omitted in the response.
         * ListCostCategoryDefinitions supports pagination. The request can
         * have a MaxResults range up to 100.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListCostCategoryDefinitionsAsync(const Model::ListCostCategoryDefinitionsRequest& request, const ListCostCategoryDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Modifies the feedback property of a given cost anomaly.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::ProvideAnomalyFeedbackOutcome ProvideAnomalyFeedback(const Model::ProvideAnomalyFeedbackRequest& request) const;

        /**
         *
Modifies the feedback property of a given cost anomaly.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ProvideAnomalyFeedbackOutcomeCallable ProvideAnomalyFeedbackCallable(const Model::ProvideAnomalyFeedbackRequest& request) const;

        /**
         *
Modifies the feedback property of a given cost anomaly.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ProvideAnomalyFeedbackAsync(const Model::ProvideAnomalyFeedbackRequest& request, const ProvideAnomalyFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Updates an existing cost anomaly monitor. The changes made are applied going
         * forward, and does not change anomalies detected in the past.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::UpdateAnomalyMonitorOutcome UpdateAnomalyMonitor(const Model::UpdateAnomalyMonitorRequest& request) const;

        /**
         *
Updates an existing cost anomaly monitor. The changes made are applied going
         * forward, and does not change anomalies detected in the past.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateAnomalyMonitorOutcomeCallable UpdateAnomalyMonitorCallable(const Model::UpdateAnomalyMonitorRequest& request) const;

        /**
         *
Updates an existing cost anomaly monitor. The changes made are applied going
         * forward, and does not change anomalies detected in the past.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateAnomalyMonitorAsync(const Model::UpdateAnomalyMonitorRequest& request, const UpdateAnomalyMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
 Updates an existing cost anomaly monitor subscription.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::UpdateAnomalySubscriptionOutcome UpdateAnomalySubscription(const Model::UpdateAnomalySubscriptionRequest& request) const;

        /**
         *
 Updates an existing cost anomaly monitor subscription.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateAnomalySubscriptionOutcomeCallable UpdateAnomalySubscriptionCallable(const Model::UpdateAnomalySubscriptionRequest& request) const;

        /**
         *
 Updates an existing cost anomaly monitor subscription.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateAnomalySubscriptionAsync(const Model::UpdateAnomalySubscriptionRequest& request, const UpdateAnomalySubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Updates an existing Cost Category. Changes made to the Cost Category rules
         * will be used to categorize the current month's expenses and future expenses.
         * This won't change categorization for the previous months.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::UpdateCostCategoryDefinitionOutcome UpdateCostCategoryDefinition(const Model::UpdateCostCategoryDefinitionRequest& request) const;

        /**
         *
Updates an existing Cost Category. Changes made to the Cost Category rules
         * will be used to categorize the current month's expenses and future expenses.
         * This won't change categorization for the previous months.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateCostCategoryDefinitionOutcomeCallable UpdateCostCategoryDefinitionCallable(const Model::UpdateCostCategoryDefinitionRequest& request) const;

        /**
         *
Updates an existing Cost Category. Changes made to the Cost Category rules
         * will be used to categorize the current month's expenses and future expenses.
         * This won't change categorization for the previous months.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateCostCategoryDefinitionAsync(const Model::UpdateCostCategoryDefinitionRequest& request, const UpdateCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

      void OverrideEndpoint(const Aws::String& endpoint);
    private:
      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
        void CreateAnomalyMonitorAsyncHelper(const Model::CreateAnomalyMonitorRequest& request, const CreateAnomalyMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateAnomalySubscriptionAsyncHelper(const Model::CreateAnomalySubscriptionRequest& request, const CreateAnomalySubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateCostCategoryDefinitionAsyncHelper(const Model::CreateCostCategoryDefinitionRequest& request, const CreateCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteAnomalyMonitorAsyncHelper(const Model::DeleteAnomalyMonitorRequest& request, const DeleteAnomalyMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteAnomalySubscriptionAsyncHelper(const Model::DeleteAnomalySubscriptionRequest& request, const DeleteAnomalySubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteCostCategoryDefinitionAsyncHelper(const Model::DeleteCostCategoryDefinitionRequest& request, const DeleteCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeCostCategoryDefinitionAsyncHelper(const Model::DescribeCostCategoryDefinitionRequest& request, const DescribeCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetAnomaliesAsyncHelper(const Model::GetAnomaliesRequest& request, const GetAnomaliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetAnomalyMonitorsAsyncHelper(const Model::GetAnomalyMonitorsRequest& request, const GetAnomalyMonitorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetAnomalySubscriptionsAsyncHelper(const Model::GetAnomalySubscriptionsRequest& request, const GetAnomalySubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetCostAndUsageAsyncHelper(const Model::GetCostAndUsageRequest& request, const GetCostAndUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetCostAndUsageWithResourcesAsyncHelper(const Model::GetCostAndUsageWithResourcesRequest& request, const GetCostAndUsageWithResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetCostCategoriesAsyncHelper(const Model::GetCostCategoriesRequest& request, const GetCostCategoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetCostForecastAsyncHelper(const Model::GetCostForecastRequest& request, const GetCostForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetDimensionValuesAsyncHelper(const Model::GetDimensionValuesRequest& request, const GetDimensionValuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetReservationCoverageAsyncHelper(const Model::GetReservationCoverageRequest& request, const GetReservationCoverageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetReservationPurchaseRecommendationAsyncHelper(const Model::GetReservationPurchaseRecommendationRequest& request, const GetReservationPurchaseRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetReservationUtilizationAsyncHelper(const Model::GetReservationUtilizationRequest& request, const GetReservationUtilizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetRightsizingRecommendationAsyncHelper(const Model::GetRightsizingRecommendationRequest& request, const GetRightsizingRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetSavingsPlansCoverageAsyncHelper(const Model::GetSavingsPlansCoverageRequest& request, const GetSavingsPlansCoverageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetSavingsPlansPurchaseRecommendationAsyncHelper(const Model::GetSavingsPlansPurchaseRecommendationRequest& request, const GetSavingsPlansPurchaseRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetSavingsPlansUtilizationAsyncHelper(const Model::GetSavingsPlansUtilizationRequest& request, const GetSavingsPlansUtilizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetSavingsPlansUtilizationDetailsAsyncHelper(const Model::GetSavingsPlansUtilizationDetailsRequest& request, const GetSavingsPlansUtilizationDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetTagsAsyncHelper(const Model::GetTagsRequest& request, const GetTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetUsageForecastAsyncHelper(const Model::GetUsageForecastRequest& request, const GetUsageForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListCostCategoryDefinitionsAsyncHelper(const Model::ListCostCategoryDefinitionsRequest& request, const ListCostCategoryDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ProvideAnomalyFeedbackAsyncHelper(const Model::ProvideAnomalyFeedbackRequest& request, const ProvideAnomalyFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateAnomalyMonitorAsyncHelper(const Model::UpdateAnomalyMonitorRequest& request, const UpdateAnomalyMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateAnomalySubscriptionAsyncHelper(const Model::UpdateAnomalySubscriptionRequest& request, const UpdateAnomalySubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateCostCategoryDefinitionAsyncHelper(const Model::UpdateCostCategoryDefinitionRequest& request, const UpdateCostCategoryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;

      Aws::String m_uri;
      Aws::String m_configScheme;
      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
  };

} // namespace CostExplorer
} // namespace Aws


text:
<input type="button" onclick="ajax_request()" value="Do AJAX">

<form name="form1">
  First <input type="text" id="first">

  Last  <input type="text" id="last">

  Address <input type="text" id="address">

</form>

redpajama_set_name: RedPajamaGithub


text:
package ua.in.quireg.chan.boards.fourchan.models;

import org.codehaus.jackson.annotate.JsonProperty;

public class FourchanThreadInfo {
    @JsonProperty("posts")
    public FourchanPostInfo[] posts;
}


text:
.. This file is part of the OpenDSA eTextbook project. See
.. http://algoviz.org/OpenDSA for more details.
.. Copyright (c) 2012-2013 by the OpenDSA Project Contributors, and
.. distributed under an MIT open source license.

.. avmetadata::
   :author: Cliff Shaffer
   :satisfies: problems; algorithms; functions
   :topic: Algorithm Analysis

Problems, Algorithms, and Programs
==================================

Programmers commonly deal with problems, algorithms, and
computer programs.
These are three distinct concepts.

Problems
--------

As your intuition would suggest, a :term:`problem` is
a task to be performed.
It is best thought of in terms of inputs and matching outputs.
A problem definition should not include any constraints on
*how* the problem is to be solved.
The solution method should be developed only after the problem is
precisely defined and thoroughly understood.
However, a problem definition should include constraints on the
resources that may be consumed by any acceptable
solution.
For any problem to be solved by a computer, there are always such
constraints, whether stated or implied.
For example, any computer program may use only the main memory
and disk space available, and it must run in a "reasonable" amount
of time.

Problems can be viewed as functions in the mathematical sense.
A :term:`function` is a matching
between inputs (the :term:`domain`) and outputs (the :term:`range`).
An input to a function might be a single value or a
collection of information.
The values making up an input are called the
:term:`parameters` of the function.
A specific selection of values for the parameters is called an
:term:`instance <problem instance>` of the problem.
For example, the input parameter to a sorting function might be an
array of integers.
A particular array of integers, with a given size and specific values
for each position in the array, would be an instance of the sorting
problem.
Different instances might generate the same output.
However, any problem instance must always result in the same output
every time the function is computed using that particular input.

This concept of all problems behaving like mathematical functions
might not match your intuition for the behavior of computer programs.
You might know of programs to which you can give the same input value
on two separate occasions, and two different outputs will result.
For example, if you type ``date`` to a typical Linux command
line prompt, you will get the current date.
Naturally the date will be different on different days, even though
the same command is given.
However, there is obviously more to the input for the date program
than the command that you type to run the program.
The date program computes a function.
In other words, on any particular day there can only be a single
answer returned by a properly running date program on a completely
specified input.
For all computer programs, the output is completely determined by the
program's full set of inputs.
Even a "random number generator" is completely determined by its
inputs (although some random number generating systems appear to get
around this by accepting a random input from a physical
process beyond the user's control).
The limits to what functions can be implemented by programs is part of
the domain of :ref:`Computability <computability> <Computability>`.

Algorithms
----------

An :term:`algorithm` is a method or a process followed to
solve a problem.
If the problem is viewed as a function, then an algorithm is an
implementation for the function
that transforms an input to the corresponding output.
A problem can be solved by many different algorithms.
A given algorithm solves only one
problem (i.e., computes a particular function).
OpenDSA modules cover many problems, and for several of these
problems we will see more than one algorithm.
For the important problem of sorting there are over a dozen commonly
known algorithms!

The advantage of knowing several solutions to a problem is that
solution :math:`\mathbf{A}` might be more efficient than solution
:math:`\mathbf{B}` for a specific variation of the problem, or for a
specific class of inputs to the problem, while solution
:math:`\mathbf{B}` might be more efficient than
:math:`\mathbf{A}` for another variation or class of inputs.
For example, one sorting algorithm might be the best
for sorting a small collection of integers (which is important if you
need to do this many times).
Another might be the best for sorting a large collection of integers.
A third might be the best for sorting a collection of variable-length
strings.

By definition, something can only be called an algorithm if it has all
of the following properties.

#. It must be *correct*.
   In other words, it must compute the desired function, converting
   each input to the correct output.
   Note that every algorithm implements some function,
   because every algorithm maps every input to some output (even if
   that output is a program crash).
   At issue here is whether a given algorithm implements the
   *intended* function.

#. It is composed of a series of *concrete steps*.
   Concrete means that the action described by that step is
   completely understood --- and doable --- by the person or machine
   that must perform the algorithm.
   Each step must also be doable in a finite amount of time.
   Thus, the algorithm gives us a "recipe" for solving the problem by
   performing a series of steps, where each such step is within our
   capacity to perform.
   The ability to perform a step can depend on who or what is intended
   to execute the recipe.
   For example, the steps of a cookie recipe in a cookbook might be
   considered sufficiently concrete for instructing a human cook,
   but not for programming an automated cookie-making factory.

#. There can be *no ambiguity* as to which step will be performed
   next.
   Often it is the next step of the algorithm description.
   Selection (e.g., the ``if`` statement)
   is normally a part of any language for describing algorithms.
   Selection allows a choice for which step will be
   performed next, but the selection process is unambiguous at the
   time when the choice is made.

#. It must be composed of a *finite* number of steps.
   If the description for the algorithm were made up of an infinite
   number of steps, we could never hope to write it down, nor
   implement it as a computer program.
   Most languages for describing algorithms (including English
   and "pseudocode") provide some way to perform
   repeated actions, known as iteration.
   Examples of iteration in programming languages include the
   ``while`` and ``for`` loop constructs.
   Iteration allows for short descriptions, with the number of
   steps actually performed controlled by the input.

#. It must *terminate*.
   In other words, it may not go into an infinite loop.

Programs
--------

We often think of a computer :term:`program` as an
instance, or concrete representation, of an algorithm in some
programming language.
Algorithms are usually presented in terms of programs,
or parts of programs.
Naturally, there are many programs that are instances of the same
algorithm, because any modern computer programming language can be
used to implement the same collection of algorithms (although some
programming languages can make life easier for the programmer).
To simplify presentation,
people often use the terms "algorithm" and "program" interchangeably,
despite the fact that they are really separate concepts.
By definition, an algorithm must provide sufficient
detail that it can be converted into a program when needed.

The requirement that an algorithm must terminate means that not all
computer programs meet the technical definition of an algorithm.
Your operating system is one such program.
However, you can think of the various tasks for an operating system
(each with associated inputs and outputs) as individual problems,
each solved by specific algorithms implemented by a part of the
operating system program, and each one of which terminates once its
output is produced.

To summarize:
A :term:`problem` is a function or a mapping of
inputs to outputs.
An :term:`algorithm` is a recipe for
solving a problem whose steps are concrete and unambiguous.
Algorithms must be correct, of finite length, and must terminate
for all inputs.
A :term:`program` is an instantiation of an algorithm
in a programming language.

.. todo::
   :type: SlideShow

   Here we need a visual description of the definitions of a problem, problem instance, algorithm, and program.  In this visualization, we may present the problem of sorting. The sorting problem here is a function that maps a specific problem instance to the desired output. An array of integers of size $n$ is randomly generated to represent a problem instance. Then an algorithm would be a recipe of mapping the problem instance to the desired output. We may present here bubble sort and merge sort as two recipes. We should give an example when the problem instance can have an effect on the efficiency of the algorithm (i.e. number of swaps for bubble sort in a sorted Vs. unsorted array). Finally, a program is an implementation of the algorithm in a specific programming language. So, here we may present the implemenation of bubble sort in C++ as an example of a program.