InterconnectClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/crt/cbor/Cbor.h>
#include <aws/interconnect/InterconnectPaginationBase.h>
#include <aws/interconnect/InterconnectServiceClientModel.h>
#include <aws/interconnect/InterconnectWaiter.h>
#include <aws/interconnect/Interconnect_EXPORTS.h>
 
namespace Aws {
namespace Interconnect {
class AWS_INTERCONNECT_API InterconnectClient : public Aws::Client::AWSRpcV2CborClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<InterconnectClient>,
                                                public InterconnectPaginationBase<InterconnectClient>,
                                                public InterconnectWaiter<InterconnectClient> {
 public:
  typedef Aws::Client::AWSRpcV2CborClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef InterconnectClientConfiguration ClientConfigurationType;
  typedef InterconnectEndpointProvider EndpointProviderType;
 
  InterconnectClient(
      const Aws::Interconnect::InterconnectClientConfiguration& clientConfiguration = Aws::Interconnect::InterconnectClientConfiguration(),
      std::shared_ptr<InterconnectEndpointProviderBase> endpointProvider = nullptr);
 
  InterconnectClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<InterconnectEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Interconnect::InterconnectClientConfiguration& clientConfiguration = Aws::Interconnect::InterconnectClientConfiguration());
 
  InterconnectClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<InterconnectEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Interconnect::InterconnectClientConfiguration& clientConfiguration = Aws::Interconnect::InterconnectClientConfiguration());
 
  /* Legacy constructors due deprecation */
  InterconnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  InterconnectClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  InterconnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~InterconnectClient();
 
  virtual Model::AcceptConnectionProposalOutcome AcceptConnectionProposal(const Model::AcceptConnectionProposalRequest& request) const;
 
  template <typename AcceptConnectionProposalRequestT = Model::AcceptConnectionProposalRequest>
  Model::AcceptConnectionProposalOutcomeCallable AcceptConnectionProposalCallable(const AcceptConnectionProposalRequestT& request) const {
    return SubmitCallable(&InterconnectClient::AcceptConnectionProposal, request);
  }
 
  template <typename AcceptConnectionProposalRequestT = Model::AcceptConnectionProposalRequest>
  void AcceptConnectionProposalAsync(const AcceptConnectionProposalRequestT& request,
                                     const AcceptConnectionProposalResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::AcceptConnectionProposal, request, handler, context);
  }
 
  virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
  template <typename CreateConnectionRequestT = Model::CreateConnectionRequest>
  Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const {
    return SubmitCallable(&InterconnectClient::CreateConnection, request);
  }
 
  template <typename CreateConnectionRequestT = Model::CreateConnectionRequest>
  void CreateConnectionAsync(const CreateConnectionRequestT& request, const CreateConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::CreateConnection, request, handler, context);
  }
 
  virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const {
    return SubmitCallable(&InterconnectClient::DeleteConnection, request);
  }
 
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::DeleteConnection, request, handler, context);
  }
 
  virtual Model::DescribeConnectionProposalOutcome DescribeConnectionProposal(
      const Model::DescribeConnectionProposalRequest& request) const;
 
  template <typename DescribeConnectionProposalRequestT = Model::DescribeConnectionProposalRequest>
  Model::DescribeConnectionProposalOutcomeCallable DescribeConnectionProposalCallable(
      const DescribeConnectionProposalRequestT& request) const {
    return SubmitCallable(&InterconnectClient::DescribeConnectionProposal, request);
  }
 
  template <typename DescribeConnectionProposalRequestT = Model::DescribeConnectionProposalRequest>
  void DescribeConnectionProposalAsync(const DescribeConnectionProposalRequestT& request,
                                       const DescribeConnectionProposalResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::DescribeConnectionProposal, request, handler, context);
  }
 
  virtual Model::GetConnectionOutcome GetConnection(const Model::GetConnectionRequest& request) const;
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  Model::GetConnectionOutcomeCallable GetConnectionCallable(const GetConnectionRequestT& request) const {
    return SubmitCallable(&InterconnectClient::GetConnection, request);
  }
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  void GetConnectionAsync(const GetConnectionRequestT& request, const GetConnectionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::GetConnection, request, handler, context);
  }
 
  virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const;
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const {
    return SubmitCallable(&InterconnectClient::GetEnvironment, request);
  }
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::GetEnvironment, request, handler, context);
  }
 
  virtual Model::ListAttachPointsOutcome ListAttachPoints(const Model::ListAttachPointsRequest& request) const;
 
  template <typename ListAttachPointsRequestT = Model::ListAttachPointsRequest>
  Model::ListAttachPointsOutcomeCallable ListAttachPointsCallable(const ListAttachPointsRequestT& request) const {
    return SubmitCallable(&InterconnectClient::ListAttachPoints, request);
  }
 
  template <typename ListAttachPointsRequestT = Model::ListAttachPointsRequest>
  void ListAttachPointsAsync(const ListAttachPointsRequestT& request, const ListAttachPointsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::ListAttachPoints, request, handler, context);
  }
 
  virtual Model::ListConnectionsOutcome ListConnections(const Model::ListConnectionsRequest& request = {}) const;
 
  template <typename ListConnectionsRequestT = Model::ListConnectionsRequest>
  Model::ListConnectionsOutcomeCallable ListConnectionsCallable(const ListConnectionsRequestT& request = {}) const {
    return SubmitCallable(&InterconnectClient::ListConnections, request);
  }
 
  template <typename ListConnectionsRequestT = Model::ListConnectionsRequest>
  void ListConnectionsAsync(const ListConnectionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListConnectionsRequestT& request = {}) const {
    return SubmitAsync(&InterconnectClient::ListConnections, 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(&InterconnectClient::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(&InterconnectClient::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(&InterconnectClient::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(&InterconnectClient::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(&InterconnectClient::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(&InterconnectClient::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(&InterconnectClient::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(&InterconnectClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateConnectionOutcome UpdateConnection(const Model::UpdateConnectionRequest& request) const;
 
  template <typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
  Model::UpdateConnectionOutcomeCallable UpdateConnectionCallable(const UpdateConnectionRequestT& request) const {
    return SubmitCallable(&InterconnectClient::UpdateConnection, request);
  }
 
  template <typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
  void UpdateConnectionAsync(const UpdateConnectionRequestT& request, const UpdateConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InterconnectClient::UpdateConnection, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<InterconnectEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<InterconnectClient>;
  void init(const InterconnectClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, InterconnectError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  InterconnectClientConfiguration m_clientConfiguration;
  std::shared_ptr<InterconnectEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Interconnect
}  // namespace Aws