MedicalImagingClient.h

 
#pragma once
#include <aws/medical-imaging/MedicalImaging_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/medical-imaging/MedicalImagingServiceClientModel.h>
 
namespace Aws
{
namespace MedicalImaging
{
  class AWS_MEDICALIMAGING_API MedicalImagingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MedicalImagingClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MedicalImagingClientConfiguration ClientConfigurationType;
      typedef MedicalImagingEndpointProvider EndpointProviderType;
 
        MedicalImagingClient(const Aws::MedicalImaging::MedicalImagingClientConfiguration& clientConfiguration = Aws::MedicalImaging::MedicalImagingClientConfiguration(),
                             std::shared_ptr<MedicalImagingEndpointProviderBase> endpointProvider = nullptr);
 
        MedicalImagingClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<MedicalImagingEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::MedicalImaging::MedicalImagingClientConfiguration& clientConfiguration = Aws::MedicalImaging::MedicalImagingClientConfiguration());
 
        MedicalImagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<MedicalImagingEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::MedicalImaging::MedicalImagingClientConfiguration& clientConfiguration = Aws::MedicalImaging::MedicalImagingClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MedicalImagingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MedicalImagingClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MedicalImagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MedicalImagingClient();
 
        virtual Model::CopyImageSetOutcome CopyImageSet(const Model::CopyImageSetRequest& request) const;
 
        template<typename CopyImageSetRequestT = Model::CopyImageSetRequest>
        Model::CopyImageSetOutcomeCallable CopyImageSetCallable(const CopyImageSetRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::CopyImageSet, request);
        }
 
        template<typename CopyImageSetRequestT = Model::CopyImageSetRequest>
        void CopyImageSetAsync(const CopyImageSetRequestT& request, const CopyImageSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::CopyImageSet, request, handler, context);
        }
 
        virtual Model::CreateDatastoreOutcome CreateDatastore(const Model::CreateDatastoreRequest& request) const;
 
        template<typename CreateDatastoreRequestT = Model::CreateDatastoreRequest>
        Model::CreateDatastoreOutcomeCallable CreateDatastoreCallable(const CreateDatastoreRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::CreateDatastore, request);
        }
 
        template<typename CreateDatastoreRequestT = Model::CreateDatastoreRequest>
        void CreateDatastoreAsync(const CreateDatastoreRequestT& request, const CreateDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::CreateDatastore, request, handler, context);
        }
 
        virtual Model::DeleteDatastoreOutcome DeleteDatastore(const Model::DeleteDatastoreRequest& request) const;
 
        template<typename DeleteDatastoreRequestT = Model::DeleteDatastoreRequest>
        Model::DeleteDatastoreOutcomeCallable DeleteDatastoreCallable(const DeleteDatastoreRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::DeleteDatastore, request);
        }
 
        template<typename DeleteDatastoreRequestT = Model::DeleteDatastoreRequest>
        void DeleteDatastoreAsync(const DeleteDatastoreRequestT& request, const DeleteDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::DeleteDatastore, request, handler, context);
        }
 
        virtual Model::DeleteImageSetOutcome DeleteImageSet(const Model::DeleteImageSetRequest& request) const;
 
        template<typename DeleteImageSetRequestT = Model::DeleteImageSetRequest>
        Model::DeleteImageSetOutcomeCallable DeleteImageSetCallable(const DeleteImageSetRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::DeleteImageSet, request);
        }
 
        template<typename DeleteImageSetRequestT = Model::DeleteImageSetRequest>
        void DeleteImageSetAsync(const DeleteImageSetRequestT& request, const DeleteImageSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::DeleteImageSet, request, handler, context);
        }
 
        virtual Model::GetDICOMImportJobOutcome GetDICOMImportJob(const Model::GetDICOMImportJobRequest& request) const;
 
        template<typename GetDICOMImportJobRequestT = Model::GetDICOMImportJobRequest>
        Model::GetDICOMImportJobOutcomeCallable GetDICOMImportJobCallable(const GetDICOMImportJobRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::GetDICOMImportJob, request);
        }
 
        template<typename GetDICOMImportJobRequestT = Model::GetDICOMImportJobRequest>
        void GetDICOMImportJobAsync(const GetDICOMImportJobRequestT& request, const GetDICOMImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::GetDICOMImportJob, request, handler, context);
        }
 
        virtual Model::GetDatastoreOutcome GetDatastore(const Model::GetDatastoreRequest& request) const;
 
        template<typename GetDatastoreRequestT = Model::GetDatastoreRequest>
        Model::GetDatastoreOutcomeCallable GetDatastoreCallable(const GetDatastoreRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::GetDatastore, request);
        }
 
        template<typename GetDatastoreRequestT = Model::GetDatastoreRequest>
        void GetDatastoreAsync(const GetDatastoreRequestT& request, const GetDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::GetDatastore, request, handler, context);
        }
 
        virtual Model::GetImageFrameOutcome GetImageFrame(const Model::GetImageFrameRequest& request) const;
 
        template<typename GetImageFrameRequestT = Model::GetImageFrameRequest>
        Model::GetImageFrameOutcomeCallable GetImageFrameCallable(const GetImageFrameRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::GetImageFrame, request);
        }
 
        template<typename GetImageFrameRequestT = Model::GetImageFrameRequest>
        void GetImageFrameAsync(const GetImageFrameRequestT& request, const GetImageFrameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::GetImageFrame, request, handler, context);
        }
 
        virtual Model::GetImageSetOutcome GetImageSet(const Model::GetImageSetRequest& request) const;
 
        template<typename GetImageSetRequestT = Model::GetImageSetRequest>
        Model::GetImageSetOutcomeCallable GetImageSetCallable(const GetImageSetRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::GetImageSet, request);
        }
 
        template<typename GetImageSetRequestT = Model::GetImageSetRequest>
        void GetImageSetAsync(const GetImageSetRequestT& request, const GetImageSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::GetImageSet, request, handler, context);
        }
 
        virtual Model::GetImageSetMetadataOutcome GetImageSetMetadata(const Model::GetImageSetMetadataRequest& request) const;
 
        template<typename GetImageSetMetadataRequestT = Model::GetImageSetMetadataRequest>
        Model::GetImageSetMetadataOutcomeCallable GetImageSetMetadataCallable(const GetImageSetMetadataRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::GetImageSetMetadata, request);
        }
 
        template<typename GetImageSetMetadataRequestT = Model::GetImageSetMetadataRequest>
        void GetImageSetMetadataAsync(const GetImageSetMetadataRequestT& request, const GetImageSetMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::GetImageSetMetadata, request, handler, context);
        }
 
        virtual Model::ListDICOMImportJobsOutcome ListDICOMImportJobs(const Model::ListDICOMImportJobsRequest& request) const;
 
        template<typename ListDICOMImportJobsRequestT = Model::ListDICOMImportJobsRequest>
        Model::ListDICOMImportJobsOutcomeCallable ListDICOMImportJobsCallable(const ListDICOMImportJobsRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::ListDICOMImportJobs, request);
        }
 
        template<typename ListDICOMImportJobsRequestT = Model::ListDICOMImportJobsRequest>
        void ListDICOMImportJobsAsync(const ListDICOMImportJobsRequestT& request, const ListDICOMImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::ListDICOMImportJobs, request, handler, context);
        }
 
        virtual Model::ListDatastoresOutcome ListDatastores(const Model::ListDatastoresRequest& request = {}) const;
 
        template<typename ListDatastoresRequestT = Model::ListDatastoresRequest>
        Model::ListDatastoresOutcomeCallable ListDatastoresCallable(const ListDatastoresRequestT& request = {}) const
        {
            return SubmitCallable(&MedicalImagingClient::ListDatastores, request);
        }
 
        template<typename ListDatastoresRequestT = Model::ListDatastoresRequest>
        void ListDatastoresAsync(const ListDatastoresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatastoresRequestT& request = {}) const
        {
            return SubmitAsync(&MedicalImagingClient::ListDatastores, request, handler, context);
        }
 
        virtual Model::ListImageSetVersionsOutcome ListImageSetVersions(const Model::ListImageSetVersionsRequest& request) const;
 
        template<typename ListImageSetVersionsRequestT = Model::ListImageSetVersionsRequest>
        Model::ListImageSetVersionsOutcomeCallable ListImageSetVersionsCallable(const ListImageSetVersionsRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::ListImageSetVersions, request);
        }
 
        template<typename ListImageSetVersionsRequestT = Model::ListImageSetVersionsRequest>
        void ListImageSetVersionsAsync(const ListImageSetVersionsRequestT& request, const ListImageSetVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::ListImageSetVersions, 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(&MedicalImagingClient::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(&MedicalImagingClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::SearchImageSetsOutcome SearchImageSets(const Model::SearchImageSetsRequest& request) const;
 
        template<typename SearchImageSetsRequestT = Model::SearchImageSetsRequest>
        Model::SearchImageSetsOutcomeCallable SearchImageSetsCallable(const SearchImageSetsRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::SearchImageSets, request);
        }
 
        template<typename SearchImageSetsRequestT = Model::SearchImageSetsRequest>
        void SearchImageSetsAsync(const SearchImageSetsRequestT& request, const SearchImageSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::SearchImageSets, request, handler, context);
        }
 
        virtual Model::StartDICOMImportJobOutcome StartDICOMImportJob(const Model::StartDICOMImportJobRequest& request) const;
 
        template<typename StartDICOMImportJobRequestT = Model::StartDICOMImportJobRequest>
        Model::StartDICOMImportJobOutcomeCallable StartDICOMImportJobCallable(const StartDICOMImportJobRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::StartDICOMImportJob, request);
        }
 
        template<typename StartDICOMImportJobRequestT = Model::StartDICOMImportJobRequest>
        void StartDICOMImportJobAsync(const StartDICOMImportJobRequestT& request, const StartDICOMImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::StartDICOMImportJob, 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(&MedicalImagingClient::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(&MedicalImagingClient::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(&MedicalImagingClient::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(&MedicalImagingClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateImageSetMetadataOutcome UpdateImageSetMetadata(const Model::UpdateImageSetMetadataRequest& request) const;
 
        template<typename UpdateImageSetMetadataRequestT = Model::UpdateImageSetMetadataRequest>
        Model::UpdateImageSetMetadataOutcomeCallable UpdateImageSetMetadataCallable(const UpdateImageSetMetadataRequestT& request) const
        {
            return SubmitCallable(&MedicalImagingClient::UpdateImageSetMetadata, request);
        }
 
        template<typename UpdateImageSetMetadataRequestT = Model::UpdateImageSetMetadataRequest>
        void UpdateImageSetMetadataAsync(const UpdateImageSetMetadataRequestT& request, const UpdateImageSetMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MedicalImagingClient::UpdateImageSetMetadata, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MedicalImagingEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MedicalImagingClient>;
      void init(const MedicalImagingClientConfiguration& clientConfiguration);
 
      MedicalImagingClientConfiguration m_clientConfiguration;
      std::shared_ptr<MedicalImagingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MedicalImaging
} // namespace Aws