MediaPackageVodClient.h

 
#pragma once
#include <aws/mediapackage-vod/MediaPackageVod_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/mediapackage-vod/MediaPackageVodServiceClientModel.h>
 
namespace Aws
{
namespace MediaPackageVod
{
  class AWS_MEDIAPACKAGEVOD_API MediaPackageVodClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MediaPackageVodClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MediaPackageVodClientConfiguration ClientConfigurationType;
      typedef MediaPackageVodEndpointProvider EndpointProviderType;
 
        MediaPackageVodClient(const Aws::MediaPackageVod::MediaPackageVodClientConfiguration& clientConfiguration = Aws::MediaPackageVod::MediaPackageVodClientConfiguration(),
                              std::shared_ptr<MediaPackageVodEndpointProviderBase> endpointProvider = nullptr);
 
        MediaPackageVodClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<MediaPackageVodEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::MediaPackageVod::MediaPackageVodClientConfiguration& clientConfiguration = Aws::MediaPackageVod::MediaPackageVodClientConfiguration());
 
        MediaPackageVodClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<MediaPackageVodEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::MediaPackageVod::MediaPackageVodClientConfiguration& clientConfiguration = Aws::MediaPackageVod::MediaPackageVodClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MediaPackageVodClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaPackageVodClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaPackageVodClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MediaPackageVodClient();
 
        virtual Model::ConfigureLogsOutcome ConfigureLogs(const Model::ConfigureLogsRequest& request) const;
 
        template<typename ConfigureLogsRequestT = Model::ConfigureLogsRequest>
        Model::ConfigureLogsOutcomeCallable ConfigureLogsCallable(const ConfigureLogsRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::ConfigureLogs, request);
        }
 
        template<typename ConfigureLogsRequestT = Model::ConfigureLogsRequest>
        void ConfigureLogsAsync(const ConfigureLogsRequestT& request, const ConfigureLogsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::ConfigureLogs, request, handler, context);
        }
 
        virtual Model::CreateAssetOutcome CreateAsset(const Model::CreateAssetRequest& request) const;
 
        template<typename CreateAssetRequestT = Model::CreateAssetRequest>
        Model::CreateAssetOutcomeCallable CreateAssetCallable(const CreateAssetRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::CreateAsset, request);
        }
 
        template<typename CreateAssetRequestT = Model::CreateAssetRequest>
        void CreateAssetAsync(const CreateAssetRequestT& request, const CreateAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::CreateAsset, request, handler, context);
        }
 
        virtual Model::CreatePackagingConfigurationOutcome CreatePackagingConfiguration(const Model::CreatePackagingConfigurationRequest& request) const;
 
        template<typename CreatePackagingConfigurationRequestT = Model::CreatePackagingConfigurationRequest>
        Model::CreatePackagingConfigurationOutcomeCallable CreatePackagingConfigurationCallable(const CreatePackagingConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::CreatePackagingConfiguration, request);
        }
 
        template<typename CreatePackagingConfigurationRequestT = Model::CreatePackagingConfigurationRequest>
        void CreatePackagingConfigurationAsync(const CreatePackagingConfigurationRequestT& request, const CreatePackagingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::CreatePackagingConfiguration, request, handler, context);
        }
 
        virtual Model::CreatePackagingGroupOutcome CreatePackagingGroup(const Model::CreatePackagingGroupRequest& request) const;
 
        template<typename CreatePackagingGroupRequestT = Model::CreatePackagingGroupRequest>
        Model::CreatePackagingGroupOutcomeCallable CreatePackagingGroupCallable(const CreatePackagingGroupRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::CreatePackagingGroup, request);
        }
 
        template<typename CreatePackagingGroupRequestT = Model::CreatePackagingGroupRequest>
        void CreatePackagingGroupAsync(const CreatePackagingGroupRequestT& request, const CreatePackagingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::CreatePackagingGroup, request, handler, context);
        }
 
        virtual Model::DeleteAssetOutcome DeleteAsset(const Model::DeleteAssetRequest& request) const;
 
        template<typename DeleteAssetRequestT = Model::DeleteAssetRequest>
        Model::DeleteAssetOutcomeCallable DeleteAssetCallable(const DeleteAssetRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::DeleteAsset, request);
        }
 
        template<typename DeleteAssetRequestT = Model::DeleteAssetRequest>
        void DeleteAssetAsync(const DeleteAssetRequestT& request, const DeleteAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::DeleteAsset, request, handler, context);
        }
 
        virtual Model::DeletePackagingConfigurationOutcome DeletePackagingConfiguration(const Model::DeletePackagingConfigurationRequest& request) const;
 
        template<typename DeletePackagingConfigurationRequestT = Model::DeletePackagingConfigurationRequest>
        Model::DeletePackagingConfigurationOutcomeCallable DeletePackagingConfigurationCallable(const DeletePackagingConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::DeletePackagingConfiguration, request);
        }
 
        template<typename DeletePackagingConfigurationRequestT = Model::DeletePackagingConfigurationRequest>
        void DeletePackagingConfigurationAsync(const DeletePackagingConfigurationRequestT& request, const DeletePackagingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::DeletePackagingConfiguration, request, handler, context);
        }
 
        virtual Model::DeletePackagingGroupOutcome DeletePackagingGroup(const Model::DeletePackagingGroupRequest& request) const;
 
        template<typename DeletePackagingGroupRequestT = Model::DeletePackagingGroupRequest>
        Model::DeletePackagingGroupOutcomeCallable DeletePackagingGroupCallable(const DeletePackagingGroupRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::DeletePackagingGroup, request);
        }
 
        template<typename DeletePackagingGroupRequestT = Model::DeletePackagingGroupRequest>
        void DeletePackagingGroupAsync(const DeletePackagingGroupRequestT& request, const DeletePackagingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::DeletePackagingGroup, request, handler, context);
        }
 
        virtual Model::DescribeAssetOutcome DescribeAsset(const Model::DescribeAssetRequest& request) const;
 
        template<typename DescribeAssetRequestT = Model::DescribeAssetRequest>
        Model::DescribeAssetOutcomeCallable DescribeAssetCallable(const DescribeAssetRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::DescribeAsset, request);
        }
 
        template<typename DescribeAssetRequestT = Model::DescribeAssetRequest>
        void DescribeAssetAsync(const DescribeAssetRequestT& request, const DescribeAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::DescribeAsset, request, handler, context);
        }
 
        virtual Model::DescribePackagingConfigurationOutcome DescribePackagingConfiguration(const Model::DescribePackagingConfigurationRequest& request) const;
 
        template<typename DescribePackagingConfigurationRequestT = Model::DescribePackagingConfigurationRequest>
        Model::DescribePackagingConfigurationOutcomeCallable DescribePackagingConfigurationCallable(const DescribePackagingConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::DescribePackagingConfiguration, request);
        }
 
        template<typename DescribePackagingConfigurationRequestT = Model::DescribePackagingConfigurationRequest>
        void DescribePackagingConfigurationAsync(const DescribePackagingConfigurationRequestT& request, const DescribePackagingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::DescribePackagingConfiguration, request, handler, context);
        }
 
        virtual Model::DescribePackagingGroupOutcome DescribePackagingGroup(const Model::DescribePackagingGroupRequest& request) const;
 
        template<typename DescribePackagingGroupRequestT = Model::DescribePackagingGroupRequest>
        Model::DescribePackagingGroupOutcomeCallable DescribePackagingGroupCallable(const DescribePackagingGroupRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::DescribePackagingGroup, request);
        }
 
        template<typename DescribePackagingGroupRequestT = Model::DescribePackagingGroupRequest>
        void DescribePackagingGroupAsync(const DescribePackagingGroupRequestT& request, const DescribePackagingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::DescribePackagingGroup, request, handler, context);
        }
 
        virtual Model::ListAssetsOutcome ListAssets(const Model::ListAssetsRequest& request = {}) const;
 
        template<typename ListAssetsRequestT = Model::ListAssetsRequest>
        Model::ListAssetsOutcomeCallable ListAssetsCallable(const ListAssetsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaPackageVodClient::ListAssets, request);
        }
 
        template<typename ListAssetsRequestT = Model::ListAssetsRequest>
        void ListAssetsAsync(const ListAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAssetsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaPackageVodClient::ListAssets, request, handler, context);
        }
 
        virtual Model::ListPackagingConfigurationsOutcome ListPackagingConfigurations(const Model::ListPackagingConfigurationsRequest& request = {}) const;
 
        template<typename ListPackagingConfigurationsRequestT = Model::ListPackagingConfigurationsRequest>
        Model::ListPackagingConfigurationsOutcomeCallable ListPackagingConfigurationsCallable(const ListPackagingConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaPackageVodClient::ListPackagingConfigurations, request);
        }
 
        template<typename ListPackagingConfigurationsRequestT = Model::ListPackagingConfigurationsRequest>
        void ListPackagingConfigurationsAsync(const ListPackagingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPackagingConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaPackageVodClient::ListPackagingConfigurations, request, handler, context);
        }
 
        virtual Model::ListPackagingGroupsOutcome ListPackagingGroups(const Model::ListPackagingGroupsRequest& request = {}) const;
 
        template<typename ListPackagingGroupsRequestT = Model::ListPackagingGroupsRequest>
        Model::ListPackagingGroupsOutcomeCallable ListPackagingGroupsCallable(const ListPackagingGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaPackageVodClient::ListPackagingGroups, request);
        }
 
        template<typename ListPackagingGroupsRequestT = Model::ListPackagingGroupsRequest>
        void ListPackagingGroupsAsync(const ListPackagingGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPackagingGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaPackageVodClient::ListPackagingGroups, 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(&MediaPackageVodClient::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(&MediaPackageVodClient::ListTagsForResource, 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(&MediaPackageVodClient::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(&MediaPackageVodClient::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(&MediaPackageVodClient::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(&MediaPackageVodClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdatePackagingGroupOutcome UpdatePackagingGroup(const Model::UpdatePackagingGroupRequest& request) const;
 
        template<typename UpdatePackagingGroupRequestT = Model::UpdatePackagingGroupRequest>
        Model::UpdatePackagingGroupOutcomeCallable UpdatePackagingGroupCallable(const UpdatePackagingGroupRequestT& request) const
        {
            return SubmitCallable(&MediaPackageVodClient::UpdatePackagingGroup, request);
        }
 
        template<typename UpdatePackagingGroupRequestT = Model::UpdatePackagingGroupRequest>
        void UpdatePackagingGroupAsync(const UpdatePackagingGroupRequestT& request, const UpdatePackagingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaPackageVodClient::UpdatePackagingGroup, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MediaPackageVodEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaPackageVodClient>;
      void init(const MediaPackageVodClientConfiguration& clientConfiguration);
 
      MediaPackageVodClientConfiguration m_clientConfiguration;
      std::shared_ptr<MediaPackageVodEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MediaPackageVod
} // namespace Aws