CloudWatchOmniClient.h

 
#pragma once
#include <aws/cloudwatchomni/CloudWatchOmniPaginationBase.h>
#include <aws/cloudwatchomni/CloudWatchOmniServiceClientModel.h>
#include <aws/cloudwatchomni/CloudWatchOmniWaiter.h>
#include <aws/cloudwatchomni/CloudWatchOmni_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/crt/cbor/Cbor.h>
 
namespace Aws {
namespace CloudWatchOmni {
class AWS_CLOUDWATCHOMNI_API CloudWatchOmniClient : public Aws::Client::AWSRpcV2CborClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchOmniClient>,
                                                    public CloudWatchOmniPaginationBase<CloudWatchOmniClient>,
                                                    public CloudWatchOmniWaiter<CloudWatchOmniClient> {
 public:
  typedef Aws::Client::AWSRpcV2CborClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudWatchOmniClientConfiguration ClientConfigurationType;
  typedef CloudWatchOmniEndpointProvider EndpointProviderType;
 
  CloudWatchOmniClient(const Aws::CloudWatchOmni::CloudWatchOmniClientConfiguration& clientConfiguration =
                           Aws::CloudWatchOmni::CloudWatchOmniClientConfiguration(),
                       std::shared_ptr<CloudWatchOmniEndpointProviderBase> endpointProvider = nullptr);
 
  CloudWatchOmniClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<CloudWatchOmniEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::CloudWatchOmni::CloudWatchOmniClientConfiguration& clientConfiguration =
                           Aws::CloudWatchOmni::CloudWatchOmniClientConfiguration());
 
  CloudWatchOmniClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<CloudWatchOmniEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::CloudWatchOmni::CloudWatchOmniClientConfiguration& clientConfiguration =
                           Aws::CloudWatchOmni::CloudWatchOmniClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudWatchOmniClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudWatchOmniClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudWatchOmniClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudWatchOmniClient();
 
  virtual Model::CreateAccessGrantOutcome CreateAccessGrant(const Model::CreateAccessGrantRequest& request) const;
 
  template <typename CreateAccessGrantRequestT = Model::CreateAccessGrantRequest>
  Model::CreateAccessGrantOutcomeCallable CreateAccessGrantCallable(const CreateAccessGrantRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateAccessGrant, request);
  }
 
  template <typename CreateAccessGrantRequestT = Model::CreateAccessGrantRequest>
  void CreateAccessGrantAsync(const CreateAccessGrantRequestT& request, const CreateAccessGrantResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateAccessGrant, request, handler, context);
  }
 
  virtual Model::CreateAccessProfileOutcome CreateAccessProfile(const Model::CreateAccessProfileRequest& request) const;
 
  template <typename CreateAccessProfileRequestT = Model::CreateAccessProfileRequest>
  Model::CreateAccessProfileOutcomeCallable CreateAccessProfileCallable(const CreateAccessProfileRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateAccessProfile, request);
  }
 
  template <typename CreateAccessProfileRequestT = Model::CreateAccessProfileRequest>
  void CreateAccessProfileAsync(const CreateAccessProfileRequestT& request, const CreateAccessProfileResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateAccessProfile, request, handler, context);
  }
 
  virtual Model::CreateAlertOutcome CreateAlert(const Model::CreateAlertRequest& request) const;
 
  template <typename CreateAlertRequestT = Model::CreateAlertRequest>
  Model::CreateAlertOutcomeCallable CreateAlertCallable(const CreateAlertRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateAlert, request);
  }
 
  template <typename CreateAlertRequestT = Model::CreateAlertRequest>
  void CreateAlertAsync(const CreateAlertRequestT& request, const CreateAlertResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateAlert, request, handler, context);
  }
 
  virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateDomain, request);
  }
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::CreateDomainAccessGrantForOrganizationOutcome CreateDomainAccessGrantForOrganization(
      const Model::CreateDomainAccessGrantForOrganizationRequest& request) const;
 
  template <typename CreateDomainAccessGrantForOrganizationRequestT = Model::CreateDomainAccessGrantForOrganizationRequest>
  Model::CreateDomainAccessGrantForOrganizationOutcomeCallable CreateDomainAccessGrantForOrganizationCallable(
      const CreateDomainAccessGrantForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateDomainAccessGrantForOrganization, request);
  }
 
  template <typename CreateDomainAccessGrantForOrganizationRequestT = Model::CreateDomainAccessGrantForOrganizationRequest>
  void CreateDomainAccessGrantForOrganizationAsync(const CreateDomainAccessGrantForOrganizationRequestT& request,
                                                   const CreateDomainAccessGrantForOrganizationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateDomainAccessGrantForOrganization, request, handler, context);
  }
 
  virtual Model::CreateDomainForOrganizationOutcome CreateDomainForOrganization(
      const Model::CreateDomainForOrganizationRequest& request) const;
 
  template <typename CreateDomainForOrganizationRequestT = Model::CreateDomainForOrganizationRequest>
  Model::CreateDomainForOrganizationOutcomeCallable CreateDomainForOrganizationCallable(
      const CreateDomainForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateDomainForOrganization, request);
  }
 
  template <typename CreateDomainForOrganizationRequestT = Model::CreateDomainForOrganizationRequest>
  void CreateDomainForOrganizationAsync(const CreateDomainForOrganizationRequestT& request,
                                        const CreateDomainForOrganizationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateDomainForOrganization, request, handler, context);
  }
 
  virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateIntegration, request);
  }
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateIntegration, request, handler, context);
  }
 
  virtual Model::CreateOmniDashboardOutcome CreateOmniDashboard(const Model::CreateOmniDashboardRequest& request) const;
 
  template <typename CreateOmniDashboardRequestT = Model::CreateOmniDashboardRequest>
  Model::CreateOmniDashboardOutcomeCallable CreateOmniDashboardCallable(const CreateOmniDashboardRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateOmniDashboard, request);
  }
 
  template <typename CreateOmniDashboardRequestT = Model::CreateOmniDashboardRequest>
  void CreateOmniDashboardAsync(const CreateOmniDashboardRequestT& request, const CreateOmniDashboardResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateOmniDashboard, request, handler, context);
  }
 
  virtual Model::CreateOneTimeDeepLinkCodeOutcome CreateOneTimeDeepLinkCode(const Model::CreateOneTimeDeepLinkCodeRequest& request) const;
 
  template <typename CreateOneTimeDeepLinkCodeRequestT = Model::CreateOneTimeDeepLinkCodeRequest>
  Model::CreateOneTimeDeepLinkCodeOutcomeCallable CreateOneTimeDeepLinkCodeCallable(
      const CreateOneTimeDeepLinkCodeRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateOneTimeDeepLinkCode, request);
  }
 
  template <typename CreateOneTimeDeepLinkCodeRequestT = Model::CreateOneTimeDeepLinkCodeRequest>
  void CreateOneTimeDeepLinkCodeAsync(const CreateOneTimeDeepLinkCodeRequestT& request,
                                      const CreateOneTimeDeepLinkCodeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateOneTimeDeepLinkCode, request, handler, context);
  }
 
  virtual Model::CreateSpaceOutcome CreateSpace(const Model::CreateSpaceRequest& request) const;
 
  template <typename CreateSpaceRequestT = Model::CreateSpaceRequest>
  Model::CreateSpaceOutcomeCallable CreateSpaceCallable(const CreateSpaceRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateSpace, request);
  }
 
  template <typename CreateSpaceRequestT = Model::CreateSpaceRequest>
  void CreateSpaceAsync(const CreateSpaceRequestT& request, const CreateSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateSpace, request, handler, context);
  }
 
  virtual Model::CreateViewOutcome CreateView(const Model::CreateViewRequest& request) const;
 
  template <typename CreateViewRequestT = Model::CreateViewRequest>
  Model::CreateViewOutcomeCallable CreateViewCallable(const CreateViewRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::CreateView, request);
  }
 
  template <typename CreateViewRequestT = Model::CreateViewRequest>
  void CreateViewAsync(const CreateViewRequestT& request, const CreateViewResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::CreateView, request, handler, context);
  }
 
  virtual Model::DeleteAccessGrantOutcome DeleteAccessGrant(const Model::DeleteAccessGrantRequest& request) const;
 
  template <typename DeleteAccessGrantRequestT = Model::DeleteAccessGrantRequest>
  Model::DeleteAccessGrantOutcomeCallable DeleteAccessGrantCallable(const DeleteAccessGrantRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteAccessGrant, request);
  }
 
  template <typename DeleteAccessGrantRequestT = Model::DeleteAccessGrantRequest>
  void DeleteAccessGrantAsync(const DeleteAccessGrantRequestT& request, const DeleteAccessGrantResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteAccessGrant, request, handler, context);
  }
 
  virtual Model::DeleteAccessProfileOutcome DeleteAccessProfile(const Model::DeleteAccessProfileRequest& request) const;
 
  template <typename DeleteAccessProfileRequestT = Model::DeleteAccessProfileRequest>
  Model::DeleteAccessProfileOutcomeCallable DeleteAccessProfileCallable(const DeleteAccessProfileRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteAccessProfile, request);
  }
 
  template <typename DeleteAccessProfileRequestT = Model::DeleteAccessProfileRequest>
  void DeleteAccessProfileAsync(const DeleteAccessProfileRequestT& request, const DeleteAccessProfileResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteAccessProfile, request, handler, context);
  }
 
  virtual Model::DeleteAlertOutcome DeleteAlert(const Model::DeleteAlertRequest& request) const;
 
  template <typename DeleteAlertRequestT = Model::DeleteAlertRequest>
  Model::DeleteAlertOutcomeCallable DeleteAlertCallable(const DeleteAlertRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteAlert, request);
  }
 
  template <typename DeleteAlertRequestT = Model::DeleteAlertRequest>
  void DeleteAlertAsync(const DeleteAlertRequestT& request, const DeleteAlertResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteAlert, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteDomainAccessGrantForOrganizationOutcome DeleteDomainAccessGrantForOrganization(
      const Model::DeleteDomainAccessGrantForOrganizationRequest& request) const;
 
  template <typename DeleteDomainAccessGrantForOrganizationRequestT = Model::DeleteDomainAccessGrantForOrganizationRequest>
  Model::DeleteDomainAccessGrantForOrganizationOutcomeCallable DeleteDomainAccessGrantForOrganizationCallable(
      const DeleteDomainAccessGrantForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteDomainAccessGrantForOrganization, request);
  }
 
  template <typename DeleteDomainAccessGrantForOrganizationRequestT = Model::DeleteDomainAccessGrantForOrganizationRequest>
  void DeleteDomainAccessGrantForOrganizationAsync(const DeleteDomainAccessGrantForOrganizationRequestT& request,
                                                   const DeleteDomainAccessGrantForOrganizationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteDomainAccessGrantForOrganization, request, handler, context);
  }
 
  virtual Model::DeleteDomainForOrganizationOutcome DeleteDomainForOrganization(
      const Model::DeleteDomainForOrganizationRequest& request) const;
 
  template <typename DeleteDomainForOrganizationRequestT = Model::DeleteDomainForOrganizationRequest>
  Model::DeleteDomainForOrganizationOutcomeCallable DeleteDomainForOrganizationCallable(
      const DeleteDomainForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteDomainForOrganization, request);
  }
 
  template <typename DeleteDomainForOrganizationRequestT = Model::DeleteDomainForOrganizationRequest>
  void DeleteDomainForOrganizationAsync(const DeleteDomainForOrganizationRequestT& request,
                                        const DeleteDomainForOrganizationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteDomainForOrganization, request, handler, context);
  }
 
  virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteIntegration, request);
  }
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteIntegration, request, handler, context);
  }
 
  virtual Model::DeleteOmniDashboardOutcome DeleteOmniDashboard(const Model::DeleteOmniDashboardRequest& request) const;
 
  template <typename DeleteOmniDashboardRequestT = Model::DeleteOmniDashboardRequest>
  Model::DeleteOmniDashboardOutcomeCallable DeleteOmniDashboardCallable(const DeleteOmniDashboardRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteOmniDashboard, request);
  }
 
  template <typename DeleteOmniDashboardRequestT = Model::DeleteOmniDashboardRequest>
  void DeleteOmniDashboardAsync(const DeleteOmniDashboardRequestT& request, const DeleteOmniDashboardResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteOmniDashboard, request, handler, context);
  }
 
  virtual Model::DeleteSpaceOutcome DeleteSpace(const Model::DeleteSpaceRequest& request) const;
 
  template <typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
  Model::DeleteSpaceOutcomeCallable DeleteSpaceCallable(const DeleteSpaceRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteSpace, request);
  }
 
  template <typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
  void DeleteSpaceAsync(const DeleteSpaceRequestT& request, const DeleteSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteSpace, request, handler, context);
  }
 
  virtual Model::DeleteViewOutcome DeleteView(const Model::DeleteViewRequest& request) const;
 
  template <typename DeleteViewRequestT = Model::DeleteViewRequest>
  Model::DeleteViewOutcomeCallable DeleteViewCallable(const DeleteViewRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::DeleteView, request);
  }
 
  template <typename DeleteViewRequestT = Model::DeleteViewRequest>
  void DeleteViewAsync(const DeleteViewRequestT& request, const DeleteViewResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::DeleteView, request, handler, context);
  }
 
  virtual Model::GetAccessGrantOutcome GetAccessGrant(const Model::GetAccessGrantRequest& request) const;
 
  template <typename GetAccessGrantRequestT = Model::GetAccessGrantRequest>
  Model::GetAccessGrantOutcomeCallable GetAccessGrantCallable(const GetAccessGrantRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetAccessGrant, request);
  }
 
  template <typename GetAccessGrantRequestT = Model::GetAccessGrantRequest>
  void GetAccessGrantAsync(const GetAccessGrantRequestT& request, const GetAccessGrantResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetAccessGrant, request, handler, context);
  }
 
  virtual Model::GetAccessProfileOutcome GetAccessProfile(const Model::GetAccessProfileRequest& request) const;
 
  template <typename GetAccessProfileRequestT = Model::GetAccessProfileRequest>
  Model::GetAccessProfileOutcomeCallable GetAccessProfileCallable(const GetAccessProfileRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetAccessProfile, request);
  }
 
  template <typename GetAccessProfileRequestT = Model::GetAccessProfileRequest>
  void GetAccessProfileAsync(const GetAccessProfileRequestT& request, const GetAccessProfileResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetAccessProfile, request, handler, context);
  }
 
  virtual Model::GetAlertOutcome GetAlert(const Model::GetAlertRequest& request) const;
 
  template <typename GetAlertRequestT = Model::GetAlertRequest>
  Model::GetAlertOutcomeCallable GetAlertCallable(const GetAlertRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetAlert, request);
  }
 
  template <typename GetAlertRequestT = Model::GetAlertRequest>
  void GetAlertAsync(const GetAlertRequestT& request, const GetAlertResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetAlert, request, handler, context);
  }
 
  virtual Model::GetContextGraphOutcome GetContextGraph(const Model::GetContextGraphRequest& request) const;
 
  template <typename GetContextGraphRequestT = Model::GetContextGraphRequest>
  Model::GetContextGraphOutcomeCallable GetContextGraphCallable(const GetContextGraphRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetContextGraph, request);
  }
 
  template <typename GetContextGraphRequestT = Model::GetContextGraphRequest>
  void GetContextGraphAsync(const GetContextGraphRequestT& request, const GetContextGraphResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetContextGraph, request, handler, context);
  }
 
  virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const;
 
  template <typename GetDomainRequestT = Model::GetDomainRequest>
  Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetDomain, request);
  }
 
  template <typename GetDomainRequestT = Model::GetDomainRequest>
  void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetDomain, request, handler, context);
  }
 
  virtual Model::GetDomainAccessGrantForOrganizationOutcome GetDomainAccessGrantForOrganization(
      const Model::GetDomainAccessGrantForOrganizationRequest& request) const;
 
  template <typename GetDomainAccessGrantForOrganizationRequestT = Model::GetDomainAccessGrantForOrganizationRequest>
  Model::GetDomainAccessGrantForOrganizationOutcomeCallable GetDomainAccessGrantForOrganizationCallable(
      const GetDomainAccessGrantForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetDomainAccessGrantForOrganization, request);
  }
 
  template <typename GetDomainAccessGrantForOrganizationRequestT = Model::GetDomainAccessGrantForOrganizationRequest>
  void GetDomainAccessGrantForOrganizationAsync(const GetDomainAccessGrantForOrganizationRequestT& request,
                                                const GetDomainAccessGrantForOrganizationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetDomainAccessGrantForOrganization, request, handler, context);
  }
 
  virtual Model::GetDomainForOrganizationOutcome GetDomainForOrganization(const Model::GetDomainForOrganizationRequest& request) const;
 
  template <typename GetDomainForOrganizationRequestT = Model::GetDomainForOrganizationRequest>
  Model::GetDomainForOrganizationOutcomeCallable GetDomainForOrganizationCallable(const GetDomainForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetDomainForOrganization, request);
  }
 
  template <typename GetDomainForOrganizationRequestT = Model::GetDomainForOrganizationRequest>
  void GetDomainForOrganizationAsync(const GetDomainForOrganizationRequestT& request,
                                     const GetDomainForOrganizationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetDomainForOrganization, request, handler, context);
  }
 
  virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const;
 
  template <typename GetIntegrationRequestT = Model::GetIntegrationRequest>
  Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetIntegration, request);
  }
 
  template <typename GetIntegrationRequestT = Model::GetIntegrationRequest>
  void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetIntegration, request, handler, context);
  }
 
  virtual Model::GetIntelligenceConfigurationOutcome GetIntelligenceConfiguration(
      const Model::GetIntelligenceConfigurationRequest& request = {}) const;
 
  template <typename GetIntelligenceConfigurationRequestT = Model::GetIntelligenceConfigurationRequest>
  Model::GetIntelligenceConfigurationOutcomeCallable GetIntelligenceConfigurationCallable(
      const GetIntelligenceConfigurationRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::GetIntelligenceConfiguration, request);
  }
 
  template <typename GetIntelligenceConfigurationRequestT = Model::GetIntelligenceConfigurationRequest>
  void GetIntelligenceConfigurationAsync(const GetIntelligenceConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetIntelligenceConfigurationRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::GetIntelligenceConfiguration, request, handler, context);
  }
 
  virtual Model::GetOmniDashboardOutcome GetOmniDashboard(const Model::GetOmniDashboardRequest& request) const;
 
  template <typename GetOmniDashboardRequestT = Model::GetOmniDashboardRequest>
  Model::GetOmniDashboardOutcomeCallable GetOmniDashboardCallable(const GetOmniDashboardRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetOmniDashboard, request);
  }
 
  template <typename GetOmniDashboardRequestT = Model::GetOmniDashboardRequest>
  void GetOmniDashboardAsync(const GetOmniDashboardRequestT& request, const GetOmniDashboardResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetOmniDashboard, request, handler, context);
  }
 
  virtual Model::GetSpaceOutcome GetSpace(const Model::GetSpaceRequest& request) const;
 
  template <typename GetSpaceRequestT = Model::GetSpaceRequest>
  Model::GetSpaceOutcomeCallable GetSpaceCallable(const GetSpaceRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetSpace, request);
  }
 
  template <typename GetSpaceRequestT = Model::GetSpaceRequest>
  void GetSpaceAsync(const GetSpaceRequestT& request, const GetSpaceResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetSpace, request, handler, context);
  }
 
  virtual Model::GetSpaceCredentialsForOrganizationOutcome GetSpaceCredentialsForOrganization(
      const Model::GetSpaceCredentialsForOrganizationRequest& request) const;
 
  template <typename GetSpaceCredentialsForOrganizationRequestT = Model::GetSpaceCredentialsForOrganizationRequest>
  Model::GetSpaceCredentialsForOrganizationOutcomeCallable GetSpaceCredentialsForOrganizationCallable(
      const GetSpaceCredentialsForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetSpaceCredentialsForOrganization, request);
  }
 
  template <typename GetSpaceCredentialsForOrganizationRequestT = Model::GetSpaceCredentialsForOrganizationRequest>
  void GetSpaceCredentialsForOrganizationAsync(const GetSpaceCredentialsForOrganizationRequestT& request,
                                               const GetSpaceCredentialsForOrganizationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetSpaceCredentialsForOrganization, request, handler, context);
  }
 
  virtual Model::GetTelemetryQueryResultsOutcome GetTelemetryQueryResults(const Model::GetTelemetryQueryResultsRequest& request) const;
 
  template <typename GetTelemetryQueryResultsRequestT = Model::GetTelemetryQueryResultsRequest>
  Model::GetTelemetryQueryResultsOutcomeCallable GetTelemetryQueryResultsCallable(const GetTelemetryQueryResultsRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetTelemetryQueryResults, request);
  }
 
  template <typename GetTelemetryQueryResultsRequestT = Model::GetTelemetryQueryResultsRequest>
  void GetTelemetryQueryResultsAsync(const GetTelemetryQueryResultsRequestT& request,
                                     const GetTelemetryQueryResultsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetTelemetryQueryResults, request, handler, context);
  }
 
  virtual Model::GetViewOutcome GetView(const Model::GetViewRequest& request) const;
 
  template <typename GetViewRequestT = Model::GetViewRequest>
  Model::GetViewOutcomeCallable GetViewCallable(const GetViewRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::GetView, request);
  }
 
  template <typename GetViewRequestT = Model::GetViewRequest>
  void GetViewAsync(const GetViewRequestT& request, const GetViewResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::GetView, request, handler, context);
  }
 
  virtual Model::ListAccessGrantsOutcome ListAccessGrants(const Model::ListAccessGrantsRequest& request = {}) const;
 
  template <typename ListAccessGrantsRequestT = Model::ListAccessGrantsRequest>
  Model::ListAccessGrantsOutcomeCallable ListAccessGrantsCallable(const ListAccessGrantsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListAccessGrants, request);
  }
 
  template <typename ListAccessGrantsRequestT = Model::ListAccessGrantsRequest>
  void ListAccessGrantsAsync(const ListAccessGrantsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListAccessGrantsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListAccessGrants, request, handler, context);
  }
 
  virtual Model::ListAccessProfilesOutcome ListAccessProfiles(const Model::ListAccessProfilesRequest& request) const;
 
  template <typename ListAccessProfilesRequestT = Model::ListAccessProfilesRequest>
  Model::ListAccessProfilesOutcomeCallable ListAccessProfilesCallable(const ListAccessProfilesRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::ListAccessProfiles, request);
  }
 
  template <typename ListAccessProfilesRequestT = Model::ListAccessProfilesRequest>
  void ListAccessProfilesAsync(const ListAccessProfilesRequestT& request, const ListAccessProfilesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::ListAccessProfiles, request, handler, context);
  }
 
  virtual Model::ListAlertsOutcome ListAlerts(const Model::ListAlertsRequest& request) const;
 
  template <typename ListAlertsRequestT = Model::ListAlertsRequest>
  Model::ListAlertsOutcomeCallable ListAlertsCallable(const ListAlertsRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::ListAlerts, request);
  }
 
  template <typename ListAlertsRequestT = Model::ListAlertsRequest>
  void ListAlertsAsync(const ListAlertsRequestT& request, const ListAlertsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::ListAlerts, request, handler, context);
  }
 
  virtual Model::ListDomainAccessGrantsForOrganizationOutcome ListDomainAccessGrantsForOrganization(
      const Model::ListDomainAccessGrantsForOrganizationRequest& request = {}) const;
 
  template <typename ListDomainAccessGrantsForOrganizationRequestT = Model::ListDomainAccessGrantsForOrganizationRequest>
  Model::ListDomainAccessGrantsForOrganizationOutcomeCallable ListDomainAccessGrantsForOrganizationCallable(
      const ListDomainAccessGrantsForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListDomainAccessGrantsForOrganization, request);
  }
 
  template <typename ListDomainAccessGrantsForOrganizationRequestT = Model::ListDomainAccessGrantsForOrganizationRequest>
  void ListDomainAccessGrantsForOrganizationAsync(const ListDomainAccessGrantsForOrganizationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const ListDomainAccessGrantsForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListDomainAccessGrantsForOrganization, request, handler, context);
  }
 
  virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListDomains, request);
  }
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDomainsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListDomains, request, handler, context);
  }
 
  virtual Model::ListIntegrationsOutcome ListIntegrations(const Model::ListIntegrationsRequest& request = {}) const;
 
  template <typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
  Model::ListIntegrationsOutcomeCallable ListIntegrationsCallable(const ListIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListIntegrations, request);
  }
 
  template <typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
  void ListIntegrationsAsync(const ListIntegrationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListIntegrations, request, handler, context);
  }
 
  virtual Model::ListOmniDashboardsOutcome ListOmniDashboards(const Model::ListOmniDashboardsRequest& request) const;
 
  template <typename ListOmniDashboardsRequestT = Model::ListOmniDashboardsRequest>
  Model::ListOmniDashboardsOutcomeCallable ListOmniDashboardsCallable(const ListOmniDashboardsRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::ListOmniDashboards, request);
  }
 
  template <typename ListOmniDashboardsRequestT = Model::ListOmniDashboardsRequest>
  void ListOmniDashboardsAsync(const ListOmniDashboardsRequestT& request, const ListOmniDashboardsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::ListOmniDashboards, request, handler, context);
  }
 
  virtual Model::ListSpacesOutcome ListSpaces(const Model::ListSpacesRequest& request = {}) const;
 
  template <typename ListSpacesRequestT = Model::ListSpacesRequest>
  Model::ListSpacesOutcomeCallable ListSpacesCallable(const ListSpacesRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListSpaces, request);
  }
 
  template <typename ListSpacesRequestT = Model::ListSpacesRequest>
  void ListSpacesAsync(const ListSpacesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListSpacesRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListSpaces, request, handler, context);
  }
 
  virtual Model::ListSpacesForOrganizationOutcome ListSpacesForOrganization(
      const Model::ListSpacesForOrganizationRequest& request = {}) const;
 
  template <typename ListSpacesForOrganizationRequestT = Model::ListSpacesForOrganizationRequest>
  Model::ListSpacesForOrganizationOutcomeCallable ListSpacesForOrganizationCallable(
      const ListSpacesForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListSpacesForOrganization, request);
  }
 
  template <typename ListSpacesForOrganizationRequestT = Model::ListSpacesForOrganizationRequest>
  void ListSpacesForOrganizationAsync(const ListSpacesForOrganizationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListSpacesForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListSpacesForOrganization, request, handler, context);
  }
 
  virtual Model::ListTelemetryFieldsOutcome ListTelemetryFields(const Model::ListTelemetryFieldsRequest& request) const;
 
  template <typename ListTelemetryFieldsRequestT = Model::ListTelemetryFieldsRequest>
  Model::ListTelemetryFieldsOutcomeCallable ListTelemetryFieldsCallable(const ListTelemetryFieldsRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::ListTelemetryFields, request);
  }
 
  template <typename ListTelemetryFieldsRequestT = Model::ListTelemetryFieldsRequest>
  void ListTelemetryFieldsAsync(const ListTelemetryFieldsRequestT& request, const ListTelemetryFieldsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::ListTelemetryFields, request, handler, context);
  }
 
  virtual Model::ListTelemetryQuerySessionsOutcome ListTelemetryQuerySessions(
      const Model::ListTelemetryQuerySessionsRequest& request = {}) const;
 
  template <typename ListTelemetryQuerySessionsRequestT = Model::ListTelemetryQuerySessionsRequest>
  Model::ListTelemetryQuerySessionsOutcomeCallable ListTelemetryQuerySessionsCallable(
      const ListTelemetryQuerySessionsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListTelemetryQuerySessions, request);
  }
 
  template <typename ListTelemetryQuerySessionsRequestT = Model::ListTelemetryQuerySessionsRequest>
  void ListTelemetryQuerySessionsAsync(const ListTelemetryQuerySessionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListTelemetryQuerySessionsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListTelemetryQuerySessions, request, handler, context);
  }
 
  virtual Model::ListViewsOutcome ListViews(const Model::ListViewsRequest& request = {}) const;
 
  template <typename ListViewsRequestT = Model::ListViewsRequest>
  Model::ListViewsOutcomeCallable ListViewsCallable(const ListViewsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::ListViews, request);
  }
 
  template <typename ListViewsRequestT = Model::ListViewsRequest>
  void ListViewsAsync(const ListViewsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListViewsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::ListViews, request, handler, context);
  }
 
  virtual Model::PutIntelligenceConfigurationOutcome PutIntelligenceConfiguration(
      const Model::PutIntelligenceConfigurationRequest& request = {}) const;
 
  template <typename PutIntelligenceConfigurationRequestT = Model::PutIntelligenceConfigurationRequest>
  Model::PutIntelligenceConfigurationOutcomeCallable PutIntelligenceConfigurationCallable(
      const PutIntelligenceConfigurationRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::PutIntelligenceConfiguration, request);
  }
 
  template <typename PutIntelligenceConfigurationRequestT = Model::PutIntelligenceConfigurationRequest>
  void PutIntelligenceConfigurationAsync(const PutIntelligenceConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const PutIntelligenceConfigurationRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::PutIntelligenceConfiguration, request, handler, context);
  }
 
  virtual Model::SearchPrincipalsOutcome SearchPrincipals(const Model::SearchPrincipalsRequest& request) const;
 
  template <typename SearchPrincipalsRequestT = Model::SearchPrincipalsRequest>
  Model::SearchPrincipalsOutcomeCallable SearchPrincipalsCallable(const SearchPrincipalsRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::SearchPrincipals, request);
  }
 
  template <typename SearchPrincipalsRequestT = Model::SearchPrincipalsRequest>
  void SearchPrincipalsAsync(const SearchPrincipalsRequestT& request, const SearchPrincipalsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::SearchPrincipals, request, handler, context);
  }
 
  virtual Model::StartTelemetryQueryOutcome StartTelemetryQuery(const Model::StartTelemetryQueryRequest& request) const;
 
  template <typename StartTelemetryQueryRequestT = Model::StartTelemetryQueryRequest>
  Model::StartTelemetryQueryOutcomeCallable StartTelemetryQueryCallable(const StartTelemetryQueryRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::StartTelemetryQuery, request);
  }
 
  template <typename StartTelemetryQueryRequestT = Model::StartTelemetryQueryRequest>
  void StartTelemetryQueryAsync(const StartTelemetryQueryRequestT& request, const StartTelemetryQueryResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::StartTelemetryQuery, request, handler, context);
  }
 
  virtual Model::StartTelemetryQuerySessionOutcome StartTelemetryQuerySession(
      const Model::StartTelemetryQuerySessionRequest& request = {}) const;
 
  template <typename StartTelemetryQuerySessionRequestT = Model::StartTelemetryQuerySessionRequest>
  Model::StartTelemetryQuerySessionOutcomeCallable StartTelemetryQuerySessionCallable(
      const StartTelemetryQuerySessionRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchOmniClient::StartTelemetryQuerySession, request);
  }
 
  template <typename StartTelemetryQuerySessionRequestT = Model::StartTelemetryQuerySessionRequest>
  void StartTelemetryQuerySessionAsync(const StartTelemetryQuerySessionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const StartTelemetryQuerySessionRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchOmniClient::StartTelemetryQuerySession, request, handler, context);
  }
 
  virtual Model::StopTelemetryQueryOutcome StopTelemetryQuery(const Model::StopTelemetryQueryRequest& request) const;
 
  template <typename StopTelemetryQueryRequestT = Model::StopTelemetryQueryRequest>
  Model::StopTelemetryQueryOutcomeCallable StopTelemetryQueryCallable(const StopTelemetryQueryRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::StopTelemetryQuery, request);
  }
 
  template <typename StopTelemetryQueryRequestT = Model::StopTelemetryQueryRequest>
  void StopTelemetryQueryAsync(const StopTelemetryQueryRequestT& request, const StopTelemetryQueryResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::StopTelemetryQuery, request, handler, context);
  }
 
  virtual Model::StopTelemetryQuerySessionOutcome StopTelemetryQuerySession(const Model::StopTelemetryQuerySessionRequest& request) const;
 
  template <typename StopTelemetryQuerySessionRequestT = Model::StopTelemetryQuerySessionRequest>
  Model::StopTelemetryQuerySessionOutcomeCallable StopTelemetryQuerySessionCallable(
      const StopTelemetryQuerySessionRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::StopTelemetryQuerySession, request);
  }
 
  template <typename StopTelemetryQuerySessionRequestT = Model::StopTelemetryQuerySessionRequest>
  void StopTelemetryQuerySessionAsync(const StopTelemetryQuerySessionRequestT& request,
                                      const StopTelemetryQuerySessionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::StopTelemetryQuerySession, request, handler, context);
  }
 
  virtual Model::UpdateAccessProfileOutcome UpdateAccessProfile(const Model::UpdateAccessProfileRequest& request) const;
 
  template <typename UpdateAccessProfileRequestT = Model::UpdateAccessProfileRequest>
  Model::UpdateAccessProfileOutcomeCallable UpdateAccessProfileCallable(const UpdateAccessProfileRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateAccessProfile, request);
  }
 
  template <typename UpdateAccessProfileRequestT = Model::UpdateAccessProfileRequest>
  void UpdateAccessProfileAsync(const UpdateAccessProfileRequestT& request, const UpdateAccessProfileResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateAccessProfile, request, handler, context);
  }
 
  virtual Model::UpdateAlertOutcome UpdateAlert(const Model::UpdateAlertRequest& request) const;
 
  template <typename UpdateAlertRequestT = Model::UpdateAlertRequest>
  Model::UpdateAlertOutcomeCallable UpdateAlertCallable(const UpdateAlertRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateAlert, request);
  }
 
  template <typename UpdateAlertRequestT = Model::UpdateAlertRequest>
  void UpdateAlertAsync(const UpdateAlertRequestT& request, const UpdateAlertResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateAlert, request, handler, context);
  }
 
  virtual Model::UpdateDomainOutcome UpdateDomain(const Model::UpdateDomainRequest& request) const;
 
  template <typename UpdateDomainRequestT = Model::UpdateDomainRequest>
  Model::UpdateDomainOutcomeCallable UpdateDomainCallable(const UpdateDomainRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateDomain, request);
  }
 
  template <typename UpdateDomainRequestT = Model::UpdateDomainRequest>
  void UpdateDomainAsync(const UpdateDomainRequestT& request, const UpdateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateDomain, request, handler, context);
  }
 
  virtual Model::UpdateDomainForOrganizationOutcome UpdateDomainForOrganization(
      const Model::UpdateDomainForOrganizationRequest& request) const;
 
  template <typename UpdateDomainForOrganizationRequestT = Model::UpdateDomainForOrganizationRequest>
  Model::UpdateDomainForOrganizationOutcomeCallable UpdateDomainForOrganizationCallable(
      const UpdateDomainForOrganizationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateDomainForOrganization, request);
  }
 
  template <typename UpdateDomainForOrganizationRequestT = Model::UpdateDomainForOrganizationRequest>
  void UpdateDomainForOrganizationAsync(const UpdateDomainForOrganizationRequestT& request,
                                        const UpdateDomainForOrganizationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateDomainForOrganization, request, handler, context);
  }
 
  virtual Model::UpdateIntegrationOutcome UpdateIntegration(const Model::UpdateIntegrationRequest& request) const;
 
  template <typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
  Model::UpdateIntegrationOutcomeCallable UpdateIntegrationCallable(const UpdateIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateIntegration, request);
  }
 
  template <typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
  void UpdateIntegrationAsync(const UpdateIntegrationRequestT& request, const UpdateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateIntegration, request, handler, context);
  }
 
  virtual Model::UpdateOmniDashboardOutcome UpdateOmniDashboard(const Model::UpdateOmniDashboardRequest& request) const;
 
  template <typename UpdateOmniDashboardRequestT = Model::UpdateOmniDashboardRequest>
  Model::UpdateOmniDashboardOutcomeCallable UpdateOmniDashboardCallable(const UpdateOmniDashboardRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateOmniDashboard, request);
  }
 
  template <typename UpdateOmniDashboardRequestT = Model::UpdateOmniDashboardRequest>
  void UpdateOmniDashboardAsync(const UpdateOmniDashboardRequestT& request, const UpdateOmniDashboardResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateOmniDashboard, request, handler, context);
  }
 
  virtual Model::UpdateSpaceOutcome UpdateSpace(const Model::UpdateSpaceRequest& request) const;
 
  template <typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
  Model::UpdateSpaceOutcomeCallable UpdateSpaceCallable(const UpdateSpaceRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateSpace, request);
  }
 
  template <typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
  void UpdateSpaceAsync(const UpdateSpaceRequestT& request, const UpdateSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateSpace, request, handler, context);
  }
 
  virtual Model::UpdateViewOutcome UpdateView(const Model::UpdateViewRequest& request) const;
 
  template <typename UpdateViewRequestT = Model::UpdateViewRequest>
  Model::UpdateViewOutcomeCallable UpdateViewCallable(const UpdateViewRequestT& request) const {
    return SubmitCallable(&CloudWatchOmniClient::UpdateView, request);
  }
 
  template <typename UpdateViewRequestT = Model::UpdateViewRequest>
  void UpdateViewAsync(const UpdateViewRequestT& request, const UpdateViewResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchOmniClient::UpdateView, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CloudWatchOmniEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchOmniClient>;
  void init(const CloudWatchOmniClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CloudWatchOmniError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CloudWatchOmniClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudWatchOmniEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudWatchOmni
}  // namespace Aws