AppRegistryClient.h

 
#pragma once
#include <aws/servicecatalog-appregistry/AppRegistry_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/servicecatalog-appregistry/AppRegistryServiceClientModel.h>
 
namespace Aws
{
namespace AppRegistry
{
  class AWS_APPREGISTRY_API AppRegistryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AppRegistryClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AppRegistryClientConfiguration ClientConfigurationType;
      typedef AppRegistryEndpointProvider EndpointProviderType;
 
        AppRegistryClient(const Aws::AppRegistry::AppRegistryClientConfiguration& clientConfiguration = Aws::AppRegistry::AppRegistryClientConfiguration(),
                          std::shared_ptr<AppRegistryEndpointProviderBase> endpointProvider = nullptr);
 
        AppRegistryClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<AppRegistryEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::AppRegistry::AppRegistryClientConfiguration& clientConfiguration = Aws::AppRegistry::AppRegistryClientConfiguration());
 
        AppRegistryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<AppRegistryEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::AppRegistry::AppRegistryClientConfiguration& clientConfiguration = Aws::AppRegistry::AppRegistryClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AppRegistryClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppRegistryClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppRegistryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AppRegistryClient();
 
        virtual Model::AssociateAttributeGroupOutcome AssociateAttributeGroup(const Model::AssociateAttributeGroupRequest& request) const;
 
        template<typename AssociateAttributeGroupRequestT = Model::AssociateAttributeGroupRequest>
        Model::AssociateAttributeGroupOutcomeCallable AssociateAttributeGroupCallable(const AssociateAttributeGroupRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::AssociateAttributeGroup, request);
        }
 
        template<typename AssociateAttributeGroupRequestT = Model::AssociateAttributeGroupRequest>
        void AssociateAttributeGroupAsync(const AssociateAttributeGroupRequestT& request, const AssociateAttributeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::AssociateAttributeGroup, request, handler, context);
        }
 
        virtual Model::AssociateResourceOutcome AssociateResource(const Model::AssociateResourceRequest& request) const;
 
        template<typename AssociateResourceRequestT = Model::AssociateResourceRequest>
        Model::AssociateResourceOutcomeCallable AssociateResourceCallable(const AssociateResourceRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::AssociateResource, request);
        }
 
        template<typename AssociateResourceRequestT = Model::AssociateResourceRequest>
        void AssociateResourceAsync(const AssociateResourceRequestT& request, const AssociateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::AssociateResource, request, handler, context);
        }
 
        virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::CreateApplication, request);
        }
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::CreateApplication, request, handler, context);
        }
 
        virtual Model::CreateAttributeGroupOutcome CreateAttributeGroup(const Model::CreateAttributeGroupRequest& request) const;
 
        template<typename CreateAttributeGroupRequestT = Model::CreateAttributeGroupRequest>
        Model::CreateAttributeGroupOutcomeCallable CreateAttributeGroupCallable(const CreateAttributeGroupRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::CreateAttributeGroup, request);
        }
 
        template<typename CreateAttributeGroupRequestT = Model::CreateAttributeGroupRequest>
        void CreateAttributeGroupAsync(const CreateAttributeGroupRequestT& request, const CreateAttributeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::CreateAttributeGroup, request, handler, context);
        }
 
        virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::DeleteApplication, request);
        }
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::DeleteApplication, request, handler, context);
        }
 
        virtual Model::DeleteAttributeGroupOutcome DeleteAttributeGroup(const Model::DeleteAttributeGroupRequest& request) const;
 
        template<typename DeleteAttributeGroupRequestT = Model::DeleteAttributeGroupRequest>
        Model::DeleteAttributeGroupOutcomeCallable DeleteAttributeGroupCallable(const DeleteAttributeGroupRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::DeleteAttributeGroup, request);
        }
 
        template<typename DeleteAttributeGroupRequestT = Model::DeleteAttributeGroupRequest>
        void DeleteAttributeGroupAsync(const DeleteAttributeGroupRequestT& request, const DeleteAttributeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::DeleteAttributeGroup, request, handler, context);
        }
 
        virtual Model::DisassociateAttributeGroupOutcome DisassociateAttributeGroup(const Model::DisassociateAttributeGroupRequest& request) const;
 
        template<typename DisassociateAttributeGroupRequestT = Model::DisassociateAttributeGroupRequest>
        Model::DisassociateAttributeGroupOutcomeCallable DisassociateAttributeGroupCallable(const DisassociateAttributeGroupRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::DisassociateAttributeGroup, request);
        }
 
        template<typename DisassociateAttributeGroupRequestT = Model::DisassociateAttributeGroupRequest>
        void DisassociateAttributeGroupAsync(const DisassociateAttributeGroupRequestT& request, const DisassociateAttributeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::DisassociateAttributeGroup, request, handler, context);
        }
 
        virtual Model::DisassociateResourceOutcome DisassociateResource(const Model::DisassociateResourceRequest& request) const;
 
        template<typename DisassociateResourceRequestT = Model::DisassociateResourceRequest>
        Model::DisassociateResourceOutcomeCallable DisassociateResourceCallable(const DisassociateResourceRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::DisassociateResource, request);
        }
 
        template<typename DisassociateResourceRequestT = Model::DisassociateResourceRequest>
        void DisassociateResourceAsync(const DisassociateResourceRequestT& request, const DisassociateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::DisassociateResource, request, handler, context);
        }
 
        virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::GetApplication, request);
        }
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::GetApplication, request, handler, context);
        }
 
        virtual Model::GetAssociatedResourceOutcome GetAssociatedResource(const Model::GetAssociatedResourceRequest& request) const;
 
        template<typename GetAssociatedResourceRequestT = Model::GetAssociatedResourceRequest>
        Model::GetAssociatedResourceOutcomeCallable GetAssociatedResourceCallable(const GetAssociatedResourceRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::GetAssociatedResource, request);
        }
 
        template<typename GetAssociatedResourceRequestT = Model::GetAssociatedResourceRequest>
        void GetAssociatedResourceAsync(const GetAssociatedResourceRequestT& request, const GetAssociatedResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::GetAssociatedResource, request, handler, context);
        }
 
        virtual Model::GetAttributeGroupOutcome GetAttributeGroup(const Model::GetAttributeGroupRequest& request) const;
 
        template<typename GetAttributeGroupRequestT = Model::GetAttributeGroupRequest>
        Model::GetAttributeGroupOutcomeCallable GetAttributeGroupCallable(const GetAttributeGroupRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::GetAttributeGroup, request);
        }
 
        template<typename GetAttributeGroupRequestT = Model::GetAttributeGroupRequest>
        void GetAttributeGroupAsync(const GetAttributeGroupRequestT& request, const GetAttributeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::GetAttributeGroup, request, handler, context);
        }
 
        virtual Model::GetConfigurationOutcome GetConfiguration(const Model::GetConfigurationRequest& request = {}) const;
 
        template<typename GetConfigurationRequestT = Model::GetConfigurationRequest>
        Model::GetConfigurationOutcomeCallable GetConfigurationCallable(const GetConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&AppRegistryClient::GetConfiguration, request);
        }
 
        template<typename GetConfigurationRequestT = Model::GetConfigurationRequest>
        void GetConfigurationAsync(const GetConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&AppRegistryClient::GetConfiguration, request, handler, context);
        }
 
        virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRegistryClient::ListApplications, request);
        }
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRegistryClient::ListApplications, request, handler, context);
        }
 
        virtual Model::ListAssociatedAttributeGroupsOutcome ListAssociatedAttributeGroups(const Model::ListAssociatedAttributeGroupsRequest& request) const;
 
        template<typename ListAssociatedAttributeGroupsRequestT = Model::ListAssociatedAttributeGroupsRequest>
        Model::ListAssociatedAttributeGroupsOutcomeCallable ListAssociatedAttributeGroupsCallable(const ListAssociatedAttributeGroupsRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::ListAssociatedAttributeGroups, request);
        }
 
        template<typename ListAssociatedAttributeGroupsRequestT = Model::ListAssociatedAttributeGroupsRequest>
        void ListAssociatedAttributeGroupsAsync(const ListAssociatedAttributeGroupsRequestT& request, const ListAssociatedAttributeGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::ListAssociatedAttributeGroups, request, handler, context);
        }
 
        virtual Model::ListAssociatedResourcesOutcome ListAssociatedResources(const Model::ListAssociatedResourcesRequest& request) const;
 
        template<typename ListAssociatedResourcesRequestT = Model::ListAssociatedResourcesRequest>
        Model::ListAssociatedResourcesOutcomeCallable ListAssociatedResourcesCallable(const ListAssociatedResourcesRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::ListAssociatedResources, request);
        }
 
        template<typename ListAssociatedResourcesRequestT = Model::ListAssociatedResourcesRequest>
        void ListAssociatedResourcesAsync(const ListAssociatedResourcesRequestT& request, const ListAssociatedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::ListAssociatedResources, request, handler, context);
        }
 
        virtual Model::ListAttributeGroupsOutcome ListAttributeGroups(const Model::ListAttributeGroupsRequest& request = {}) const;
 
        template<typename ListAttributeGroupsRequestT = Model::ListAttributeGroupsRequest>
        Model::ListAttributeGroupsOutcomeCallable ListAttributeGroupsCallable(const ListAttributeGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRegistryClient::ListAttributeGroups, request);
        }
 
        template<typename ListAttributeGroupsRequestT = Model::ListAttributeGroupsRequest>
        void ListAttributeGroupsAsync(const ListAttributeGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAttributeGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRegistryClient::ListAttributeGroups, request, handler, context);
        }
 
        virtual Model::ListAttributeGroupsForApplicationOutcome ListAttributeGroupsForApplication(const Model::ListAttributeGroupsForApplicationRequest& request) const;
 
        template<typename ListAttributeGroupsForApplicationRequestT = Model::ListAttributeGroupsForApplicationRequest>
        Model::ListAttributeGroupsForApplicationOutcomeCallable ListAttributeGroupsForApplicationCallable(const ListAttributeGroupsForApplicationRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::ListAttributeGroupsForApplication, request);
        }
 
        template<typename ListAttributeGroupsForApplicationRequestT = Model::ListAttributeGroupsForApplicationRequest>
        void ListAttributeGroupsForApplicationAsync(const ListAttributeGroupsForApplicationRequestT& request, const ListAttributeGroupsForApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::ListAttributeGroupsForApplication, 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(&AppRegistryClient::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(&AppRegistryClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutConfigurationOutcome PutConfiguration(const Model::PutConfigurationRequest& request) const;
 
        template<typename PutConfigurationRequestT = Model::PutConfigurationRequest>
        Model::PutConfigurationOutcomeCallable PutConfigurationCallable(const PutConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::PutConfiguration, request);
        }
 
        template<typename PutConfigurationRequestT = Model::PutConfigurationRequest>
        void PutConfigurationAsync(const PutConfigurationRequestT& request, const PutConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::PutConfiguration, request, handler, context);
        }
 
        virtual Model::SyncResourceOutcome SyncResource(const Model::SyncResourceRequest& request) const;
 
        template<typename SyncResourceRequestT = Model::SyncResourceRequest>
        Model::SyncResourceOutcomeCallable SyncResourceCallable(const SyncResourceRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::SyncResource, request);
        }
 
        template<typename SyncResourceRequestT = Model::SyncResourceRequest>
        void SyncResourceAsync(const SyncResourceRequestT& request, const SyncResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::SyncResource, 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(&AppRegistryClient::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(&AppRegistryClient::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(&AppRegistryClient::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(&AppRegistryClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::UpdateApplication, request);
        }
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::UpdateApplication, request, handler, context);
        }
 
        virtual Model::UpdateAttributeGroupOutcome UpdateAttributeGroup(const Model::UpdateAttributeGroupRequest& request) const;
 
        template<typename UpdateAttributeGroupRequestT = Model::UpdateAttributeGroupRequest>
        Model::UpdateAttributeGroupOutcomeCallable UpdateAttributeGroupCallable(const UpdateAttributeGroupRequestT& request) const
        {
            return SubmitCallable(&AppRegistryClient::UpdateAttributeGroup, request);
        }
 
        template<typename UpdateAttributeGroupRequestT = Model::UpdateAttributeGroupRequest>
        void UpdateAttributeGroupAsync(const UpdateAttributeGroupRequestT& request, const UpdateAttributeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRegistryClient::UpdateAttributeGroup, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppRegistryEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppRegistryClient>;
      void init(const AppRegistryClientConfiguration& clientConfiguration);
 
      AppRegistryClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppRegistryEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AppRegistry
} // namespace Aws