EventBridgeClient.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/eventbridge/EventBridgePaginationBase.h>
#include <aws/eventbridge/EventBridgeServiceClientModel.h>
#include <aws/eventbridge/EventBridgeWaiter.h>
#include <aws/eventbridge/EventBridge_EXPORTS.h>
 
namespace Aws {
namespace EventBridge {
class AWS_EVENTBRIDGE_API EventBridgeClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<EventBridgeClient>,
                                              public EventBridgePaginationBase<EventBridgeClient>,
                                              public EventBridgeWaiter<EventBridgeClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef EventBridgeClientConfiguration ClientConfigurationType;
  typedef EventBridgeEndpointProvider EndpointProviderType;
 
  EventBridgeClient(
      const Aws::EventBridge::EventBridgeClientConfiguration& clientConfiguration = Aws::EventBridge::EventBridgeClientConfiguration(),
      std::shared_ptr<EventBridgeEndpointProviderBase> endpointProvider = nullptr);
 
  EventBridgeClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<EventBridgeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::EventBridge::EventBridgeClientConfiguration& clientConfiguration = Aws::EventBridge::EventBridgeClientConfiguration());
 
  EventBridgeClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<EventBridgeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::EventBridge::EventBridgeClientConfiguration& clientConfiguration = Aws::EventBridge::EventBridgeClientConfiguration());
 
  /* Legacy constructors due deprecation */
  EventBridgeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EventBridgeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EventBridgeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EventBridgeClient();
 
  virtual Model::ActivateEventSourceOutcome ActivateEventSource(const Model::ActivateEventSourceRequest& request) const;
 
  template <typename ActivateEventSourceRequestT = Model::ActivateEventSourceRequest>
  Model::ActivateEventSourceOutcomeCallable ActivateEventSourceCallable(const ActivateEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::ActivateEventSource, request);
  }
 
  template <typename ActivateEventSourceRequestT = Model::ActivateEventSourceRequest>
  void ActivateEventSourceAsync(const ActivateEventSourceRequestT& request, const ActivateEventSourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::ActivateEventSource, request, handler, context);
  }
 
  virtual Model::CancelReplayOutcome CancelReplay(const Model::CancelReplayRequest& request) const;
 
  template <typename CancelReplayRequestT = Model::CancelReplayRequest>
  Model::CancelReplayOutcomeCallable CancelReplayCallable(const CancelReplayRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::CancelReplay, request);
  }
 
  template <typename CancelReplayRequestT = Model::CancelReplayRequest>
  void CancelReplayAsync(const CancelReplayRequestT& request, const CancelReplayResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::CancelReplay, request, handler, context);
  }
 
  virtual Model::CreateApiDestinationOutcome CreateApiDestination(const Model::CreateApiDestinationRequest& request) const;
 
  template <typename CreateApiDestinationRequestT = Model::CreateApiDestinationRequest>
  Model::CreateApiDestinationOutcomeCallable CreateApiDestinationCallable(const CreateApiDestinationRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::CreateApiDestination, request);
  }
 
  template <typename CreateApiDestinationRequestT = Model::CreateApiDestinationRequest>
  void CreateApiDestinationAsync(const CreateApiDestinationRequestT& request, const CreateApiDestinationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::CreateApiDestination, request, handler, context);
  }
 
  virtual Model::CreateArchiveOutcome CreateArchive(const Model::CreateArchiveRequest& request) const;
 
  template <typename CreateArchiveRequestT = Model::CreateArchiveRequest>
  Model::CreateArchiveOutcomeCallable CreateArchiveCallable(const CreateArchiveRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::CreateArchive, request);
  }
 
  template <typename CreateArchiveRequestT = Model::CreateArchiveRequest>
  void CreateArchiveAsync(const CreateArchiveRequestT& request, const CreateArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::CreateArchive, 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(&EventBridgeClient::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(&EventBridgeClient::CreateConnection, request, handler, context);
  }
 
  virtual Model::CreateEndpointOutcome CreateEndpoint(const Model::CreateEndpointRequest& request) const;
 
  template <typename CreateEndpointRequestT = Model::CreateEndpointRequest>
  Model::CreateEndpointOutcomeCallable CreateEndpointCallable(const CreateEndpointRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::CreateEndpoint, request);
  }
 
  template <typename CreateEndpointRequestT = Model::CreateEndpointRequest>
  void CreateEndpointAsync(const CreateEndpointRequestT& request, const CreateEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::CreateEndpoint, request, handler, context);
  }
 
  virtual Model::CreateEventBusOutcome CreateEventBus(const Model::CreateEventBusRequest& request) const;
 
  template <typename CreateEventBusRequestT = Model::CreateEventBusRequest>
  Model::CreateEventBusOutcomeCallable CreateEventBusCallable(const CreateEventBusRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::CreateEventBus, request);
  }
 
  template <typename CreateEventBusRequestT = Model::CreateEventBusRequest>
  void CreateEventBusAsync(const CreateEventBusRequestT& request, const CreateEventBusResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::CreateEventBus, request, handler, context);
  }
 
  virtual Model::CreatePartnerEventSourceOutcome CreatePartnerEventSource(const Model::CreatePartnerEventSourceRequest& request) const;
 
  template <typename CreatePartnerEventSourceRequestT = Model::CreatePartnerEventSourceRequest>
  Model::CreatePartnerEventSourceOutcomeCallable CreatePartnerEventSourceCallable(const CreatePartnerEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::CreatePartnerEventSource, request);
  }
 
  template <typename CreatePartnerEventSourceRequestT = Model::CreatePartnerEventSourceRequest>
  void CreatePartnerEventSourceAsync(const CreatePartnerEventSourceRequestT& request,
                                     const CreatePartnerEventSourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::CreatePartnerEventSource, request, handler, context);
  }
 
  virtual Model::DeactivateEventSourceOutcome DeactivateEventSource(const Model::DeactivateEventSourceRequest& request) const;
 
  template <typename DeactivateEventSourceRequestT = Model::DeactivateEventSourceRequest>
  Model::DeactivateEventSourceOutcomeCallable DeactivateEventSourceCallable(const DeactivateEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeactivateEventSource, request);
  }
 
  template <typename DeactivateEventSourceRequestT = Model::DeactivateEventSourceRequest>
  void DeactivateEventSourceAsync(const DeactivateEventSourceRequestT& request, const DeactivateEventSourceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeactivateEventSource, request, handler, context);
  }
 
  virtual Model::DeauthorizeConnectionOutcome DeauthorizeConnection(const Model::DeauthorizeConnectionRequest& request) const;
 
  template <typename DeauthorizeConnectionRequestT = Model::DeauthorizeConnectionRequest>
  Model::DeauthorizeConnectionOutcomeCallable DeauthorizeConnectionCallable(const DeauthorizeConnectionRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeauthorizeConnection, request);
  }
 
  template <typename DeauthorizeConnectionRequestT = Model::DeauthorizeConnectionRequest>
  void DeauthorizeConnectionAsync(const DeauthorizeConnectionRequestT& request, const DeauthorizeConnectionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeauthorizeConnection, request, handler, context);
  }
 
  virtual Model::DeleteApiDestinationOutcome DeleteApiDestination(const Model::DeleteApiDestinationRequest& request) const;
 
  template <typename DeleteApiDestinationRequestT = Model::DeleteApiDestinationRequest>
  Model::DeleteApiDestinationOutcomeCallable DeleteApiDestinationCallable(const DeleteApiDestinationRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeleteApiDestination, request);
  }
 
  template <typename DeleteApiDestinationRequestT = Model::DeleteApiDestinationRequest>
  void DeleteApiDestinationAsync(const DeleteApiDestinationRequestT& request, const DeleteApiDestinationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeleteApiDestination, request, handler, context);
  }
 
  virtual Model::DeleteArchiveOutcome DeleteArchive(const Model::DeleteArchiveRequest& request) const;
 
  template <typename DeleteArchiveRequestT = Model::DeleteArchiveRequest>
  Model::DeleteArchiveOutcomeCallable DeleteArchiveCallable(const DeleteArchiveRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeleteArchive, request);
  }
 
  template <typename DeleteArchiveRequestT = Model::DeleteArchiveRequest>
  void DeleteArchiveAsync(const DeleteArchiveRequestT& request, const DeleteArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeleteArchive, 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(&EventBridgeClient::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(&EventBridgeClient::DeleteConnection, request, handler, context);
  }
 
  virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const;
 
  template <typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
  Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeleteEndpoint, request);
  }
 
  template <typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
  void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeleteEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteEventBusOutcome DeleteEventBus(const Model::DeleteEventBusRequest& request) const;
 
  template <typename DeleteEventBusRequestT = Model::DeleteEventBusRequest>
  Model::DeleteEventBusOutcomeCallable DeleteEventBusCallable(const DeleteEventBusRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeleteEventBus, request);
  }
 
  template <typename DeleteEventBusRequestT = Model::DeleteEventBusRequest>
  void DeleteEventBusAsync(const DeleteEventBusRequestT& request, const DeleteEventBusResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeleteEventBus, request, handler, context);
  }
 
  virtual Model::DeletePartnerEventSourceOutcome DeletePartnerEventSource(const Model::DeletePartnerEventSourceRequest& request) const;
 
  template <typename DeletePartnerEventSourceRequestT = Model::DeletePartnerEventSourceRequest>
  Model::DeletePartnerEventSourceOutcomeCallable DeletePartnerEventSourceCallable(const DeletePartnerEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeletePartnerEventSource, request);
  }
 
  template <typename DeletePartnerEventSourceRequestT = Model::DeletePartnerEventSourceRequest>
  void DeletePartnerEventSourceAsync(const DeletePartnerEventSourceRequestT& request,
                                     const DeletePartnerEventSourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeletePartnerEventSource, request, handler, context);
  }
 
  virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const;
 
  template <typename DeleteRuleRequestT = Model::DeleteRuleRequest>
  Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DeleteRule, request);
  }
 
  template <typename DeleteRuleRequestT = Model::DeleteRuleRequest>
  void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DeleteRule, request, handler, context);
  }
 
  virtual Model::DescribeApiDestinationOutcome DescribeApiDestination(const Model::DescribeApiDestinationRequest& request) const;
 
  template <typename DescribeApiDestinationRequestT = Model::DescribeApiDestinationRequest>
  Model::DescribeApiDestinationOutcomeCallable DescribeApiDestinationCallable(const DescribeApiDestinationRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeApiDestination, request);
  }
 
  template <typename DescribeApiDestinationRequestT = Model::DescribeApiDestinationRequest>
  void DescribeApiDestinationAsync(const DescribeApiDestinationRequestT& request,
                                   const DescribeApiDestinationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeApiDestination, request, handler, context);
  }
 
  virtual Model::DescribeArchiveOutcome DescribeArchive(const Model::DescribeArchiveRequest& request) const;
 
  template <typename DescribeArchiveRequestT = Model::DescribeArchiveRequest>
  Model::DescribeArchiveOutcomeCallable DescribeArchiveCallable(const DescribeArchiveRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeArchive, request);
  }
 
  template <typename DescribeArchiveRequestT = Model::DescribeArchiveRequest>
  void DescribeArchiveAsync(const DescribeArchiveRequestT& request, const DescribeArchiveResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeArchive, request, handler, context);
  }
 
  virtual Model::DescribeConnectionOutcome DescribeConnection(const Model::DescribeConnectionRequest& request) const;
 
  template <typename DescribeConnectionRequestT = Model::DescribeConnectionRequest>
  Model::DescribeConnectionOutcomeCallable DescribeConnectionCallable(const DescribeConnectionRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeConnection, request);
  }
 
  template <typename DescribeConnectionRequestT = Model::DescribeConnectionRequest>
  void DescribeConnectionAsync(const DescribeConnectionRequestT& request, const DescribeConnectionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeConnection, request, handler, context);
  }
 
  virtual Model::DescribeEndpointOutcome DescribeEndpoint(const Model::DescribeEndpointRequest& request) const;
 
  template <typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
  Model::DescribeEndpointOutcomeCallable DescribeEndpointCallable(const DescribeEndpointRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeEndpoint, request);
  }
 
  template <typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
  void DescribeEndpointAsync(const DescribeEndpointRequestT& request, const DescribeEndpointResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeEndpoint, request, handler, context);
  }
 
  virtual Model::DescribeEventBusOutcome DescribeEventBus(const Model::DescribeEventBusRequest& request = {}) const;
 
  template <typename DescribeEventBusRequestT = Model::DescribeEventBusRequest>
  Model::DescribeEventBusOutcomeCallable DescribeEventBusCallable(const DescribeEventBusRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::DescribeEventBus, request);
  }
 
  template <typename DescribeEventBusRequestT = Model::DescribeEventBusRequest>
  void DescribeEventBusAsync(const DescribeEventBusResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeEventBusRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::DescribeEventBus, request, handler, context);
  }
 
  virtual Model::DescribeEventSourceOutcome DescribeEventSource(const Model::DescribeEventSourceRequest& request) const;
 
  template <typename DescribeEventSourceRequestT = Model::DescribeEventSourceRequest>
  Model::DescribeEventSourceOutcomeCallable DescribeEventSourceCallable(const DescribeEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeEventSource, request);
  }
 
  template <typename DescribeEventSourceRequestT = Model::DescribeEventSourceRequest>
  void DescribeEventSourceAsync(const DescribeEventSourceRequestT& request, const DescribeEventSourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeEventSource, request, handler, context);
  }
 
  virtual Model::DescribePartnerEventSourceOutcome DescribePartnerEventSource(
      const Model::DescribePartnerEventSourceRequest& request) const;
 
  template <typename DescribePartnerEventSourceRequestT = Model::DescribePartnerEventSourceRequest>
  Model::DescribePartnerEventSourceOutcomeCallable DescribePartnerEventSourceCallable(
      const DescribePartnerEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribePartnerEventSource, request);
  }
 
  template <typename DescribePartnerEventSourceRequestT = Model::DescribePartnerEventSourceRequest>
  void DescribePartnerEventSourceAsync(const DescribePartnerEventSourceRequestT& request,
                                       const DescribePartnerEventSourceResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribePartnerEventSource, request, handler, context);
  }
 
  virtual Model::DescribeReplayOutcome DescribeReplay(const Model::DescribeReplayRequest& request) const;
 
  template <typename DescribeReplayRequestT = Model::DescribeReplayRequest>
  Model::DescribeReplayOutcomeCallable DescribeReplayCallable(const DescribeReplayRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeReplay, request);
  }
 
  template <typename DescribeReplayRequestT = Model::DescribeReplayRequest>
  void DescribeReplayAsync(const DescribeReplayRequestT& request, const DescribeReplayResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeReplay, request, handler, context);
  }
 
  virtual Model::DescribeRuleOutcome DescribeRule(const Model::DescribeRuleRequest& request) const;
 
  template <typename DescribeRuleRequestT = Model::DescribeRuleRequest>
  Model::DescribeRuleOutcomeCallable DescribeRuleCallable(const DescribeRuleRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DescribeRule, request);
  }
 
  template <typename DescribeRuleRequestT = Model::DescribeRuleRequest>
  void DescribeRuleAsync(const DescribeRuleRequestT& request, const DescribeRuleResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DescribeRule, request, handler, context);
  }
 
  virtual Model::DisableRuleOutcome DisableRule(const Model::DisableRuleRequest& request) const;
 
  template <typename DisableRuleRequestT = Model::DisableRuleRequest>
  Model::DisableRuleOutcomeCallable DisableRuleCallable(const DisableRuleRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::DisableRule, request);
  }
 
  template <typename DisableRuleRequestT = Model::DisableRuleRequest>
  void DisableRuleAsync(const DisableRuleRequestT& request, const DisableRuleResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::DisableRule, request, handler, context);
  }
 
  virtual Model::EnableRuleOutcome EnableRule(const Model::EnableRuleRequest& request) const;
 
  template <typename EnableRuleRequestT = Model::EnableRuleRequest>
  Model::EnableRuleOutcomeCallable EnableRuleCallable(const EnableRuleRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::EnableRule, request);
  }
 
  template <typename EnableRuleRequestT = Model::EnableRuleRequest>
  void EnableRuleAsync(const EnableRuleRequestT& request, const EnableRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::EnableRule, request, handler, context);
  }
 
  virtual Model::ListApiDestinationsOutcome ListApiDestinations(const Model::ListApiDestinationsRequest& request = {}) const;
 
  template <typename ListApiDestinationsRequestT = Model::ListApiDestinationsRequest>
  Model::ListApiDestinationsOutcomeCallable ListApiDestinationsCallable(const ListApiDestinationsRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListApiDestinations, request);
  }
 
  template <typename ListApiDestinationsRequestT = Model::ListApiDestinationsRequest>
  void ListApiDestinationsAsync(const ListApiDestinationsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListApiDestinationsRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListApiDestinations, request, handler, context);
  }
 
  virtual Model::ListArchivesOutcome ListArchives(const Model::ListArchivesRequest& request = {}) const;
 
  template <typename ListArchivesRequestT = Model::ListArchivesRequest>
  Model::ListArchivesOutcomeCallable ListArchivesCallable(const ListArchivesRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListArchives, request);
  }
 
  template <typename ListArchivesRequestT = Model::ListArchivesRequest>
  void ListArchivesAsync(const ListArchivesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListArchivesRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListArchives, 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(&EventBridgeClient::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(&EventBridgeClient::ListConnections, request, handler, context);
  }
 
  virtual Model::ListEndpointsOutcome ListEndpoints(const Model::ListEndpointsRequest& request = {}) const;
 
  template <typename ListEndpointsRequestT = Model::ListEndpointsRequest>
  Model::ListEndpointsOutcomeCallable ListEndpointsCallable(const ListEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListEndpoints, request);
  }
 
  template <typename ListEndpointsRequestT = Model::ListEndpointsRequest>
  void ListEndpointsAsync(const ListEndpointsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListEndpointsRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListEndpoints, request, handler, context);
  }
 
  virtual Model::ListEventBusesOutcome ListEventBuses(const Model::ListEventBusesRequest& request = {}) const;
 
  template <typename ListEventBusesRequestT = Model::ListEventBusesRequest>
  Model::ListEventBusesOutcomeCallable ListEventBusesCallable(const ListEventBusesRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListEventBuses, request);
  }
 
  template <typename ListEventBusesRequestT = Model::ListEventBusesRequest>
  void ListEventBusesAsync(const ListEventBusesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListEventBusesRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListEventBuses, request, handler, context);
  }
 
  virtual Model::ListEventSourcesOutcome ListEventSources(const Model::ListEventSourcesRequest& request = {}) const;
 
  template <typename ListEventSourcesRequestT = Model::ListEventSourcesRequest>
  Model::ListEventSourcesOutcomeCallable ListEventSourcesCallable(const ListEventSourcesRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListEventSources, request);
  }
 
  template <typename ListEventSourcesRequestT = Model::ListEventSourcesRequest>
  void ListEventSourcesAsync(const ListEventSourcesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListEventSourcesRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListEventSources, request, handler, context);
  }
 
  virtual Model::ListPartnerEventSourceAccountsOutcome ListPartnerEventSourceAccounts(
      const Model::ListPartnerEventSourceAccountsRequest& request) const;
 
  template <typename ListPartnerEventSourceAccountsRequestT = Model::ListPartnerEventSourceAccountsRequest>
  Model::ListPartnerEventSourceAccountsOutcomeCallable ListPartnerEventSourceAccountsCallable(
      const ListPartnerEventSourceAccountsRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::ListPartnerEventSourceAccounts, request);
  }
 
  template <typename ListPartnerEventSourceAccountsRequestT = Model::ListPartnerEventSourceAccountsRequest>
  void ListPartnerEventSourceAccountsAsync(const ListPartnerEventSourceAccountsRequestT& request,
                                           const ListPartnerEventSourceAccountsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::ListPartnerEventSourceAccounts, request, handler, context);
  }
 
  virtual Model::ListPartnerEventSourcesOutcome ListPartnerEventSources(const Model::ListPartnerEventSourcesRequest& request) const;
 
  template <typename ListPartnerEventSourcesRequestT = Model::ListPartnerEventSourcesRequest>
  Model::ListPartnerEventSourcesOutcomeCallable ListPartnerEventSourcesCallable(const ListPartnerEventSourcesRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::ListPartnerEventSources, request);
  }
 
  template <typename ListPartnerEventSourcesRequestT = Model::ListPartnerEventSourcesRequest>
  void ListPartnerEventSourcesAsync(const ListPartnerEventSourcesRequestT& request,
                                    const ListPartnerEventSourcesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::ListPartnerEventSources, request, handler, context);
  }
 
  virtual Model::ListReplaysOutcome ListReplays(const Model::ListReplaysRequest& request = {}) const;
 
  template <typename ListReplaysRequestT = Model::ListReplaysRequest>
  Model::ListReplaysOutcomeCallable ListReplaysCallable(const ListReplaysRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListReplays, request);
  }
 
  template <typename ListReplaysRequestT = Model::ListReplaysRequest>
  void ListReplaysAsync(const ListReplaysResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListReplaysRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListReplays, request, handler, context);
  }
 
  virtual Model::ListRuleNamesByTargetOutcome ListRuleNamesByTarget(const Model::ListRuleNamesByTargetRequest& request) const;
 
  template <typename ListRuleNamesByTargetRequestT = Model::ListRuleNamesByTargetRequest>
  Model::ListRuleNamesByTargetOutcomeCallable ListRuleNamesByTargetCallable(const ListRuleNamesByTargetRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::ListRuleNamesByTarget, request);
  }
 
  template <typename ListRuleNamesByTargetRequestT = Model::ListRuleNamesByTargetRequest>
  void ListRuleNamesByTargetAsync(const ListRuleNamesByTargetRequestT& request, const ListRuleNamesByTargetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::ListRuleNamesByTarget, request, handler, context);
  }
 
  virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request = {}) const;
 
  template <typename ListRulesRequestT = Model::ListRulesRequest>
  Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::ListRules, request);
  }
 
  template <typename ListRulesRequestT = Model::ListRulesRequest>
  void ListRulesAsync(const ListRulesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListRulesRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::ListRules, 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(&EventBridgeClient::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(&EventBridgeClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTargetsByRuleOutcome ListTargetsByRule(const Model::ListTargetsByRuleRequest& request) const;
 
  template <typename ListTargetsByRuleRequestT = Model::ListTargetsByRuleRequest>
  Model::ListTargetsByRuleOutcomeCallable ListTargetsByRuleCallable(const ListTargetsByRuleRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::ListTargetsByRule, request);
  }
 
  template <typename ListTargetsByRuleRequestT = Model::ListTargetsByRuleRequest>
  void ListTargetsByRuleAsync(const ListTargetsByRuleRequestT& request, const ListTargetsByRuleResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::ListTargetsByRule, request, handler, context);
  }
 
  virtual Model::PutEventsOutcome PutEvents(const Model::PutEventsRequest& request) const;
 
  template <typename PutEventsRequestT = Model::PutEventsRequest>
  Model::PutEventsOutcomeCallable PutEventsCallable(const PutEventsRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::PutEvents, request);
  }
 
  template <typename PutEventsRequestT = Model::PutEventsRequest>
  void PutEventsAsync(const PutEventsRequestT& request, const PutEventsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::PutEvents, request, handler, context);
  }
 
  virtual Model::PutPartnerEventsOutcome PutPartnerEvents(const Model::PutPartnerEventsRequest& request) const;
 
  template <typename PutPartnerEventsRequestT = Model::PutPartnerEventsRequest>
  Model::PutPartnerEventsOutcomeCallable PutPartnerEventsCallable(const PutPartnerEventsRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::PutPartnerEvents, request);
  }
 
  template <typename PutPartnerEventsRequestT = Model::PutPartnerEventsRequest>
  void PutPartnerEventsAsync(const PutPartnerEventsRequestT& request, const PutPartnerEventsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::PutPartnerEvents, request, handler, context);
  }
 
  virtual Model::PutPermissionOutcome PutPermission(const Model::PutPermissionRequest& request = {}) const;
 
  template <typename PutPermissionRequestT = Model::PutPermissionRequest>
  Model::PutPermissionOutcomeCallable PutPermissionCallable(const PutPermissionRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::PutPermission, request);
  }
 
  template <typename PutPermissionRequestT = Model::PutPermissionRequest>
  void PutPermissionAsync(const PutPermissionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const PutPermissionRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::PutPermission, request, handler, context);
  }
 
  virtual Model::PutRuleOutcome PutRule(const Model::PutRuleRequest& request) const;
 
  template <typename PutRuleRequestT = Model::PutRuleRequest>
  Model::PutRuleOutcomeCallable PutRuleCallable(const PutRuleRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::PutRule, request);
  }
 
  template <typename PutRuleRequestT = Model::PutRuleRequest>
  void PutRuleAsync(const PutRuleRequestT& request, const PutRuleResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::PutRule, request, handler, context);
  }
 
  virtual Model::PutTargetsOutcome PutTargets(const Model::PutTargetsRequest& request) const;
 
  template <typename PutTargetsRequestT = Model::PutTargetsRequest>
  Model::PutTargetsOutcomeCallable PutTargetsCallable(const PutTargetsRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::PutTargets, request);
  }
 
  template <typename PutTargetsRequestT = Model::PutTargetsRequest>
  void PutTargetsAsync(const PutTargetsRequestT& request, const PutTargetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::PutTargets, request, handler, context);
  }
 
  virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request = {}) const;
 
  template <typename RemovePermissionRequestT = Model::RemovePermissionRequest>
  Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::RemovePermission, request);
  }
 
  template <typename RemovePermissionRequestT = Model::RemovePermissionRequest>
  void RemovePermissionAsync(const RemovePermissionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const RemovePermissionRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::RemovePermission, request, handler, context);
  }
 
  virtual Model::RemoveTargetsOutcome RemoveTargets(const Model::RemoveTargetsRequest& request) const;
 
  template <typename RemoveTargetsRequestT = Model::RemoveTargetsRequest>
  Model::RemoveTargetsOutcomeCallable RemoveTargetsCallable(const RemoveTargetsRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::RemoveTargets, request);
  }
 
  template <typename RemoveTargetsRequestT = Model::RemoveTargetsRequest>
  void RemoveTargetsAsync(const RemoveTargetsRequestT& request, const RemoveTargetsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::RemoveTargets, request, handler, context);
  }
 
  virtual Model::StartReplayOutcome StartReplay(const Model::StartReplayRequest& request) const;
 
  template <typename StartReplayRequestT = Model::StartReplayRequest>
  Model::StartReplayOutcomeCallable StartReplayCallable(const StartReplayRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::StartReplay, request);
  }
 
  template <typename StartReplayRequestT = Model::StartReplayRequest>
  void StartReplayAsync(const StartReplayRequestT& request, const StartReplayResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::StartReplay, 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(&EventBridgeClient::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(&EventBridgeClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestEventPatternOutcome TestEventPattern(const Model::TestEventPatternRequest& request) const;
 
  template <typename TestEventPatternRequestT = Model::TestEventPatternRequest>
  Model::TestEventPatternOutcomeCallable TestEventPatternCallable(const TestEventPatternRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::TestEventPattern, request);
  }
 
  template <typename TestEventPatternRequestT = Model::TestEventPatternRequest>
  void TestEventPatternAsync(const TestEventPatternRequestT& request, const TestEventPatternResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::TestEventPattern, 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(&EventBridgeClient::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(&EventBridgeClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApiDestinationOutcome UpdateApiDestination(const Model::UpdateApiDestinationRequest& request) const;
 
  template <typename UpdateApiDestinationRequestT = Model::UpdateApiDestinationRequest>
  Model::UpdateApiDestinationOutcomeCallable UpdateApiDestinationCallable(const UpdateApiDestinationRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::UpdateApiDestination, request);
  }
 
  template <typename UpdateApiDestinationRequestT = Model::UpdateApiDestinationRequest>
  void UpdateApiDestinationAsync(const UpdateApiDestinationRequestT& request, const UpdateApiDestinationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::UpdateApiDestination, request, handler, context);
  }
 
  virtual Model::UpdateArchiveOutcome UpdateArchive(const Model::UpdateArchiveRequest& request) const;
 
  template <typename UpdateArchiveRequestT = Model::UpdateArchiveRequest>
  Model::UpdateArchiveOutcomeCallable UpdateArchiveCallable(const UpdateArchiveRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::UpdateArchive, request);
  }
 
  template <typename UpdateArchiveRequestT = Model::UpdateArchiveRequest>
  void UpdateArchiveAsync(const UpdateArchiveRequestT& request, const UpdateArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::UpdateArchive, 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(&EventBridgeClient::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(&EventBridgeClient::UpdateConnection, request, handler, context);
  }
 
  virtual Model::UpdateEndpointOutcome UpdateEndpoint(const Model::UpdateEndpointRequest& request) const;
 
  template <typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
  Model::UpdateEndpointOutcomeCallable UpdateEndpointCallable(const UpdateEndpointRequestT& request) const {
    return SubmitCallable(&EventBridgeClient::UpdateEndpoint, request);
  }
 
  template <typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
  void UpdateEndpointAsync(const UpdateEndpointRequestT& request, const UpdateEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeClient::UpdateEndpoint, request, handler, context);
  }
 
  virtual Model::UpdateEventBusOutcome UpdateEventBus(const Model::UpdateEventBusRequest& request = {}) const;
 
  template <typename UpdateEventBusRequestT = Model::UpdateEventBusRequest>
  Model::UpdateEventBusOutcomeCallable UpdateEventBusCallable(const UpdateEventBusRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeClient::UpdateEventBus, request);
  }
 
  template <typename UpdateEventBusRequestT = Model::UpdateEventBusRequest>
  void UpdateEventBusAsync(const UpdateEventBusResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const UpdateEventBusRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeClient::UpdateEventBus, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EventBridgeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EventBridgeClient>;
  void init(const EventBridgeClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EventBridgeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  EventBridgeClientConfiguration m_clientConfiguration;
  std::shared_ptr<EventBridgeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EventBridge
}  // namespace Aws