SageMakerGeospatialClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/sagemaker-geospatial/SageMakerGeospatialPaginationBase.h>
#include <aws/sagemaker-geospatial/SageMakerGeospatialServiceClientModel.h>
#include <aws/sagemaker-geospatial/SageMakerGeospatialWaiter.h>
#include <aws/sagemaker-geospatial/SageMakerGeospatial_EXPORTS.h>
 
namespace Aws {
namespace SageMakerGeospatial {
class AWS_SAGEMAKERGEOSPATIAL_API SageMakerGeospatialClient : public Aws::Client::AWSJsonClient,
                                                              public Aws::Client::ClientWithAsyncTemplateMethods<SageMakerGeospatialClient>,
                                                              public SageMakerGeospatialPaginationBase<SageMakerGeospatialClient>,
                                                              public SageMakerGeospatialWaiter<SageMakerGeospatialClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SageMakerGeospatialClientConfiguration ClientConfigurationType;
  typedef SageMakerGeospatialEndpointProvider EndpointProviderType;
 
  SageMakerGeospatialClient(const Aws::SageMakerGeospatial::SageMakerGeospatialClientConfiguration& clientConfiguration =
                                Aws::SageMakerGeospatial::SageMakerGeospatialClientConfiguration(),
                            std::shared_ptr<SageMakerGeospatialEndpointProviderBase> endpointProvider = nullptr);
 
  SageMakerGeospatialClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<SageMakerGeospatialEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::SageMakerGeospatial::SageMakerGeospatialClientConfiguration& clientConfiguration =
                                Aws::SageMakerGeospatial::SageMakerGeospatialClientConfiguration());
 
  SageMakerGeospatialClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<SageMakerGeospatialEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::SageMakerGeospatial::SageMakerGeospatialClientConfiguration& clientConfiguration =
                                Aws::SageMakerGeospatial::SageMakerGeospatialClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SageMakerGeospatialClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SageMakerGeospatialClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SageMakerGeospatialClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SageMakerGeospatialClient();
 
  virtual Model::DeleteEarthObservationJobOutcome DeleteEarthObservationJob(const Model::DeleteEarthObservationJobRequest& request) const;
 
  template <typename DeleteEarthObservationJobRequestT = Model::DeleteEarthObservationJobRequest>
  Model::DeleteEarthObservationJobOutcomeCallable DeleteEarthObservationJobCallable(
      const DeleteEarthObservationJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::DeleteEarthObservationJob, request);
  }
 
  template <typename DeleteEarthObservationJobRequestT = Model::DeleteEarthObservationJobRequest>
  void DeleteEarthObservationJobAsync(const DeleteEarthObservationJobRequestT& request,
                                      const DeleteEarthObservationJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::DeleteEarthObservationJob, request, handler, context);
  }
 
  virtual Model::DeleteVectorEnrichmentJobOutcome DeleteVectorEnrichmentJob(const Model::DeleteVectorEnrichmentJobRequest& request) const;
 
  template <typename DeleteVectorEnrichmentJobRequestT = Model::DeleteVectorEnrichmentJobRequest>
  Model::DeleteVectorEnrichmentJobOutcomeCallable DeleteVectorEnrichmentJobCallable(
      const DeleteVectorEnrichmentJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::DeleteVectorEnrichmentJob, request);
  }
 
  template <typename DeleteVectorEnrichmentJobRequestT = Model::DeleteVectorEnrichmentJobRequest>
  void DeleteVectorEnrichmentJobAsync(const DeleteVectorEnrichmentJobRequestT& request,
                                      const DeleteVectorEnrichmentJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::DeleteVectorEnrichmentJob, request, handler, context);
  }
 
  virtual Model::ExportEarthObservationJobOutcome ExportEarthObservationJob(const Model::ExportEarthObservationJobRequest& request) const;
 
  template <typename ExportEarthObservationJobRequestT = Model::ExportEarthObservationJobRequest>
  Model::ExportEarthObservationJobOutcomeCallable ExportEarthObservationJobCallable(
      const ExportEarthObservationJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::ExportEarthObservationJob, request);
  }
 
  template <typename ExportEarthObservationJobRequestT = Model::ExportEarthObservationJobRequest>
  void ExportEarthObservationJobAsync(const ExportEarthObservationJobRequestT& request,
                                      const ExportEarthObservationJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::ExportEarthObservationJob, request, handler, context);
  }
 
  virtual Model::ExportVectorEnrichmentJobOutcome ExportVectorEnrichmentJob(const Model::ExportVectorEnrichmentJobRequest& request) const;
 
  template <typename ExportVectorEnrichmentJobRequestT = Model::ExportVectorEnrichmentJobRequest>
  Model::ExportVectorEnrichmentJobOutcomeCallable ExportVectorEnrichmentJobCallable(
      const ExportVectorEnrichmentJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::ExportVectorEnrichmentJob, request);
  }
 
  template <typename ExportVectorEnrichmentJobRequestT = Model::ExportVectorEnrichmentJobRequest>
  void ExportVectorEnrichmentJobAsync(const ExportVectorEnrichmentJobRequestT& request,
                                      const ExportVectorEnrichmentJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::ExportVectorEnrichmentJob, request, handler, context);
  }
 
  virtual Model::GetEarthObservationJobOutcome GetEarthObservationJob(const Model::GetEarthObservationJobRequest& request) const;
 
  template <typename GetEarthObservationJobRequestT = Model::GetEarthObservationJobRequest>
  Model::GetEarthObservationJobOutcomeCallable GetEarthObservationJobCallable(const GetEarthObservationJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::GetEarthObservationJob, request);
  }
 
  template <typename GetEarthObservationJobRequestT = Model::GetEarthObservationJobRequest>
  void GetEarthObservationJobAsync(const GetEarthObservationJobRequestT& request,
                                   const GetEarthObservationJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::GetEarthObservationJob, request, handler, context);
  }
 
  virtual Model::GetRasterDataCollectionOutcome GetRasterDataCollection(const Model::GetRasterDataCollectionRequest& request) const;
 
  template <typename GetRasterDataCollectionRequestT = Model::GetRasterDataCollectionRequest>
  Model::GetRasterDataCollectionOutcomeCallable GetRasterDataCollectionCallable(const GetRasterDataCollectionRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::GetRasterDataCollection, request);
  }
 
  template <typename GetRasterDataCollectionRequestT = Model::GetRasterDataCollectionRequest>
  void GetRasterDataCollectionAsync(const GetRasterDataCollectionRequestT& request,
                                    const GetRasterDataCollectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::GetRasterDataCollection, request, handler, context);
  }
 
  virtual Model::GetTileOutcome GetTile(const Model::GetTileRequest& request) const;
 
  template <typename GetTileRequestT = Model::GetTileRequest>
  Model::GetTileOutcomeCallable GetTileCallable(const GetTileRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::GetTile, request);
  }
 
  template <typename GetTileRequestT = Model::GetTileRequest>
  void GetTileAsync(const GetTileRequestT& request, const GetTileResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::GetTile, request, handler, context);
  }
 
  virtual Model::GetVectorEnrichmentJobOutcome GetVectorEnrichmentJob(const Model::GetVectorEnrichmentJobRequest& request) const;
 
  template <typename GetVectorEnrichmentJobRequestT = Model::GetVectorEnrichmentJobRequest>
  Model::GetVectorEnrichmentJobOutcomeCallable GetVectorEnrichmentJobCallable(const GetVectorEnrichmentJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::GetVectorEnrichmentJob, request);
  }
 
  template <typename GetVectorEnrichmentJobRequestT = Model::GetVectorEnrichmentJobRequest>
  void GetVectorEnrichmentJobAsync(const GetVectorEnrichmentJobRequestT& request,
                                   const GetVectorEnrichmentJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::GetVectorEnrichmentJob, request, handler, context);
  }
 
  virtual Model::ListEarthObservationJobsOutcome ListEarthObservationJobs(const Model::ListEarthObservationJobsRequest& request = {}) const;
 
  template <typename ListEarthObservationJobsRequestT = Model::ListEarthObservationJobsRequest>
  Model::ListEarthObservationJobsOutcomeCallable ListEarthObservationJobsCallable(
      const ListEarthObservationJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerGeospatialClient::ListEarthObservationJobs, request);
  }
 
  template <typename ListEarthObservationJobsRequestT = Model::ListEarthObservationJobsRequest>
  void ListEarthObservationJobsAsync(const ListEarthObservationJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListEarthObservationJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerGeospatialClient::ListEarthObservationJobs, request, handler, context);
  }
 
  virtual Model::ListRasterDataCollectionsOutcome ListRasterDataCollections(
      const Model::ListRasterDataCollectionsRequest& request = {}) const;
 
  template <typename ListRasterDataCollectionsRequestT = Model::ListRasterDataCollectionsRequest>
  Model::ListRasterDataCollectionsOutcomeCallable ListRasterDataCollectionsCallable(
      const ListRasterDataCollectionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerGeospatialClient::ListRasterDataCollections, request);
  }
 
  template <typename ListRasterDataCollectionsRequestT = Model::ListRasterDataCollectionsRequest>
  void ListRasterDataCollectionsAsync(const ListRasterDataCollectionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListRasterDataCollectionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerGeospatialClient::ListRasterDataCollections, 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(&SageMakerGeospatialClient::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(&SageMakerGeospatialClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListVectorEnrichmentJobsOutcome ListVectorEnrichmentJobs(const Model::ListVectorEnrichmentJobsRequest& request = {}) const;
 
  template <typename ListVectorEnrichmentJobsRequestT = Model::ListVectorEnrichmentJobsRequest>
  Model::ListVectorEnrichmentJobsOutcomeCallable ListVectorEnrichmentJobsCallable(
      const ListVectorEnrichmentJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerGeospatialClient::ListVectorEnrichmentJobs, request);
  }
 
  template <typename ListVectorEnrichmentJobsRequestT = Model::ListVectorEnrichmentJobsRequest>
  void ListVectorEnrichmentJobsAsync(const ListVectorEnrichmentJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListVectorEnrichmentJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerGeospatialClient::ListVectorEnrichmentJobs, request, handler, context);
  }
 
  virtual Model::SearchRasterDataCollectionOutcome SearchRasterDataCollection(
      const Model::SearchRasterDataCollectionRequest& request) const;
 
  template <typename SearchRasterDataCollectionRequestT = Model::SearchRasterDataCollectionRequest>
  Model::SearchRasterDataCollectionOutcomeCallable SearchRasterDataCollectionCallable(
      const SearchRasterDataCollectionRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::SearchRasterDataCollection, request);
  }
 
  template <typename SearchRasterDataCollectionRequestT = Model::SearchRasterDataCollectionRequest>
  void SearchRasterDataCollectionAsync(const SearchRasterDataCollectionRequestT& request,
                                       const SearchRasterDataCollectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::SearchRasterDataCollection, request, handler, context);
  }
 
  virtual Model::StartEarthObservationJobOutcome StartEarthObservationJob(const Model::StartEarthObservationJobRequest& request) const;
 
  template <typename StartEarthObservationJobRequestT = Model::StartEarthObservationJobRequest>
  Model::StartEarthObservationJobOutcomeCallable StartEarthObservationJobCallable(const StartEarthObservationJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::StartEarthObservationJob, request);
  }
 
  template <typename StartEarthObservationJobRequestT = Model::StartEarthObservationJobRequest>
  void StartEarthObservationJobAsync(const StartEarthObservationJobRequestT& request,
                                     const StartEarthObservationJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::StartEarthObservationJob, request, handler, context);
  }
 
  virtual Model::StartVectorEnrichmentJobOutcome StartVectorEnrichmentJob(const Model::StartVectorEnrichmentJobRequest& request) const;
 
  template <typename StartVectorEnrichmentJobRequestT = Model::StartVectorEnrichmentJobRequest>
  Model::StartVectorEnrichmentJobOutcomeCallable StartVectorEnrichmentJobCallable(const StartVectorEnrichmentJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::StartVectorEnrichmentJob, request);
  }
 
  template <typename StartVectorEnrichmentJobRequestT = Model::StartVectorEnrichmentJobRequest>
  void StartVectorEnrichmentJobAsync(const StartVectorEnrichmentJobRequestT& request,
                                     const StartVectorEnrichmentJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::StartVectorEnrichmentJob, request, handler, context);
  }
 
  virtual Model::StopEarthObservationJobOutcome StopEarthObservationJob(const Model::StopEarthObservationJobRequest& request) const;
 
  template <typename StopEarthObservationJobRequestT = Model::StopEarthObservationJobRequest>
  Model::StopEarthObservationJobOutcomeCallable StopEarthObservationJobCallable(const StopEarthObservationJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::StopEarthObservationJob, request);
  }
 
  template <typename StopEarthObservationJobRequestT = Model::StopEarthObservationJobRequest>
  void StopEarthObservationJobAsync(const StopEarthObservationJobRequestT& request,
                                    const StopEarthObservationJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::StopEarthObservationJob, request, handler, context);
  }
 
  virtual Model::StopVectorEnrichmentJobOutcome StopVectorEnrichmentJob(const Model::StopVectorEnrichmentJobRequest& request) const;
 
  template <typename StopVectorEnrichmentJobRequestT = Model::StopVectorEnrichmentJobRequest>
  Model::StopVectorEnrichmentJobOutcomeCallable StopVectorEnrichmentJobCallable(const StopVectorEnrichmentJobRequestT& request) const {
    return SubmitCallable(&SageMakerGeospatialClient::StopVectorEnrichmentJob, request);
  }
 
  template <typename StopVectorEnrichmentJobRequestT = Model::StopVectorEnrichmentJobRequest>
  void StopVectorEnrichmentJobAsync(const StopVectorEnrichmentJobRequestT& request,
                                    const StopVectorEnrichmentJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerGeospatialClient::StopVectorEnrichmentJob, 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(&SageMakerGeospatialClient::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(&SageMakerGeospatialClient::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(&SageMakerGeospatialClient::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(&SageMakerGeospatialClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SageMakerGeospatialEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SageMakerGeospatialClient>;
  void init(const SageMakerGeospatialClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SageMakerGeospatialError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SageMakerGeospatialClientConfiguration m_clientConfiguration;
  std::shared_ptr<SageMakerGeospatialEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SageMakerGeospatial
}  // namespace Aws