IoT1ClickProjectsClient.h

 
#pragma once
#include <aws/iot1click-projects/IoT1ClickProjects_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/iot1click-projects/IoT1ClickProjectsServiceClientModel.h>
 
namespace Aws
{
namespace IoT1ClickProjects
{
  class AWS_IOT1CLICKPROJECTS_API IoT1ClickProjectsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoT1ClickProjectsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoT1ClickProjectsClientConfiguration ClientConfigurationType;
      typedef IoT1ClickProjectsEndpointProvider EndpointProviderType;
 
        IoT1ClickProjectsClient(const Aws::IoT1ClickProjects::IoT1ClickProjectsClientConfiguration& clientConfiguration = Aws::IoT1ClickProjects::IoT1ClickProjectsClientConfiguration(),
                                std::shared_ptr<IoT1ClickProjectsEndpointProviderBase> endpointProvider = nullptr);
 
        IoT1ClickProjectsClient(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<IoT1ClickProjectsEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::IoT1ClickProjects::IoT1ClickProjectsClientConfiguration& clientConfiguration = Aws::IoT1ClickProjects::IoT1ClickProjectsClientConfiguration());
 
        IoT1ClickProjectsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<IoT1ClickProjectsEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::IoT1ClickProjects::IoT1ClickProjectsClientConfiguration& clientConfiguration = Aws::IoT1ClickProjects::IoT1ClickProjectsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoT1ClickProjectsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoT1ClickProjectsClient(const Aws::Auth::AWSCredentials& credentials,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoT1ClickProjectsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoT1ClickProjectsClient();
 
        virtual Model::AssociateDeviceWithPlacementOutcome AssociateDeviceWithPlacement(const Model::AssociateDeviceWithPlacementRequest& request) const;
 
        template<typename AssociateDeviceWithPlacementRequestT = Model::AssociateDeviceWithPlacementRequest>
        Model::AssociateDeviceWithPlacementOutcomeCallable AssociateDeviceWithPlacementCallable(const AssociateDeviceWithPlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::AssociateDeviceWithPlacement, request);
        }
 
        template<typename AssociateDeviceWithPlacementRequestT = Model::AssociateDeviceWithPlacementRequest>
        void AssociateDeviceWithPlacementAsync(const AssociateDeviceWithPlacementRequestT& request, const AssociateDeviceWithPlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::AssociateDeviceWithPlacement, request, handler, context);
        }
 
        virtual Model::CreatePlacementOutcome CreatePlacement(const Model::CreatePlacementRequest& request) const;
 
        template<typename CreatePlacementRequestT = Model::CreatePlacementRequest>
        Model::CreatePlacementOutcomeCallable CreatePlacementCallable(const CreatePlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::CreatePlacement, request);
        }
 
        template<typename CreatePlacementRequestT = Model::CreatePlacementRequest>
        void CreatePlacementAsync(const CreatePlacementRequestT& request, const CreatePlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::CreatePlacement, request, handler, context);
        }
 
        virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::CreateProject, request);
        }
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::CreateProject, request, handler, context);
        }
 
        virtual Model::DeletePlacementOutcome DeletePlacement(const Model::DeletePlacementRequest& request) const;
 
        template<typename DeletePlacementRequestT = Model::DeletePlacementRequest>
        Model::DeletePlacementOutcomeCallable DeletePlacementCallable(const DeletePlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::DeletePlacement, request);
        }
 
        template<typename DeletePlacementRequestT = Model::DeletePlacementRequest>
        void DeletePlacementAsync(const DeletePlacementRequestT& request, const DeletePlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::DeletePlacement, request, handler, context);
        }
 
        virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::DeleteProject, request);
        }
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::DeleteProject, request, handler, context);
        }
 
        virtual Model::DescribePlacementOutcome DescribePlacement(const Model::DescribePlacementRequest& request) const;
 
        template<typename DescribePlacementRequestT = Model::DescribePlacementRequest>
        Model::DescribePlacementOutcomeCallable DescribePlacementCallable(const DescribePlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::DescribePlacement, request);
        }
 
        template<typename DescribePlacementRequestT = Model::DescribePlacementRequest>
        void DescribePlacementAsync(const DescribePlacementRequestT& request, const DescribePlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::DescribePlacement, request, handler, context);
        }
 
        virtual Model::DescribeProjectOutcome DescribeProject(const Model::DescribeProjectRequest& request) const;
 
        template<typename DescribeProjectRequestT = Model::DescribeProjectRequest>
        Model::DescribeProjectOutcomeCallable DescribeProjectCallable(const DescribeProjectRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::DescribeProject, request);
        }
 
        template<typename DescribeProjectRequestT = Model::DescribeProjectRequest>
        void DescribeProjectAsync(const DescribeProjectRequestT& request, const DescribeProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::DescribeProject, request, handler, context);
        }
 
        virtual Model::DisassociateDeviceFromPlacementOutcome DisassociateDeviceFromPlacement(const Model::DisassociateDeviceFromPlacementRequest& request) const;
 
        template<typename DisassociateDeviceFromPlacementRequestT = Model::DisassociateDeviceFromPlacementRequest>
        Model::DisassociateDeviceFromPlacementOutcomeCallable DisassociateDeviceFromPlacementCallable(const DisassociateDeviceFromPlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::DisassociateDeviceFromPlacement, request);
        }
 
        template<typename DisassociateDeviceFromPlacementRequestT = Model::DisassociateDeviceFromPlacementRequest>
        void DisassociateDeviceFromPlacementAsync(const DisassociateDeviceFromPlacementRequestT& request, const DisassociateDeviceFromPlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::DisassociateDeviceFromPlacement, request, handler, context);
        }
 
        virtual Model::GetDevicesInPlacementOutcome GetDevicesInPlacement(const Model::GetDevicesInPlacementRequest& request) const;
 
        template<typename GetDevicesInPlacementRequestT = Model::GetDevicesInPlacementRequest>
        Model::GetDevicesInPlacementOutcomeCallable GetDevicesInPlacementCallable(const GetDevicesInPlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::GetDevicesInPlacement, request);
        }
 
        template<typename GetDevicesInPlacementRequestT = Model::GetDevicesInPlacementRequest>
        void GetDevicesInPlacementAsync(const GetDevicesInPlacementRequestT& request, const GetDevicesInPlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::GetDevicesInPlacement, request, handler, context);
        }
 
        virtual Model::ListPlacementsOutcome ListPlacements(const Model::ListPlacementsRequest& request) const;
 
        template<typename ListPlacementsRequestT = Model::ListPlacementsRequest>
        Model::ListPlacementsOutcomeCallable ListPlacementsCallable(const ListPlacementsRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::ListPlacements, request);
        }
 
        template<typename ListPlacementsRequestT = Model::ListPlacementsRequest>
        void ListPlacementsAsync(const ListPlacementsRequestT& request, const ListPlacementsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::ListPlacements, request, handler, context);
        }
 
        virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request = {}) const;
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request = {}) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::ListProjects, request);
        }
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        void ListProjectsAsync(const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProjectsRequestT& request = {}) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::ListProjects, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdatePlacementOutcome UpdatePlacement(const Model::UpdatePlacementRequest& request) const;
 
        template<typename UpdatePlacementRequestT = Model::UpdatePlacementRequest>
        Model::UpdatePlacementOutcomeCallable UpdatePlacementCallable(const UpdatePlacementRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::UpdatePlacement, request);
        }
 
        template<typename UpdatePlacementRequestT = Model::UpdatePlacementRequest>
        void UpdatePlacementAsync(const UpdatePlacementRequestT& request, const UpdatePlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::UpdatePlacement, request, handler, context);
        }
 
        virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const
        {
            return SubmitCallable(&IoT1ClickProjectsClient::UpdateProject, request);
        }
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoT1ClickProjectsClient::UpdateProject, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoT1ClickProjectsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoT1ClickProjectsClient>;
      void init(const IoT1ClickProjectsClientConfiguration& clientConfiguration);
 
      IoT1ClickProjectsClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoT1ClickProjectsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoT1ClickProjects
} // namespace Aws