S3VectorsClient.h

 
#pragma once
#include <aws/s3vectors/S3Vectors_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/s3vectors/S3VectorsServiceClientModel.h>
 
namespace Aws
{
namespace S3Vectors
{
  class AWS_S3VECTORS_API S3VectorsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<S3VectorsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef S3VectorsClientConfiguration ClientConfigurationType;
      typedef S3VectorsEndpointProvider EndpointProviderType;
 
        S3VectorsClient(const Aws::S3Vectors::S3VectorsClientConfiguration& clientConfiguration = Aws::S3Vectors::S3VectorsClientConfiguration(),
                        std::shared_ptr<S3VectorsEndpointProviderBase> endpointProvider = nullptr);
 
        S3VectorsClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<S3VectorsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::S3Vectors::S3VectorsClientConfiguration& clientConfiguration = Aws::S3Vectors::S3VectorsClientConfiguration());
 
        S3VectorsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<S3VectorsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::S3Vectors::S3VectorsClientConfiguration& clientConfiguration = Aws::S3Vectors::S3VectorsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        S3VectorsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        S3VectorsClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        S3VectorsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~S3VectorsClient();
 
        virtual Model::CreateIndexOutcome CreateIndex(const Model::CreateIndexRequest& request) const;
 
        template<typename CreateIndexRequestT = Model::CreateIndexRequest>
        Model::CreateIndexOutcomeCallable CreateIndexCallable(const CreateIndexRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::CreateIndex, request);
        }
 
        template<typename CreateIndexRequestT = Model::CreateIndexRequest>
        void CreateIndexAsync(const CreateIndexRequestT& request, const CreateIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::CreateIndex, request, handler, context);
        }
 
        virtual Model::CreateVectorBucketOutcome CreateVectorBucket(const Model::CreateVectorBucketRequest& request) const;
 
        template<typename CreateVectorBucketRequestT = Model::CreateVectorBucketRequest>
        Model::CreateVectorBucketOutcomeCallable CreateVectorBucketCallable(const CreateVectorBucketRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::CreateVectorBucket, request);
        }
 
        template<typename CreateVectorBucketRequestT = Model::CreateVectorBucketRequest>
        void CreateVectorBucketAsync(const CreateVectorBucketRequestT& request, const CreateVectorBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::CreateVectorBucket, request, handler, context);
        }
 
        virtual Model::DeleteIndexOutcome DeleteIndex(const Model::DeleteIndexRequest& request = {}) const;
 
        template<typename DeleteIndexRequestT = Model::DeleteIndexRequest>
        Model::DeleteIndexOutcomeCallable DeleteIndexCallable(const DeleteIndexRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::DeleteIndex, request);
        }
 
        template<typename DeleteIndexRequestT = Model::DeleteIndexRequest>
        void DeleteIndexAsync(const DeleteIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteIndexRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::DeleteIndex, request, handler, context);
        }
 
        virtual Model::DeleteVectorBucketOutcome DeleteVectorBucket(const Model::DeleteVectorBucketRequest& request = {}) const;
 
        template<typename DeleteVectorBucketRequestT = Model::DeleteVectorBucketRequest>
        Model::DeleteVectorBucketOutcomeCallable DeleteVectorBucketCallable(const DeleteVectorBucketRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::DeleteVectorBucket, request);
        }
 
        template<typename DeleteVectorBucketRequestT = Model::DeleteVectorBucketRequest>
        void DeleteVectorBucketAsync(const DeleteVectorBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteVectorBucketRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::DeleteVectorBucket, request, handler, context);
        }
 
        virtual Model::DeleteVectorBucketPolicyOutcome DeleteVectorBucketPolicy(const Model::DeleteVectorBucketPolicyRequest& request = {}) const;
 
        template<typename DeleteVectorBucketPolicyRequestT = Model::DeleteVectorBucketPolicyRequest>
        Model::DeleteVectorBucketPolicyOutcomeCallable DeleteVectorBucketPolicyCallable(const DeleteVectorBucketPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::DeleteVectorBucketPolicy, request);
        }
 
        template<typename DeleteVectorBucketPolicyRequestT = Model::DeleteVectorBucketPolicyRequest>
        void DeleteVectorBucketPolicyAsync(const DeleteVectorBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteVectorBucketPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::DeleteVectorBucketPolicy, request, handler, context);
        }
 
        virtual Model::DeleteVectorsOutcome DeleteVectors(const Model::DeleteVectorsRequest& request) const;
 
        template<typename DeleteVectorsRequestT = Model::DeleteVectorsRequest>
        Model::DeleteVectorsOutcomeCallable DeleteVectorsCallable(const DeleteVectorsRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::DeleteVectors, request);
        }
 
        template<typename DeleteVectorsRequestT = Model::DeleteVectorsRequest>
        void DeleteVectorsAsync(const DeleteVectorsRequestT& request, const DeleteVectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::DeleteVectors, request, handler, context);
        }
 
        virtual Model::GetIndexOutcome GetIndex(const Model::GetIndexRequest& request = {}) const;
 
        template<typename GetIndexRequestT = Model::GetIndexRequest>
        Model::GetIndexOutcomeCallable GetIndexCallable(const GetIndexRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::GetIndex, request);
        }
 
        template<typename GetIndexRequestT = Model::GetIndexRequest>
        void GetIndexAsync(const GetIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetIndexRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::GetIndex, request, handler, context);
        }
 
        virtual Model::GetVectorBucketOutcome GetVectorBucket(const Model::GetVectorBucketRequest& request = {}) const;
 
        template<typename GetVectorBucketRequestT = Model::GetVectorBucketRequest>
        Model::GetVectorBucketOutcomeCallable GetVectorBucketCallable(const GetVectorBucketRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::GetVectorBucket, request);
        }
 
        template<typename GetVectorBucketRequestT = Model::GetVectorBucketRequest>
        void GetVectorBucketAsync(const GetVectorBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetVectorBucketRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::GetVectorBucket, request, handler, context);
        }
 
        virtual Model::GetVectorBucketPolicyOutcome GetVectorBucketPolicy(const Model::GetVectorBucketPolicyRequest& request = {}) const;
 
        template<typename GetVectorBucketPolicyRequestT = Model::GetVectorBucketPolicyRequest>
        Model::GetVectorBucketPolicyOutcomeCallable GetVectorBucketPolicyCallable(const GetVectorBucketPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::GetVectorBucketPolicy, request);
        }
 
        template<typename GetVectorBucketPolicyRequestT = Model::GetVectorBucketPolicyRequest>
        void GetVectorBucketPolicyAsync(const GetVectorBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetVectorBucketPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::GetVectorBucketPolicy, request, handler, context);
        }
 
        virtual Model::GetVectorsOutcome GetVectors(const Model::GetVectorsRequest& request) const;
 
        template<typename GetVectorsRequestT = Model::GetVectorsRequest>
        Model::GetVectorsOutcomeCallable GetVectorsCallable(const GetVectorsRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::GetVectors, request);
        }
 
        template<typename GetVectorsRequestT = Model::GetVectorsRequest>
        void GetVectorsAsync(const GetVectorsRequestT& request, const GetVectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::GetVectors, request, handler, context);
        }
 
        virtual Model::ListIndexesOutcome ListIndexes(const Model::ListIndexesRequest& request = {}) const;
 
        template<typename ListIndexesRequestT = Model::ListIndexesRequest>
        Model::ListIndexesOutcomeCallable ListIndexesCallable(const ListIndexesRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::ListIndexes, request);
        }
 
        template<typename ListIndexesRequestT = Model::ListIndexesRequest>
        void ListIndexesAsync(const ListIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIndexesRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::ListIndexes, request, handler, context);
        }
 
        virtual Model::ListVectorBucketsOutcome ListVectorBuckets(const Model::ListVectorBucketsRequest& request = {}) const;
 
        template<typename ListVectorBucketsRequestT = Model::ListVectorBucketsRequest>
        Model::ListVectorBucketsOutcomeCallable ListVectorBucketsCallable(const ListVectorBucketsRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::ListVectorBuckets, request);
        }
 
        template<typename ListVectorBucketsRequestT = Model::ListVectorBucketsRequest>
        void ListVectorBucketsAsync(const ListVectorBucketsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVectorBucketsRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::ListVectorBuckets, request, handler, context);
        }
 
        virtual Model::ListVectorsOutcome ListVectors(const Model::ListVectorsRequest& request = {}) const;
 
        template<typename ListVectorsRequestT = Model::ListVectorsRequest>
        Model::ListVectorsOutcomeCallable ListVectorsCallable(const ListVectorsRequestT& request = {}) const
        {
            return SubmitCallable(&S3VectorsClient::ListVectors, request);
        }
 
        template<typename ListVectorsRequestT = Model::ListVectorsRequest>
        void ListVectorsAsync(const ListVectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVectorsRequestT& request = {}) const
        {
            return SubmitAsync(&S3VectorsClient::ListVectors, request, handler, context);
        }
 
        virtual Model::PutVectorBucketPolicyOutcome PutVectorBucketPolicy(const Model::PutVectorBucketPolicyRequest& request) const;
 
        template<typename PutVectorBucketPolicyRequestT = Model::PutVectorBucketPolicyRequest>
        Model::PutVectorBucketPolicyOutcomeCallable PutVectorBucketPolicyCallable(const PutVectorBucketPolicyRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::PutVectorBucketPolicy, request);
        }
 
        template<typename PutVectorBucketPolicyRequestT = Model::PutVectorBucketPolicyRequest>
        void PutVectorBucketPolicyAsync(const PutVectorBucketPolicyRequestT& request, const PutVectorBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::PutVectorBucketPolicy, request, handler, context);
        }
 
        virtual Model::PutVectorsOutcome PutVectors(const Model::PutVectorsRequest& request) const;
 
        template<typename PutVectorsRequestT = Model::PutVectorsRequest>
        Model::PutVectorsOutcomeCallable PutVectorsCallable(const PutVectorsRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::PutVectors, request);
        }
 
        template<typename PutVectorsRequestT = Model::PutVectorsRequest>
        void PutVectorsAsync(const PutVectorsRequestT& request, const PutVectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::PutVectors, request, handler, context);
        }
 
        virtual Model::QueryVectorsOutcome QueryVectors(const Model::QueryVectorsRequest& request) const;
 
        template<typename QueryVectorsRequestT = Model::QueryVectorsRequest>
        Model::QueryVectorsOutcomeCallable QueryVectorsCallable(const QueryVectorsRequestT& request) const
        {
            return SubmitCallable(&S3VectorsClient::QueryVectors, request);
        }
 
        template<typename QueryVectorsRequestT = Model::QueryVectorsRequest>
        void QueryVectorsAsync(const QueryVectorsRequestT& request, const QueryVectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3VectorsClient::QueryVectors, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<S3VectorsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<S3VectorsClient>;
      void init(const S3VectorsClientConfiguration& clientConfiguration);
 
      S3VectorsClientConfiguration m_clientConfiguration;
      std::shared_ptr<S3VectorsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace S3Vectors
} // namespace Aws