MediaPackageVodClient.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/mediapackage-vod/MediaPackageVodPaginationBase.h>
#include <aws/mediapackage-vod/MediaPackageVodServiceClientModel.h>
#include <aws/mediapackage-vod/MediaPackageVod_EXPORTS.h>
 
namespace Aws {
namespace MediaPackageVod {
class AWS_MEDIAPACKAGEVOD_API MediaPackageVodClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<MediaPackageVodClient>,
                                                      public MediaPackageVodPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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