Cloud9Client.h

 
#pragma once
#include <aws/cloud9/Cloud9ServiceClientModel.h>
#include <aws/cloud9/Cloud9_EXPORTS.h>
#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>
 
namespace Aws {
namespace Cloud9 {
class AWS_CLOUD9_API Cloud9Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<Cloud9Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Cloud9ClientConfiguration ClientConfigurationType;
  typedef Cloud9EndpointProvider EndpointProviderType;
 
  Cloud9Client(const Aws::Cloud9::Cloud9ClientConfiguration& clientConfiguration = Aws::Cloud9::Cloud9ClientConfiguration(),
               std::shared_ptr<Cloud9EndpointProviderBase> endpointProvider = nullptr);
 
  Cloud9Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<Cloud9EndpointProviderBase> endpointProvider = nullptr,
               const Aws::Cloud9::Cloud9ClientConfiguration& clientConfiguration = Aws::Cloud9::Cloud9ClientConfiguration());
 
  Cloud9Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               std::shared_ptr<Cloud9EndpointProviderBase> endpointProvider = nullptr,
               const Aws::Cloud9::Cloud9ClientConfiguration& clientConfiguration = Aws::Cloud9::Cloud9ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Cloud9Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Cloud9Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Cloud9Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Cloud9Client();
 
  virtual Model::CreateEnvironmentEC2Outcome CreateEnvironmentEC2(const Model::CreateEnvironmentEC2Request& request) const;
 
  template <typename CreateEnvironmentEC2RequestT = Model::CreateEnvironmentEC2Request>
  Model::CreateEnvironmentEC2OutcomeCallable CreateEnvironmentEC2Callable(const CreateEnvironmentEC2RequestT& request) const {
    return SubmitCallable(&Cloud9Client::CreateEnvironmentEC2, request);
  }
 
  template <typename CreateEnvironmentEC2RequestT = Model::CreateEnvironmentEC2Request>
  void CreateEnvironmentEC2Async(const CreateEnvironmentEC2RequestT& request, const CreateEnvironmentEC2ResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::CreateEnvironmentEC2, request, handler, context);
  }
 
  virtual Model::CreateEnvironmentMembershipOutcome CreateEnvironmentMembership(
      const Model::CreateEnvironmentMembershipRequest& request) const;
 
  template <typename CreateEnvironmentMembershipRequestT = Model::CreateEnvironmentMembershipRequest>
  Model::CreateEnvironmentMembershipOutcomeCallable CreateEnvironmentMembershipCallable(
      const CreateEnvironmentMembershipRequestT& request) const {
    return SubmitCallable(&Cloud9Client::CreateEnvironmentMembership, request);
  }
 
  template <typename CreateEnvironmentMembershipRequestT = Model::CreateEnvironmentMembershipRequest>
  void CreateEnvironmentMembershipAsync(const CreateEnvironmentMembershipRequestT& request,
                                        const CreateEnvironmentMembershipResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::CreateEnvironmentMembership, request, handler, context);
  }
 
  virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const;
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const {
    return SubmitCallable(&Cloud9Client::DeleteEnvironment, request);
  }
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::DeleteEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteEnvironmentMembershipOutcome DeleteEnvironmentMembership(
      const Model::DeleteEnvironmentMembershipRequest& request) const;
 
  template <typename DeleteEnvironmentMembershipRequestT = Model::DeleteEnvironmentMembershipRequest>
  Model::DeleteEnvironmentMembershipOutcomeCallable DeleteEnvironmentMembershipCallable(
      const DeleteEnvironmentMembershipRequestT& request) const {
    return SubmitCallable(&Cloud9Client::DeleteEnvironmentMembership, request);
  }
 
  template <typename DeleteEnvironmentMembershipRequestT = Model::DeleteEnvironmentMembershipRequest>
  void DeleteEnvironmentMembershipAsync(const DeleteEnvironmentMembershipRequestT& request,
                                        const DeleteEnvironmentMembershipResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::DeleteEnvironmentMembership, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentMembershipsOutcome DescribeEnvironmentMemberships(
      const Model::DescribeEnvironmentMembershipsRequest& request = {}) const;
 
  template <typename DescribeEnvironmentMembershipsRequestT = Model::DescribeEnvironmentMembershipsRequest>
  Model::DescribeEnvironmentMembershipsOutcomeCallable DescribeEnvironmentMembershipsCallable(
      const DescribeEnvironmentMembershipsRequestT& request = {}) const {
    return SubmitCallable(&Cloud9Client::DescribeEnvironmentMemberships, request);
  }
 
  template <typename DescribeEnvironmentMembershipsRequestT = Model::DescribeEnvironmentMembershipsRequest>
  void DescribeEnvironmentMembershipsAsync(const DescribeEnvironmentMembershipsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeEnvironmentMembershipsRequestT& request = {}) const {
    return SubmitAsync(&Cloud9Client::DescribeEnvironmentMemberships, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentStatusOutcome DescribeEnvironmentStatus(const Model::DescribeEnvironmentStatusRequest& request) const;
 
  template <typename DescribeEnvironmentStatusRequestT = Model::DescribeEnvironmentStatusRequest>
  Model::DescribeEnvironmentStatusOutcomeCallable DescribeEnvironmentStatusCallable(
      const DescribeEnvironmentStatusRequestT& request) const {
    return SubmitCallable(&Cloud9Client::DescribeEnvironmentStatus, request);
  }
 
  template <typename DescribeEnvironmentStatusRequestT = Model::DescribeEnvironmentStatusRequest>
  void DescribeEnvironmentStatusAsync(const DescribeEnvironmentStatusRequestT& request,
                                      const DescribeEnvironmentStatusResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::DescribeEnvironmentStatus, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentsOutcome DescribeEnvironments(const Model::DescribeEnvironmentsRequest& request) const;
 
  template <typename DescribeEnvironmentsRequestT = Model::DescribeEnvironmentsRequest>
  Model::DescribeEnvironmentsOutcomeCallable DescribeEnvironmentsCallable(const DescribeEnvironmentsRequestT& request) const {
    return SubmitCallable(&Cloud9Client::DescribeEnvironments, request);
  }
 
  template <typename DescribeEnvironmentsRequestT = Model::DescribeEnvironmentsRequest>
  void DescribeEnvironmentsAsync(const DescribeEnvironmentsRequestT& request, const DescribeEnvironmentsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::DescribeEnvironments, request, handler, context);
  }
 
  virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request = {}) const;
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request = {}) const {
    return SubmitCallable(&Cloud9Client::ListEnvironments, request);
  }
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  void ListEnvironmentsAsync(const ListEnvironmentsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListEnvironmentsRequestT& request = {}) const {
    return SubmitAsync(&Cloud9Client::ListEnvironments, 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(&Cloud9Client::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(&Cloud9Client::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(&Cloud9Client::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(&Cloud9Client::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(&Cloud9Client::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(&Cloud9Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const;
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const {
    return SubmitCallable(&Cloud9Client::UpdateEnvironment, request);
  }
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::UpdateEnvironment, request, handler, context);
  }
 
  virtual Model::UpdateEnvironmentMembershipOutcome UpdateEnvironmentMembership(
      const Model::UpdateEnvironmentMembershipRequest& request) const;
 
  template <typename UpdateEnvironmentMembershipRequestT = Model::UpdateEnvironmentMembershipRequest>
  Model::UpdateEnvironmentMembershipOutcomeCallable UpdateEnvironmentMembershipCallable(
      const UpdateEnvironmentMembershipRequestT& request) const {
    return SubmitCallable(&Cloud9Client::UpdateEnvironmentMembership, request);
  }
 
  template <typename UpdateEnvironmentMembershipRequestT = Model::UpdateEnvironmentMembershipRequest>
  void UpdateEnvironmentMembershipAsync(const UpdateEnvironmentMembershipRequestT& request,
                                        const UpdateEnvironmentMembershipResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Cloud9Client::UpdateEnvironmentMembership, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<Cloud9EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Cloud9Client>;
  void init(const Cloud9ClientConfiguration& clientConfiguration);
 
  Cloud9ClientConfiguration m_clientConfiguration;
  std::shared_ptr<Cloud9EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Cloud9
}  // namespace Aws