MediaStoreClient.h

 
#pragma once
#include <aws/mediastore/MediaStore_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/mediastore/MediaStoreServiceClientModel.h>
 
namespace Aws
{
namespace MediaStore
{
  class AWS_MEDIASTORE_API MediaStoreClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MediaStoreClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MediaStoreClientConfiguration ClientConfigurationType;
      typedef MediaStoreEndpointProvider EndpointProviderType;
 
        MediaStoreClient(const Aws::MediaStore::MediaStoreClientConfiguration& clientConfiguration = Aws::MediaStore::MediaStoreClientConfiguration(),
                         std::shared_ptr<MediaStoreEndpointProviderBase> endpointProvider = nullptr);
 
        MediaStoreClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<MediaStoreEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::MediaStore::MediaStoreClientConfiguration& clientConfiguration = Aws::MediaStore::MediaStoreClientConfiguration());
 
        MediaStoreClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<MediaStoreEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::MediaStore::MediaStoreClientConfiguration& clientConfiguration = Aws::MediaStore::MediaStoreClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MediaStoreClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaStoreClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaStoreClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MediaStoreClient();
 
        virtual Model::CreateContainerOutcome CreateContainer(const Model::CreateContainerRequest& request) const;
 
        template<typename CreateContainerRequestT = Model::CreateContainerRequest>
        Model::CreateContainerOutcomeCallable CreateContainerCallable(const CreateContainerRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::CreateContainer, request);
        }
 
        template<typename CreateContainerRequestT = Model::CreateContainerRequest>
        void CreateContainerAsync(const CreateContainerRequestT& request, const CreateContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::CreateContainer, request, handler, context);
        }
 
        virtual Model::DeleteContainerOutcome DeleteContainer(const Model::DeleteContainerRequest& request) const;
 
        template<typename DeleteContainerRequestT = Model::DeleteContainerRequest>
        Model::DeleteContainerOutcomeCallable DeleteContainerCallable(const DeleteContainerRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::DeleteContainer, request);
        }
 
        template<typename DeleteContainerRequestT = Model::DeleteContainerRequest>
        void DeleteContainerAsync(const DeleteContainerRequestT& request, const DeleteContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::DeleteContainer, request, handler, context);
        }
 
        virtual Model::DeleteContainerPolicyOutcome DeleteContainerPolicy(const Model::DeleteContainerPolicyRequest& request) const;
 
        template<typename DeleteContainerPolicyRequestT = Model::DeleteContainerPolicyRequest>
        Model::DeleteContainerPolicyOutcomeCallable DeleteContainerPolicyCallable(const DeleteContainerPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::DeleteContainerPolicy, request);
        }
 
        template<typename DeleteContainerPolicyRequestT = Model::DeleteContainerPolicyRequest>
        void DeleteContainerPolicyAsync(const DeleteContainerPolicyRequestT& request, const DeleteContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::DeleteContainerPolicy, request, handler, context);
        }
 
        virtual Model::DeleteCorsPolicyOutcome DeleteCorsPolicy(const Model::DeleteCorsPolicyRequest& request) const;
 
        template<typename DeleteCorsPolicyRequestT = Model::DeleteCorsPolicyRequest>
        Model::DeleteCorsPolicyOutcomeCallable DeleteCorsPolicyCallable(const DeleteCorsPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::DeleteCorsPolicy, request);
        }
 
        template<typename DeleteCorsPolicyRequestT = Model::DeleteCorsPolicyRequest>
        void DeleteCorsPolicyAsync(const DeleteCorsPolicyRequestT& request, const DeleteCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::DeleteCorsPolicy, request, handler, context);
        }
 
        virtual Model::DeleteLifecyclePolicyOutcome DeleteLifecyclePolicy(const Model::DeleteLifecyclePolicyRequest& request) const;
 
        template<typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
        Model::DeleteLifecyclePolicyOutcomeCallable DeleteLifecyclePolicyCallable(const DeleteLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::DeleteLifecyclePolicy, request);
        }
 
        template<typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
        void DeleteLifecyclePolicyAsync(const DeleteLifecyclePolicyRequestT& request, const DeleteLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::DeleteLifecyclePolicy, request, handler, context);
        }
 
        virtual Model::DeleteMetricPolicyOutcome DeleteMetricPolicy(const Model::DeleteMetricPolicyRequest& request) const;
 
        template<typename DeleteMetricPolicyRequestT = Model::DeleteMetricPolicyRequest>
        Model::DeleteMetricPolicyOutcomeCallable DeleteMetricPolicyCallable(const DeleteMetricPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::DeleteMetricPolicy, request);
        }
 
        template<typename DeleteMetricPolicyRequestT = Model::DeleteMetricPolicyRequest>
        void DeleteMetricPolicyAsync(const DeleteMetricPolicyRequestT& request, const DeleteMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::DeleteMetricPolicy, request, handler, context);
        }
 
        virtual Model::DescribeContainerOutcome DescribeContainer(const Model::DescribeContainerRequest& request = {}) const;
 
        template<typename DescribeContainerRequestT = Model::DescribeContainerRequest>
        Model::DescribeContainerOutcomeCallable DescribeContainerCallable(const DescribeContainerRequestT& request = {}) const
        {
            return SubmitCallable(&MediaStoreClient::DescribeContainer, request);
        }
 
        template<typename DescribeContainerRequestT = Model::DescribeContainerRequest>
        void DescribeContainerAsync(const DescribeContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeContainerRequestT& request = {}) const
        {
            return SubmitAsync(&MediaStoreClient::DescribeContainer, request, handler, context);
        }
 
        virtual Model::GetContainerPolicyOutcome GetContainerPolicy(const Model::GetContainerPolicyRequest& request) const;
 
        template<typename GetContainerPolicyRequestT = Model::GetContainerPolicyRequest>
        Model::GetContainerPolicyOutcomeCallable GetContainerPolicyCallable(const GetContainerPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::GetContainerPolicy, request);
        }
 
        template<typename GetContainerPolicyRequestT = Model::GetContainerPolicyRequest>
        void GetContainerPolicyAsync(const GetContainerPolicyRequestT& request, const GetContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::GetContainerPolicy, request, handler, context);
        }
 
        virtual Model::GetCorsPolicyOutcome GetCorsPolicy(const Model::GetCorsPolicyRequest& request) const;
 
        template<typename GetCorsPolicyRequestT = Model::GetCorsPolicyRequest>
        Model::GetCorsPolicyOutcomeCallable GetCorsPolicyCallable(const GetCorsPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::GetCorsPolicy, request);
        }
 
        template<typename GetCorsPolicyRequestT = Model::GetCorsPolicyRequest>
        void GetCorsPolicyAsync(const GetCorsPolicyRequestT& request, const GetCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::GetCorsPolicy, request, handler, context);
        }
 
        virtual Model::GetLifecyclePolicyOutcome GetLifecyclePolicy(const Model::GetLifecyclePolicyRequest& request) const;
 
        template<typename GetLifecyclePolicyRequestT = Model::GetLifecyclePolicyRequest>
        Model::GetLifecyclePolicyOutcomeCallable GetLifecyclePolicyCallable(const GetLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::GetLifecyclePolicy, request);
        }
 
        template<typename GetLifecyclePolicyRequestT = Model::GetLifecyclePolicyRequest>
        void GetLifecyclePolicyAsync(const GetLifecyclePolicyRequestT& request, const GetLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::GetLifecyclePolicy, request, handler, context);
        }
 
        virtual Model::GetMetricPolicyOutcome GetMetricPolicy(const Model::GetMetricPolicyRequest& request) const;
 
        template<typename GetMetricPolicyRequestT = Model::GetMetricPolicyRequest>
        Model::GetMetricPolicyOutcomeCallable GetMetricPolicyCallable(const GetMetricPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::GetMetricPolicy, request);
        }
 
        template<typename GetMetricPolicyRequestT = Model::GetMetricPolicyRequest>
        void GetMetricPolicyAsync(const GetMetricPolicyRequestT& request, const GetMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::GetMetricPolicy, request, handler, context);
        }
 
        virtual Model::ListContainersOutcome ListContainers(const Model::ListContainersRequest& request = {}) const;
 
        template<typename ListContainersRequestT = Model::ListContainersRequest>
        Model::ListContainersOutcomeCallable ListContainersCallable(const ListContainersRequestT& request = {}) const
        {
            return SubmitCallable(&MediaStoreClient::ListContainers, request);
        }
 
        template<typename ListContainersRequestT = Model::ListContainersRequest>
        void ListContainersAsync(const ListContainersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListContainersRequestT& request = {}) const
        {
            return SubmitAsync(&MediaStoreClient::ListContainers, 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(&MediaStoreClient::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(&MediaStoreClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutContainerPolicyOutcome PutContainerPolicy(const Model::PutContainerPolicyRequest& request) const;
 
        template<typename PutContainerPolicyRequestT = Model::PutContainerPolicyRequest>
        Model::PutContainerPolicyOutcomeCallable PutContainerPolicyCallable(const PutContainerPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::PutContainerPolicy, request);
        }
 
        template<typename PutContainerPolicyRequestT = Model::PutContainerPolicyRequest>
        void PutContainerPolicyAsync(const PutContainerPolicyRequestT& request, const PutContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::PutContainerPolicy, request, handler, context);
        }
 
        virtual Model::PutCorsPolicyOutcome PutCorsPolicy(const Model::PutCorsPolicyRequest& request) const;
 
        template<typename PutCorsPolicyRequestT = Model::PutCorsPolicyRequest>
        Model::PutCorsPolicyOutcomeCallable PutCorsPolicyCallable(const PutCorsPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::PutCorsPolicy, request);
        }
 
        template<typename PutCorsPolicyRequestT = Model::PutCorsPolicyRequest>
        void PutCorsPolicyAsync(const PutCorsPolicyRequestT& request, const PutCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::PutCorsPolicy, request, handler, context);
        }
 
        virtual Model::PutLifecyclePolicyOutcome PutLifecyclePolicy(const Model::PutLifecyclePolicyRequest& request) const;
 
        template<typename PutLifecyclePolicyRequestT = Model::PutLifecyclePolicyRequest>
        Model::PutLifecyclePolicyOutcomeCallable PutLifecyclePolicyCallable(const PutLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::PutLifecyclePolicy, request);
        }
 
        template<typename PutLifecyclePolicyRequestT = Model::PutLifecyclePolicyRequest>
        void PutLifecyclePolicyAsync(const PutLifecyclePolicyRequestT& request, const PutLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::PutLifecyclePolicy, request, handler, context);
        }
 
        virtual Model::PutMetricPolicyOutcome PutMetricPolicy(const Model::PutMetricPolicyRequest& request) const;
 
        template<typename PutMetricPolicyRequestT = Model::PutMetricPolicyRequest>
        Model::PutMetricPolicyOutcomeCallable PutMetricPolicyCallable(const PutMetricPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::PutMetricPolicy, request);
        }
 
        template<typename PutMetricPolicyRequestT = Model::PutMetricPolicyRequest>
        void PutMetricPolicyAsync(const PutMetricPolicyRequestT& request, const PutMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::PutMetricPolicy, request, handler, context);
        }
 
        virtual Model::StartAccessLoggingOutcome StartAccessLogging(const Model::StartAccessLoggingRequest& request) const;
 
        template<typename StartAccessLoggingRequestT = Model::StartAccessLoggingRequest>
        Model::StartAccessLoggingOutcomeCallable StartAccessLoggingCallable(const StartAccessLoggingRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::StartAccessLogging, request);
        }
 
        template<typename StartAccessLoggingRequestT = Model::StartAccessLoggingRequest>
        void StartAccessLoggingAsync(const StartAccessLoggingRequestT& request, const StartAccessLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::StartAccessLogging, request, handler, context);
        }
 
        virtual Model::StopAccessLoggingOutcome StopAccessLogging(const Model::StopAccessLoggingRequest& request) const;
 
        template<typename StopAccessLoggingRequestT = Model::StopAccessLoggingRequest>
        Model::StopAccessLoggingOutcomeCallable StopAccessLoggingCallable(const StopAccessLoggingRequestT& request) const
        {
            return SubmitCallable(&MediaStoreClient::StopAccessLogging, request);
        }
 
        template<typename StopAccessLoggingRequestT = Model::StopAccessLoggingRequest>
        void StopAccessLoggingAsync(const StopAccessLoggingRequestT& request, const StopAccessLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaStoreClient::StopAccessLogging, 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(&MediaStoreClient::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(&MediaStoreClient::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(&MediaStoreClient::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(&MediaStoreClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MediaStoreEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaStoreClient>;
      void init(const MediaStoreClientConfiguration& clientConfiguration);
 
      MediaStoreClientConfiguration m_clientConfiguration;
      std::shared_ptr<MediaStoreEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MediaStore
} // namespace Aws