EventBridgeV2Client.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/crt/cbor/Cbor.h>
#include <aws/eventbridgev2/EventBridgeV2PaginationBase.h>
#include <aws/eventbridgev2/EventBridgeV2ServiceClientModel.h>
#include <aws/eventbridgev2/EventBridgeV2Waiter.h>
#include <aws/eventbridgev2/EventBridgeV2_EXPORTS.h>
 
namespace Aws {
namespace EventBridgeV2 {
class AWS_EVENTBRIDGEV2_API EventBridgeV2Client : public Aws::Client::AWSRpcV2CborClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<EventBridgeV2Client>,
                                                  public EventBridgeV2PaginationBase<EventBridgeV2Client>,
                                                  public EventBridgeV2Waiter<EventBridgeV2Client> {
 public:
  typedef Aws::Client::AWSRpcV2CborClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef EventBridgeV2ClientConfiguration ClientConfigurationType;
  typedef EventBridgeV2EndpointProvider EndpointProviderType;
 
  EventBridgeV2Client(const Aws::EventBridgeV2::EventBridgeV2ClientConfiguration& clientConfiguration =
                          Aws::EventBridgeV2::EventBridgeV2ClientConfiguration(),
                      std::shared_ptr<EventBridgeV2EndpointProviderBase> endpointProvider = nullptr);
 
  EventBridgeV2Client(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<EventBridgeV2EndpointProviderBase> endpointProvider = nullptr,
                      const Aws::EventBridgeV2::EventBridgeV2ClientConfiguration& clientConfiguration =
                          Aws::EventBridgeV2::EventBridgeV2ClientConfiguration());
 
  EventBridgeV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<EventBridgeV2EndpointProviderBase> endpointProvider = nullptr,
                      const Aws::EventBridgeV2::EventBridgeV2ClientConfiguration& clientConfiguration =
                          Aws::EventBridgeV2::EventBridgeV2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  EventBridgeV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EventBridgeV2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EventBridgeV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EventBridgeV2Client();
 
  virtual Model::CreateEventBusOutcome CreateEventBus(const Model::CreateEventBusRequest& request) const;
 
  template <typename CreateEventBusRequestT = Model::CreateEventBusRequest>
  Model::CreateEventBusOutcomeCallable CreateEventBusCallable(const CreateEventBusRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::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(&EventBridgeV2Client::CreateEventBus, request, handler, context);
  }
 
  virtual Model::CreateEventSourceOutcome CreateEventSource(const Model::CreateEventSourceRequest& request) const;
 
  template <typename CreateEventSourceRequestT = Model::CreateEventSourceRequest>
  Model::CreateEventSourceOutcomeCallable CreateEventSourceCallable(const CreateEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::CreateEventSource, request);
  }
 
  template <typename CreateEventSourceRequestT = Model::CreateEventSourceRequest>
  void CreateEventSourceAsync(const CreateEventSourceRequestT& request, const CreateEventSourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::CreateEventSource, request, handler, context);
  }
 
  virtual Model::CreateSubscriberOutcome CreateSubscriber(const Model::CreateSubscriberRequest& request) const;
 
  template <typename CreateSubscriberRequestT = Model::CreateSubscriberRequest>
  Model::CreateSubscriberOutcomeCallable CreateSubscriberCallable(const CreateSubscriberRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::CreateSubscriber, request);
  }
 
  template <typename CreateSubscriberRequestT = Model::CreateSubscriberRequest>
  void CreateSubscriberAsync(const CreateSubscriberRequestT& request, const CreateSubscriberResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::CreateSubscriber, 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(&EventBridgeV2Client::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(&EventBridgeV2Client::DeleteEventBus, request, handler, context);
  }
 
  virtual Model::DeleteEventSourceOutcome DeleteEventSource(const Model::DeleteEventSourceRequest& request) const;
 
  template <typename DeleteEventSourceRequestT = Model::DeleteEventSourceRequest>
  Model::DeleteEventSourceOutcomeCallable DeleteEventSourceCallable(const DeleteEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::DeleteEventSource, request);
  }
 
  template <typename DeleteEventSourceRequestT = Model::DeleteEventSourceRequest>
  void DeleteEventSourceAsync(const DeleteEventSourceRequestT& request, const DeleteEventSourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::DeleteEventSource, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteSubscriberOutcome DeleteSubscriber(const Model::DeleteSubscriberRequest& request) const;
 
  template <typename DeleteSubscriberRequestT = Model::DeleteSubscriberRequest>
  Model::DeleteSubscriberOutcomeCallable DeleteSubscriberCallable(const DeleteSubscriberRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::DeleteSubscriber, request);
  }
 
  template <typename DeleteSubscriberRequestT = Model::DeleteSubscriberRequest>
  void DeleteSubscriberAsync(const DeleteSubscriberRequestT& request, const DeleteSubscriberResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::DeleteSubscriber, 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(&EventBridgeV2Client::DescribeEventBus, request);
  }
 
  template <typename DescribeEventBusRequestT = Model::DescribeEventBusRequest>
  void DescribeEventBusAsync(const DescribeEventBusRequestT& request, const DescribeEventBusResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::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(&EventBridgeV2Client::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(&EventBridgeV2Client::DescribeEventSource, request, handler, context);
  }
 
  virtual Model::DescribeSubscriberOutcome DescribeSubscriber(const Model::DescribeSubscriberRequest& request) const;
 
  template <typename DescribeSubscriberRequestT = Model::DescribeSubscriberRequest>
  Model::DescribeSubscriberOutcomeCallable DescribeSubscriberCallable(const DescribeSubscriberRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::DescribeSubscriber, request);
  }
 
  template <typename DescribeSubscriberRequestT = Model::DescribeSubscriberRequest>
  void DescribeSubscriberAsync(const DescribeSubscriberRequestT& request, const DescribeSubscriberResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::DescribeSubscriber, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::GetResourcePolicy, 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(&EventBridgeV2Client::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(&EventBridgeV2Client::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(&EventBridgeV2Client::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(&EventBridgeV2Client::ListEventSources, request, handler, context);
  }
 
  virtual Model::ListResourcePoliciesOutcome ListResourcePolicies(const Model::ListResourcePoliciesRequest& request) const;
 
  template <typename ListResourcePoliciesRequestT = Model::ListResourcePoliciesRequest>
  Model::ListResourcePoliciesOutcomeCallable ListResourcePoliciesCallable(const ListResourcePoliciesRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::ListResourcePolicies, request);
  }
 
  template <typename ListResourcePoliciesRequestT = Model::ListResourcePoliciesRequest>
  void ListResourcePoliciesAsync(const ListResourcePoliciesRequestT& request, const ListResourcePoliciesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::ListResourcePolicies, request, handler, context);
  }
 
  virtual Model::ListSubscribersOutcome ListSubscribers(const Model::ListSubscribersRequest& request = {}) const;
 
  template <typename ListSubscribersRequestT = Model::ListSubscribersRequest>
  Model::ListSubscribersOutcomeCallable ListSubscribersCallable(const ListSubscribersRequestT& request = {}) const {
    return SubmitCallable(&EventBridgeV2Client::ListSubscribers, request);
  }
 
  template <typename ListSubscribersRequestT = Model::ListSubscribersRequest>
  void ListSubscribersAsync(const ListSubscribersResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListSubscribersRequestT& request = {}) const {
    return SubmitAsync(&EventBridgeV2Client::ListSubscribers, 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(&EventBridgeV2Client::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(&EventBridgeV2Client::ListTagsForResource, 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(&EventBridgeV2Client::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(&EventBridgeV2Client::PutEvents, request, handler, context);
  }
 
  virtual Model::PutRawEventsOutcome PutRawEvents(const Model::PutRawEventsRequest& request) const;
 
  template <typename PutRawEventsRequestT = Model::PutRawEventsRequest>
  Model::PutRawEventsOutcomeCallable PutRawEventsCallable(const PutRawEventsRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::PutRawEvents, request);
  }
 
  template <typename PutRawEventsRequestT = Model::PutRawEventsRequest>
  void PutRawEventsAsync(const PutRawEventsRequestT& request, const PutRawEventsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::PutRawEvents, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::RevokeResourceOutcome RevokeResource(const Model::RevokeResourceRequest& request) const;
 
  template <typename RevokeResourceRequestT = Model::RevokeResourceRequest>
  Model::RevokeResourceOutcomeCallable RevokeResourceCallable(const RevokeResourceRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::RevokeResource, request);
  }
 
  template <typename RevokeResourceRequestT = Model::RevokeResourceRequest>
  void RevokeResourceAsync(const RevokeResourceRequestT& request, const RevokeResourceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::RevokeResource, 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(&EventBridgeV2Client::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(&EventBridgeV2Client::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::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(&EventBridgeV2Client::UntagResource, 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(&EventBridgeV2Client::UpdateEventBus, request);
  }
 
  template <typename UpdateEventBusRequestT = Model::UpdateEventBusRequest>
  void UpdateEventBusAsync(const UpdateEventBusRequestT& request, const UpdateEventBusResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::UpdateEventBus, request, handler, context);
  }
 
  virtual Model::UpdateEventSourceOutcome UpdateEventSource(const Model::UpdateEventSourceRequest& request) const;
 
  template <typename UpdateEventSourceRequestT = Model::UpdateEventSourceRequest>
  Model::UpdateEventSourceOutcomeCallable UpdateEventSourceCallable(const UpdateEventSourceRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::UpdateEventSource, request);
  }
 
  template <typename UpdateEventSourceRequestT = Model::UpdateEventSourceRequest>
  void UpdateEventSourceAsync(const UpdateEventSourceRequestT& request, const UpdateEventSourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::UpdateEventSource, request, handler, context);
  }
 
  virtual Model::UpdateSubscriberOutcome UpdateSubscriber(const Model::UpdateSubscriberRequest& request) const;
 
  template <typename UpdateSubscriberRequestT = Model::UpdateSubscriberRequest>
  Model::UpdateSubscriberOutcomeCallable UpdateSubscriberCallable(const UpdateSubscriberRequestT& request) const {
    return SubmitCallable(&EventBridgeV2Client::UpdateSubscriber, request);
  }
 
  template <typename UpdateSubscriberRequestT = Model::UpdateSubscriberRequest>
  void UpdateSubscriberAsync(const UpdateSubscriberRequestT& request, const UpdateSubscriberResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EventBridgeV2Client::UpdateSubscriber, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EventBridgeV2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EventBridgeV2Client>;
  void init(const EventBridgeV2ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EventBridgeV2Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  EventBridgeV2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<EventBridgeV2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EventBridgeV2
}  // namespace Aws