KinesisVideoArchivedMediaClient.h

 
#pragma once
#include <aws/kinesis-video-archived-media/KinesisVideoArchivedMedia_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/kinesis-video-archived-media/KinesisVideoArchivedMediaServiceClientModel.h>
 
namespace Aws
{
namespace KinesisVideoArchivedMedia
{
  class AWS_KINESISVIDEOARCHIVEDMEDIA_API KinesisVideoArchivedMediaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<KinesisVideoArchivedMediaClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef KinesisVideoArchivedMediaClientConfiguration ClientConfigurationType;
      typedef KinesisVideoArchivedMediaEndpointProvider EndpointProviderType;
 
        KinesisVideoArchivedMediaClient(const Aws::KinesisVideoArchivedMedia::KinesisVideoArchivedMediaClientConfiguration& clientConfiguration = Aws::KinesisVideoArchivedMedia::KinesisVideoArchivedMediaClientConfiguration(),
                                        std::shared_ptr<KinesisVideoArchivedMediaEndpointProviderBase> endpointProvider = nullptr);
 
        KinesisVideoArchivedMediaClient(const Aws::Auth::AWSCredentials& credentials,
                                        std::shared_ptr<KinesisVideoArchivedMediaEndpointProviderBase> endpointProvider = nullptr,
                                        const Aws::KinesisVideoArchivedMedia::KinesisVideoArchivedMediaClientConfiguration& clientConfiguration = Aws::KinesisVideoArchivedMedia::KinesisVideoArchivedMediaClientConfiguration());
 
        KinesisVideoArchivedMediaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                        std::shared_ptr<KinesisVideoArchivedMediaEndpointProviderBase> endpointProvider = nullptr,
                                        const Aws::KinesisVideoArchivedMedia::KinesisVideoArchivedMediaClientConfiguration& clientConfiguration = Aws::KinesisVideoArchivedMedia::KinesisVideoArchivedMediaClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        KinesisVideoArchivedMediaClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        KinesisVideoArchivedMediaClient(const Aws::Auth::AWSCredentials& credentials,
                                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        KinesisVideoArchivedMediaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~KinesisVideoArchivedMediaClient();
 
        virtual Model::GetClipOutcome GetClip(const Model::GetClipRequest& request) const;
 
        template<typename GetClipRequestT = Model::GetClipRequest>
        Model::GetClipOutcomeCallable GetClipCallable(const GetClipRequestT& request) const
        {
            return SubmitCallable(&KinesisVideoArchivedMediaClient::GetClip, request);
        }
 
        template<typename GetClipRequestT = Model::GetClipRequest>
        void GetClipAsync(const GetClipRequestT& request, const GetClipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisVideoArchivedMediaClient::GetClip, request, handler, context);
        }
 
        virtual Model::GetDASHStreamingSessionURLOutcome GetDASHStreamingSessionURL(const Model::GetDASHStreamingSessionURLRequest& request = {}) const;
 
        template<typename GetDASHStreamingSessionURLRequestT = Model::GetDASHStreamingSessionURLRequest>
        Model::GetDASHStreamingSessionURLOutcomeCallable GetDASHStreamingSessionURLCallable(const GetDASHStreamingSessionURLRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisVideoArchivedMediaClient::GetDASHStreamingSessionURL, request);
        }
 
        template<typename GetDASHStreamingSessionURLRequestT = Model::GetDASHStreamingSessionURLRequest>
        void GetDASHStreamingSessionURLAsync(const GetDASHStreamingSessionURLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDASHStreamingSessionURLRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisVideoArchivedMediaClient::GetDASHStreamingSessionURL, request, handler, context);
        }
 
        virtual Model::GetHLSStreamingSessionURLOutcome GetHLSStreamingSessionURL(const Model::GetHLSStreamingSessionURLRequest& request = {}) const;
 
        template<typename GetHLSStreamingSessionURLRequestT = Model::GetHLSStreamingSessionURLRequest>
        Model::GetHLSStreamingSessionURLOutcomeCallable GetHLSStreamingSessionURLCallable(const GetHLSStreamingSessionURLRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisVideoArchivedMediaClient::GetHLSStreamingSessionURL, request);
        }
 
        template<typename GetHLSStreamingSessionURLRequestT = Model::GetHLSStreamingSessionURLRequest>
        void GetHLSStreamingSessionURLAsync(const GetHLSStreamingSessionURLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetHLSStreamingSessionURLRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisVideoArchivedMediaClient::GetHLSStreamingSessionURL, request, handler, context);
        }
 
        virtual Model::GetImagesOutcome GetImages(const Model::GetImagesRequest& request) const;
 
        template<typename GetImagesRequestT = Model::GetImagesRequest>
        Model::GetImagesOutcomeCallable GetImagesCallable(const GetImagesRequestT& request) const
        {
            return SubmitCallable(&KinesisVideoArchivedMediaClient::GetImages, request);
        }
 
        template<typename GetImagesRequestT = Model::GetImagesRequest>
        void GetImagesAsync(const GetImagesRequestT& request, const GetImagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisVideoArchivedMediaClient::GetImages, request, handler, context);
        }
 
        virtual Model::GetMediaForFragmentListOutcome GetMediaForFragmentList(const Model::GetMediaForFragmentListRequest& request) const;
 
        template<typename GetMediaForFragmentListRequestT = Model::GetMediaForFragmentListRequest>
        Model::GetMediaForFragmentListOutcomeCallable GetMediaForFragmentListCallable(const GetMediaForFragmentListRequestT& request) const
        {
            return SubmitCallable(&KinesisVideoArchivedMediaClient::GetMediaForFragmentList, request);
        }
 
        template<typename GetMediaForFragmentListRequestT = Model::GetMediaForFragmentListRequest>
        void GetMediaForFragmentListAsync(const GetMediaForFragmentListRequestT& request, const GetMediaForFragmentListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KinesisVideoArchivedMediaClient::GetMediaForFragmentList, request, handler, context);
        }
 
        virtual Model::ListFragmentsOutcome ListFragments(const Model::ListFragmentsRequest& request = {}) const;
 
        template<typename ListFragmentsRequestT = Model::ListFragmentsRequest>
        Model::ListFragmentsOutcomeCallable ListFragmentsCallable(const ListFragmentsRequestT& request = {}) const
        {
            return SubmitCallable(&KinesisVideoArchivedMediaClient::ListFragments, request);
        }
 
        template<typename ListFragmentsRequestT = Model::ListFragmentsRequest>
        void ListFragmentsAsync(const ListFragmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFragmentsRequestT& request = {}) const
        {
            return SubmitAsync(&KinesisVideoArchivedMediaClient::ListFragments, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<KinesisVideoArchivedMediaEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisVideoArchivedMediaClient>;
      void init(const KinesisVideoArchivedMediaClientConfiguration& clientConfiguration);
 
      KinesisVideoArchivedMediaClientConfiguration m_clientConfiguration;
      std::shared_ptr<KinesisVideoArchivedMediaEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace KinesisVideoArchivedMedia
} // namespace Aws