EventBridgeClient.h

 
#pragma once
#include <aws/eventbridge/EventBridge_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/eventbridge/EventBridgeServiceClientModel.h>
 
namespace Aws
{
namespace EventBridge
{
  class AWS_EVENTBRIDGE_API EventBridgeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<EventBridgeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<EventBridgeClient>;
      void init(const EventBridgeClientConfiguration& clientConfiguration);
 
      EventBridgeClientConfiguration m_clientConfiguration;
      std::shared_ptr<EventBridgeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EventBridge
} // namespace Aws