ManagedGrafanaClient.h

 
#pragma once
#include <aws/grafana/ManagedGrafana_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/grafana/ManagedGrafanaServiceClientModel.h>
 
namespace Aws
{
namespace ManagedGrafana
{
  class AWS_MANAGEDGRAFANA_API ManagedGrafanaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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