ManagedGrafanaClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/grafana/ManagedGrafanaPaginationBase.h>
#include <aws/grafana/ManagedGrafanaServiceClientModel.h>
#include <aws/grafana/ManagedGrafana_EXPORTS.h>
 
namespace Aws {
namespace ManagedGrafana {
class AWS_MANAGEDGRAFANA_API ManagedGrafanaClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<ManagedGrafanaClient>,
                                                    public ManagedGrafanaPaginationBase<ManagedGrafanaClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ManagedGrafanaClientConfiguration ClientConfigurationType;
  typedef ManagedGrafanaEndpointProvider EndpointProviderType;
 
  ManagedGrafanaClient(const Aws::ManagedGrafana::ManagedGrafanaClientConfiguration& clientConfiguration =
                           Aws::ManagedGrafana::ManagedGrafanaClientConfiguration(),
                       std::shared_ptr<ManagedGrafanaEndpointProviderBase> endpointProvider = nullptr);
 
  ManagedGrafanaClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<ManagedGrafanaEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::ManagedGrafana::ManagedGrafanaClientConfiguration& clientConfiguration =
                           Aws::ManagedGrafana::ManagedGrafanaClientConfiguration());
 
  ManagedGrafanaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<ManagedGrafanaEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::ManagedGrafana::ManagedGrafanaClientConfiguration& clientConfiguration =
                           Aws::ManagedGrafana::ManagedGrafanaClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ManagedGrafanaClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ManagedGrafanaClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ManagedGrafanaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ManagedGrafanaClient();
 
  virtual Model::AssociateLicenseOutcome AssociateLicense(const Model::AssociateLicenseRequest& request) const;
 
  template <typename AssociateLicenseRequestT = Model::AssociateLicenseRequest>
  Model::AssociateLicenseOutcomeCallable AssociateLicenseCallable(const AssociateLicenseRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::AssociateLicense, request);
  }
 
  template <typename AssociateLicenseRequestT = Model::AssociateLicenseRequest>
  void AssociateLicenseAsync(const AssociateLicenseRequestT& request, const AssociateLicenseResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::AssociateLicense, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceOutcome CreateWorkspace(const Model::CreateWorkspaceRequest& request) const;
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  Model::CreateWorkspaceOutcomeCallable CreateWorkspaceCallable(const CreateWorkspaceRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::CreateWorkspace, request);
  }
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  void CreateWorkspaceAsync(const CreateWorkspaceRequestT& request, const CreateWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::CreateWorkspace, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceApiKeyOutcome CreateWorkspaceApiKey(const Model::CreateWorkspaceApiKeyRequest& request) const;
 
  template <typename CreateWorkspaceApiKeyRequestT = Model::CreateWorkspaceApiKeyRequest>
  Model::CreateWorkspaceApiKeyOutcomeCallable CreateWorkspaceApiKeyCallable(const CreateWorkspaceApiKeyRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::CreateWorkspaceApiKey, request);
  }
 
  template <typename CreateWorkspaceApiKeyRequestT = Model::CreateWorkspaceApiKeyRequest>
  void CreateWorkspaceApiKeyAsync(const CreateWorkspaceApiKeyRequestT& request, const CreateWorkspaceApiKeyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::CreateWorkspaceApiKey, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceServiceAccountOutcome CreateWorkspaceServiceAccount(
      const Model::CreateWorkspaceServiceAccountRequest& request) const;
 
  template <typename CreateWorkspaceServiceAccountRequestT = Model::CreateWorkspaceServiceAccountRequest>
  Model::CreateWorkspaceServiceAccountOutcomeCallable CreateWorkspaceServiceAccountCallable(
      const CreateWorkspaceServiceAccountRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::CreateWorkspaceServiceAccount, request);
  }
 
  template <typename CreateWorkspaceServiceAccountRequestT = Model::CreateWorkspaceServiceAccountRequest>
  void CreateWorkspaceServiceAccountAsync(const CreateWorkspaceServiceAccountRequestT& request,
                                          const CreateWorkspaceServiceAccountResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::CreateWorkspaceServiceAccount, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceServiceAccountTokenOutcome CreateWorkspaceServiceAccountToken(
      const Model::CreateWorkspaceServiceAccountTokenRequest& request) const;
 
  template <typename CreateWorkspaceServiceAccountTokenRequestT = Model::CreateWorkspaceServiceAccountTokenRequest>
  Model::CreateWorkspaceServiceAccountTokenOutcomeCallable CreateWorkspaceServiceAccountTokenCallable(
      const CreateWorkspaceServiceAccountTokenRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::CreateWorkspaceServiceAccountToken, request);
  }
 
  template <typename CreateWorkspaceServiceAccountTokenRequestT = Model::CreateWorkspaceServiceAccountTokenRequest>
  void CreateWorkspaceServiceAccountTokenAsync(const CreateWorkspaceServiceAccountTokenRequestT& request,
                                               const CreateWorkspaceServiceAccountTokenResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::CreateWorkspaceServiceAccountToken, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceOutcome DeleteWorkspace(const Model::DeleteWorkspaceRequest& request) const;
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  Model::DeleteWorkspaceOutcomeCallable DeleteWorkspaceCallable(const DeleteWorkspaceRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DeleteWorkspace, request);
  }
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  void DeleteWorkspaceAsync(const DeleteWorkspaceRequestT& request, const DeleteWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DeleteWorkspace, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceApiKeyOutcome DeleteWorkspaceApiKey(const Model::DeleteWorkspaceApiKeyRequest& request) const;
 
  template <typename DeleteWorkspaceApiKeyRequestT = Model::DeleteWorkspaceApiKeyRequest>
  Model::DeleteWorkspaceApiKeyOutcomeCallable DeleteWorkspaceApiKeyCallable(const DeleteWorkspaceApiKeyRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DeleteWorkspaceApiKey, request);
  }
 
  template <typename DeleteWorkspaceApiKeyRequestT = Model::DeleteWorkspaceApiKeyRequest>
  void DeleteWorkspaceApiKeyAsync(const DeleteWorkspaceApiKeyRequestT& request, const DeleteWorkspaceApiKeyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DeleteWorkspaceApiKey, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceServiceAccountOutcome DeleteWorkspaceServiceAccount(
      const Model::DeleteWorkspaceServiceAccountRequest& request) const;
 
  template <typename DeleteWorkspaceServiceAccountRequestT = Model::DeleteWorkspaceServiceAccountRequest>
  Model::DeleteWorkspaceServiceAccountOutcomeCallable DeleteWorkspaceServiceAccountCallable(
      const DeleteWorkspaceServiceAccountRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DeleteWorkspaceServiceAccount, request);
  }
 
  template <typename DeleteWorkspaceServiceAccountRequestT = Model::DeleteWorkspaceServiceAccountRequest>
  void DeleteWorkspaceServiceAccountAsync(const DeleteWorkspaceServiceAccountRequestT& request,
                                          const DeleteWorkspaceServiceAccountResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DeleteWorkspaceServiceAccount, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceServiceAccountTokenOutcome DeleteWorkspaceServiceAccountToken(
      const Model::DeleteWorkspaceServiceAccountTokenRequest& request) const;
 
  template <typename DeleteWorkspaceServiceAccountTokenRequestT = Model::DeleteWorkspaceServiceAccountTokenRequest>
  Model::DeleteWorkspaceServiceAccountTokenOutcomeCallable DeleteWorkspaceServiceAccountTokenCallable(
      const DeleteWorkspaceServiceAccountTokenRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DeleteWorkspaceServiceAccountToken, request);
  }
 
  template <typename DeleteWorkspaceServiceAccountTokenRequestT = Model::DeleteWorkspaceServiceAccountTokenRequest>
  void DeleteWorkspaceServiceAccountTokenAsync(const DeleteWorkspaceServiceAccountTokenRequestT& request,
                                               const DeleteWorkspaceServiceAccountTokenResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DeleteWorkspaceServiceAccountToken, request, handler, context);
  }
 
  virtual Model::DescribeWorkspaceOutcome DescribeWorkspace(const Model::DescribeWorkspaceRequest& request) const;
 
  template <typename DescribeWorkspaceRequestT = Model::DescribeWorkspaceRequest>
  Model::DescribeWorkspaceOutcomeCallable DescribeWorkspaceCallable(const DescribeWorkspaceRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DescribeWorkspace, request);
  }
 
  template <typename DescribeWorkspaceRequestT = Model::DescribeWorkspaceRequest>
  void DescribeWorkspaceAsync(const DescribeWorkspaceRequestT& request, const DescribeWorkspaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DescribeWorkspace, request, handler, context);
  }
 
  virtual Model::DescribeWorkspaceAuthenticationOutcome DescribeWorkspaceAuthentication(
      const Model::DescribeWorkspaceAuthenticationRequest& request) const;
 
  template <typename DescribeWorkspaceAuthenticationRequestT = Model::DescribeWorkspaceAuthenticationRequest>
  Model::DescribeWorkspaceAuthenticationOutcomeCallable DescribeWorkspaceAuthenticationCallable(
      const DescribeWorkspaceAuthenticationRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DescribeWorkspaceAuthentication, request);
  }
 
  template <typename DescribeWorkspaceAuthenticationRequestT = Model::DescribeWorkspaceAuthenticationRequest>
  void DescribeWorkspaceAuthenticationAsync(const DescribeWorkspaceAuthenticationRequestT& request,
                                            const DescribeWorkspaceAuthenticationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DescribeWorkspaceAuthentication, request, handler, context);
  }
 
  virtual Model::DescribeWorkspaceConfigurationOutcome DescribeWorkspaceConfiguration(
      const Model::DescribeWorkspaceConfigurationRequest& request) const;
 
  template <typename DescribeWorkspaceConfigurationRequestT = Model::DescribeWorkspaceConfigurationRequest>
  Model::DescribeWorkspaceConfigurationOutcomeCallable DescribeWorkspaceConfigurationCallable(
      const DescribeWorkspaceConfigurationRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DescribeWorkspaceConfiguration, request);
  }
 
  template <typename DescribeWorkspaceConfigurationRequestT = Model::DescribeWorkspaceConfigurationRequest>
  void DescribeWorkspaceConfigurationAsync(const DescribeWorkspaceConfigurationRequestT& request,
                                           const DescribeWorkspaceConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DescribeWorkspaceConfiguration, request, handler, context);
  }
 
  virtual Model::DisassociateLicenseOutcome DisassociateLicense(const Model::DisassociateLicenseRequest& request) const;
 
  template <typename DisassociateLicenseRequestT = Model::DisassociateLicenseRequest>
  Model::DisassociateLicenseOutcomeCallable DisassociateLicenseCallable(const DisassociateLicenseRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::DisassociateLicense, request);
  }
 
  template <typename DisassociateLicenseRequestT = Model::DisassociateLicenseRequest>
  void DisassociateLicenseAsync(const DisassociateLicenseRequestT& request, const DisassociateLicenseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::DisassociateLicense, request, handler, context);
  }
 
  virtual Model::ListPermissionsOutcome ListPermissions(const Model::ListPermissionsRequest& request) const;
 
  template <typename ListPermissionsRequestT = Model::ListPermissionsRequest>
  Model::ListPermissionsOutcomeCallable ListPermissionsCallable(const ListPermissionsRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::ListPermissions, request);
  }
 
  template <typename ListPermissionsRequestT = Model::ListPermissionsRequest>
  void ListPermissionsAsync(const ListPermissionsRequestT& request, const ListPermissionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::ListPermissions, 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(&ManagedGrafanaClient::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(&ManagedGrafanaClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListVersionsOutcome ListVersions(const Model::ListVersionsRequest& request = {}) const;
 
  template <typename ListVersionsRequestT = Model::ListVersionsRequest>
  Model::ListVersionsOutcomeCallable ListVersionsCallable(const ListVersionsRequestT& request = {}) const {
    return SubmitCallable(&ManagedGrafanaClient::ListVersions, request);
  }
 
  template <typename ListVersionsRequestT = Model::ListVersionsRequest>
  void ListVersionsAsync(const ListVersionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListVersionsRequestT& request = {}) const {
    return SubmitAsync(&ManagedGrafanaClient::ListVersions, request, handler, context);
  }
 
  virtual Model::ListWorkspaceServiceAccountTokensOutcome ListWorkspaceServiceAccountTokens(
      const Model::ListWorkspaceServiceAccountTokensRequest& request) const;
 
  template <typename ListWorkspaceServiceAccountTokensRequestT = Model::ListWorkspaceServiceAccountTokensRequest>
  Model::ListWorkspaceServiceAccountTokensOutcomeCallable ListWorkspaceServiceAccountTokensCallable(
      const ListWorkspaceServiceAccountTokensRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::ListWorkspaceServiceAccountTokens, request);
  }
 
  template <typename ListWorkspaceServiceAccountTokensRequestT = Model::ListWorkspaceServiceAccountTokensRequest>
  void ListWorkspaceServiceAccountTokensAsync(const ListWorkspaceServiceAccountTokensRequestT& request,
                                              const ListWorkspaceServiceAccountTokensResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::ListWorkspaceServiceAccountTokens, request, handler, context);
  }
 
  virtual Model::ListWorkspaceServiceAccountsOutcome ListWorkspaceServiceAccounts(
      const Model::ListWorkspaceServiceAccountsRequest& request) const;
 
  template <typename ListWorkspaceServiceAccountsRequestT = Model::ListWorkspaceServiceAccountsRequest>
  Model::ListWorkspaceServiceAccountsOutcomeCallable ListWorkspaceServiceAccountsCallable(
      const ListWorkspaceServiceAccountsRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::ListWorkspaceServiceAccounts, request);
  }
 
  template <typename ListWorkspaceServiceAccountsRequestT = Model::ListWorkspaceServiceAccountsRequest>
  void ListWorkspaceServiceAccountsAsync(const ListWorkspaceServiceAccountsRequestT& request,
                                         const ListWorkspaceServiceAccountsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::ListWorkspaceServiceAccounts, request, handler, context);
  }
 
  virtual Model::ListWorkspacesOutcome ListWorkspaces(const Model::ListWorkspacesRequest& request = {}) const;
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  Model::ListWorkspacesOutcomeCallable ListWorkspacesCallable(const ListWorkspacesRequestT& request = {}) const {
    return SubmitCallable(&ManagedGrafanaClient::ListWorkspaces, request);
  }
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  void ListWorkspacesAsync(const ListWorkspacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListWorkspacesRequestT& request = {}) const {
    return SubmitAsync(&ManagedGrafanaClient::ListWorkspaces, 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(&ManagedGrafanaClient::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(&ManagedGrafanaClient::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(&ManagedGrafanaClient::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(&ManagedGrafanaClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdatePermissionsOutcome UpdatePermissions(const Model::UpdatePermissionsRequest& request) const;
 
  template <typename UpdatePermissionsRequestT = Model::UpdatePermissionsRequest>
  Model::UpdatePermissionsOutcomeCallable UpdatePermissionsCallable(const UpdatePermissionsRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::UpdatePermissions, request);
  }
 
  template <typename UpdatePermissionsRequestT = Model::UpdatePermissionsRequest>
  void UpdatePermissionsAsync(const UpdatePermissionsRequestT& request, const UpdatePermissionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::UpdatePermissions, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceOutcome UpdateWorkspace(const Model::UpdateWorkspaceRequest& request) const;
 
  template <typename UpdateWorkspaceRequestT = Model::UpdateWorkspaceRequest>
  Model::UpdateWorkspaceOutcomeCallable UpdateWorkspaceCallable(const UpdateWorkspaceRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::UpdateWorkspace, request);
  }
 
  template <typename UpdateWorkspaceRequestT = Model::UpdateWorkspaceRequest>
  void UpdateWorkspaceAsync(const UpdateWorkspaceRequestT& request, const UpdateWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::UpdateWorkspace, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceAuthenticationOutcome UpdateWorkspaceAuthentication(
      const Model::UpdateWorkspaceAuthenticationRequest& request) const;
 
  template <typename UpdateWorkspaceAuthenticationRequestT = Model::UpdateWorkspaceAuthenticationRequest>
  Model::UpdateWorkspaceAuthenticationOutcomeCallable UpdateWorkspaceAuthenticationCallable(
      const UpdateWorkspaceAuthenticationRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::UpdateWorkspaceAuthentication, request);
  }
 
  template <typename UpdateWorkspaceAuthenticationRequestT = Model::UpdateWorkspaceAuthenticationRequest>
  void UpdateWorkspaceAuthenticationAsync(const UpdateWorkspaceAuthenticationRequestT& request,
                                          const UpdateWorkspaceAuthenticationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::UpdateWorkspaceAuthentication, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceConfigurationOutcome UpdateWorkspaceConfiguration(
      const Model::UpdateWorkspaceConfigurationRequest& request) const;
 
  template <typename UpdateWorkspaceConfigurationRequestT = Model::UpdateWorkspaceConfigurationRequest>
  Model::UpdateWorkspaceConfigurationOutcomeCallable UpdateWorkspaceConfigurationCallable(
      const UpdateWorkspaceConfigurationRequestT& request) const {
    return SubmitCallable(&ManagedGrafanaClient::UpdateWorkspaceConfiguration, request);
  }
 
  template <typename UpdateWorkspaceConfigurationRequestT = Model::UpdateWorkspaceConfigurationRequest>
  void UpdateWorkspaceConfigurationAsync(const UpdateWorkspaceConfigurationRequestT& request,
                                         const UpdateWorkspaceConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedGrafanaClient::UpdateWorkspaceConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ManagedGrafanaEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ManagedGrafanaClient>;
  void init(const ManagedGrafanaClientConfiguration& clientConfiguration);
 
  ManagedGrafanaClientConfiguration m_clientConfiguration;
  std::shared_ptr<ManagedGrafanaEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ManagedGrafana
}  // namespace Aws