PanoramaClient.h

 
#pragma once
#include <aws/panorama/Panorama_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/panorama/PanoramaServiceClientModel.h>
 
namespace Aws
{
namespace Panorama
{
  class AWS_PANORAMA_API PanoramaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<PanoramaClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef PanoramaClientConfiguration ClientConfigurationType;
      typedef PanoramaEndpointProvider EndpointProviderType;
 
        PanoramaClient(const Aws::Panorama::PanoramaClientConfiguration& clientConfiguration = Aws::Panorama::PanoramaClientConfiguration(),
                       std::shared_ptr<PanoramaEndpointProviderBase> endpointProvider = nullptr);
 
        PanoramaClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<PanoramaEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Panorama::PanoramaClientConfiguration& clientConfiguration = Aws::Panorama::PanoramaClientConfiguration());
 
        PanoramaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<PanoramaEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Panorama::PanoramaClientConfiguration& clientConfiguration = Aws::Panorama::PanoramaClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        PanoramaClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        PanoramaClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        PanoramaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~PanoramaClient();
 
        virtual Model::CreateApplicationInstanceOutcome CreateApplicationInstance(const Model::CreateApplicationInstanceRequest& request) const;
 
        template<typename CreateApplicationInstanceRequestT = Model::CreateApplicationInstanceRequest>
        Model::CreateApplicationInstanceOutcomeCallable CreateApplicationInstanceCallable(const CreateApplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::CreateApplicationInstance, request);
        }
 
        template<typename CreateApplicationInstanceRequestT = Model::CreateApplicationInstanceRequest>
        void CreateApplicationInstanceAsync(const CreateApplicationInstanceRequestT& request, const CreateApplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::CreateApplicationInstance, request, handler, context);
        }
 
        virtual Model::CreateJobForDevicesOutcome CreateJobForDevices(const Model::CreateJobForDevicesRequest& request) const;
 
        template<typename CreateJobForDevicesRequestT = Model::CreateJobForDevicesRequest>
        Model::CreateJobForDevicesOutcomeCallable CreateJobForDevicesCallable(const CreateJobForDevicesRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::CreateJobForDevices, request);
        }
 
        template<typename CreateJobForDevicesRequestT = Model::CreateJobForDevicesRequest>
        void CreateJobForDevicesAsync(const CreateJobForDevicesRequestT& request, const CreateJobForDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::CreateJobForDevices, request, handler, context);
        }
 
        virtual Model::CreateNodeFromTemplateJobOutcome CreateNodeFromTemplateJob(const Model::CreateNodeFromTemplateJobRequest& request) const;
 
        template<typename CreateNodeFromTemplateJobRequestT = Model::CreateNodeFromTemplateJobRequest>
        Model::CreateNodeFromTemplateJobOutcomeCallable CreateNodeFromTemplateJobCallable(const CreateNodeFromTemplateJobRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::CreateNodeFromTemplateJob, request);
        }
 
        template<typename CreateNodeFromTemplateJobRequestT = Model::CreateNodeFromTemplateJobRequest>
        void CreateNodeFromTemplateJobAsync(const CreateNodeFromTemplateJobRequestT& request, const CreateNodeFromTemplateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::CreateNodeFromTemplateJob, request, handler, context);
        }
 
        virtual Model::CreatePackageOutcome CreatePackage(const Model::CreatePackageRequest& request) const;
 
        template<typename CreatePackageRequestT = Model::CreatePackageRequest>
        Model::CreatePackageOutcomeCallable CreatePackageCallable(const CreatePackageRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::CreatePackage, request);
        }
 
        template<typename CreatePackageRequestT = Model::CreatePackageRequest>
        void CreatePackageAsync(const CreatePackageRequestT& request, const CreatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::CreatePackage, request, handler, context);
        }
 
        virtual Model::CreatePackageImportJobOutcome CreatePackageImportJob(const Model::CreatePackageImportJobRequest& request) const;
 
        template<typename CreatePackageImportJobRequestT = Model::CreatePackageImportJobRequest>
        Model::CreatePackageImportJobOutcomeCallable CreatePackageImportJobCallable(const CreatePackageImportJobRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::CreatePackageImportJob, request);
        }
 
        template<typename CreatePackageImportJobRequestT = Model::CreatePackageImportJobRequest>
        void CreatePackageImportJobAsync(const CreatePackageImportJobRequestT& request, const CreatePackageImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::CreatePackageImportJob, request, handler, context);
        }
 
        virtual Model::DeleteDeviceOutcome DeleteDevice(const Model::DeleteDeviceRequest& request) const;
 
        template<typename DeleteDeviceRequestT = Model::DeleteDeviceRequest>
        Model::DeleteDeviceOutcomeCallable DeleteDeviceCallable(const DeleteDeviceRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DeleteDevice, request);
        }
 
        template<typename DeleteDeviceRequestT = Model::DeleteDeviceRequest>
        void DeleteDeviceAsync(const DeleteDeviceRequestT& request, const DeleteDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DeleteDevice, request, handler, context);
        }
 
        virtual Model::DeletePackageOutcome DeletePackage(const Model::DeletePackageRequest& request) const;
 
        template<typename DeletePackageRequestT = Model::DeletePackageRequest>
        Model::DeletePackageOutcomeCallable DeletePackageCallable(const DeletePackageRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DeletePackage, request);
        }
 
        template<typename DeletePackageRequestT = Model::DeletePackageRequest>
        void DeletePackageAsync(const DeletePackageRequestT& request, const DeletePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DeletePackage, request, handler, context);
        }
 
        virtual Model::DeregisterPackageVersionOutcome DeregisterPackageVersion(const Model::DeregisterPackageVersionRequest& request) const;
 
        template<typename DeregisterPackageVersionRequestT = Model::DeregisterPackageVersionRequest>
        Model::DeregisterPackageVersionOutcomeCallable DeregisterPackageVersionCallable(const DeregisterPackageVersionRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DeregisterPackageVersion, request);
        }
 
        template<typename DeregisterPackageVersionRequestT = Model::DeregisterPackageVersionRequest>
        void DeregisterPackageVersionAsync(const DeregisterPackageVersionRequestT& request, const DeregisterPackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DeregisterPackageVersion, request, handler, context);
        }
 
        virtual Model::DescribeApplicationInstanceOutcome DescribeApplicationInstance(const Model::DescribeApplicationInstanceRequest& request) const;
 
        template<typename DescribeApplicationInstanceRequestT = Model::DescribeApplicationInstanceRequest>
        Model::DescribeApplicationInstanceOutcomeCallable DescribeApplicationInstanceCallable(const DescribeApplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribeApplicationInstance, request);
        }
 
        template<typename DescribeApplicationInstanceRequestT = Model::DescribeApplicationInstanceRequest>
        void DescribeApplicationInstanceAsync(const DescribeApplicationInstanceRequestT& request, const DescribeApplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribeApplicationInstance, request, handler, context);
        }
 
        virtual Model::DescribeApplicationInstanceDetailsOutcome DescribeApplicationInstanceDetails(const Model::DescribeApplicationInstanceDetailsRequest& request) const;
 
        template<typename DescribeApplicationInstanceDetailsRequestT = Model::DescribeApplicationInstanceDetailsRequest>
        Model::DescribeApplicationInstanceDetailsOutcomeCallable DescribeApplicationInstanceDetailsCallable(const DescribeApplicationInstanceDetailsRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribeApplicationInstanceDetails, request);
        }
 
        template<typename DescribeApplicationInstanceDetailsRequestT = Model::DescribeApplicationInstanceDetailsRequest>
        void DescribeApplicationInstanceDetailsAsync(const DescribeApplicationInstanceDetailsRequestT& request, const DescribeApplicationInstanceDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribeApplicationInstanceDetails, request, handler, context);
        }
 
        virtual Model::DescribeDeviceOutcome DescribeDevice(const Model::DescribeDeviceRequest& request) const;
 
        template<typename DescribeDeviceRequestT = Model::DescribeDeviceRequest>
        Model::DescribeDeviceOutcomeCallable DescribeDeviceCallable(const DescribeDeviceRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribeDevice, request);
        }
 
        template<typename DescribeDeviceRequestT = Model::DescribeDeviceRequest>
        void DescribeDeviceAsync(const DescribeDeviceRequestT& request, const DescribeDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribeDevice, request, handler, context);
        }
 
        virtual Model::DescribeDeviceJobOutcome DescribeDeviceJob(const Model::DescribeDeviceJobRequest& request) const;
 
        template<typename DescribeDeviceJobRequestT = Model::DescribeDeviceJobRequest>
        Model::DescribeDeviceJobOutcomeCallable DescribeDeviceJobCallable(const DescribeDeviceJobRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribeDeviceJob, request);
        }
 
        template<typename DescribeDeviceJobRequestT = Model::DescribeDeviceJobRequest>
        void DescribeDeviceJobAsync(const DescribeDeviceJobRequestT& request, const DescribeDeviceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribeDeviceJob, request, handler, context);
        }
 
        virtual Model::DescribeNodeOutcome DescribeNode(const Model::DescribeNodeRequest& request) const;
 
        template<typename DescribeNodeRequestT = Model::DescribeNodeRequest>
        Model::DescribeNodeOutcomeCallable DescribeNodeCallable(const DescribeNodeRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribeNode, request);
        }
 
        template<typename DescribeNodeRequestT = Model::DescribeNodeRequest>
        void DescribeNodeAsync(const DescribeNodeRequestT& request, const DescribeNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribeNode, request, handler, context);
        }
 
        virtual Model::DescribeNodeFromTemplateJobOutcome DescribeNodeFromTemplateJob(const Model::DescribeNodeFromTemplateJobRequest& request) const;
 
        template<typename DescribeNodeFromTemplateJobRequestT = Model::DescribeNodeFromTemplateJobRequest>
        Model::DescribeNodeFromTemplateJobOutcomeCallable DescribeNodeFromTemplateJobCallable(const DescribeNodeFromTemplateJobRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribeNodeFromTemplateJob, request);
        }
 
        template<typename DescribeNodeFromTemplateJobRequestT = Model::DescribeNodeFromTemplateJobRequest>
        void DescribeNodeFromTemplateJobAsync(const DescribeNodeFromTemplateJobRequestT& request, const DescribeNodeFromTemplateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribeNodeFromTemplateJob, request, handler, context);
        }
 
        virtual Model::DescribePackageOutcome DescribePackage(const Model::DescribePackageRequest& request) const;
 
        template<typename DescribePackageRequestT = Model::DescribePackageRequest>
        Model::DescribePackageOutcomeCallable DescribePackageCallable(const DescribePackageRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribePackage, request);
        }
 
        template<typename DescribePackageRequestT = Model::DescribePackageRequest>
        void DescribePackageAsync(const DescribePackageRequestT& request, const DescribePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribePackage, request, handler, context);
        }
 
        virtual Model::DescribePackageImportJobOutcome DescribePackageImportJob(const Model::DescribePackageImportJobRequest& request) const;
 
        template<typename DescribePackageImportJobRequestT = Model::DescribePackageImportJobRequest>
        Model::DescribePackageImportJobOutcomeCallable DescribePackageImportJobCallable(const DescribePackageImportJobRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribePackageImportJob, request);
        }
 
        template<typename DescribePackageImportJobRequestT = Model::DescribePackageImportJobRequest>
        void DescribePackageImportJobAsync(const DescribePackageImportJobRequestT& request, const DescribePackageImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribePackageImportJob, request, handler, context);
        }
 
        virtual Model::DescribePackageVersionOutcome DescribePackageVersion(const Model::DescribePackageVersionRequest& request) const;
 
        template<typename DescribePackageVersionRequestT = Model::DescribePackageVersionRequest>
        Model::DescribePackageVersionOutcomeCallable DescribePackageVersionCallable(const DescribePackageVersionRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::DescribePackageVersion, request);
        }
 
        template<typename DescribePackageVersionRequestT = Model::DescribePackageVersionRequest>
        void DescribePackageVersionAsync(const DescribePackageVersionRequestT& request, const DescribePackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::DescribePackageVersion, request, handler, context);
        }
 
        virtual Model::ListApplicationInstanceDependenciesOutcome ListApplicationInstanceDependencies(const Model::ListApplicationInstanceDependenciesRequest& request) const;
 
        template<typename ListApplicationInstanceDependenciesRequestT = Model::ListApplicationInstanceDependenciesRequest>
        Model::ListApplicationInstanceDependenciesOutcomeCallable ListApplicationInstanceDependenciesCallable(const ListApplicationInstanceDependenciesRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::ListApplicationInstanceDependencies, request);
        }
 
        template<typename ListApplicationInstanceDependenciesRequestT = Model::ListApplicationInstanceDependenciesRequest>
        void ListApplicationInstanceDependenciesAsync(const ListApplicationInstanceDependenciesRequestT& request, const ListApplicationInstanceDependenciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::ListApplicationInstanceDependencies, request, handler, context);
        }
 
        virtual Model::ListApplicationInstanceNodeInstancesOutcome ListApplicationInstanceNodeInstances(const Model::ListApplicationInstanceNodeInstancesRequest& request) const;
 
        template<typename ListApplicationInstanceNodeInstancesRequestT = Model::ListApplicationInstanceNodeInstancesRequest>
        Model::ListApplicationInstanceNodeInstancesOutcomeCallable ListApplicationInstanceNodeInstancesCallable(const ListApplicationInstanceNodeInstancesRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::ListApplicationInstanceNodeInstances, request);
        }
 
        template<typename ListApplicationInstanceNodeInstancesRequestT = Model::ListApplicationInstanceNodeInstancesRequest>
        void ListApplicationInstanceNodeInstancesAsync(const ListApplicationInstanceNodeInstancesRequestT& request, const ListApplicationInstanceNodeInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::ListApplicationInstanceNodeInstances, request, handler, context);
        }
 
        virtual Model::ListApplicationInstancesOutcome ListApplicationInstances(const Model::ListApplicationInstancesRequest& request = {}) const;
 
        template<typename ListApplicationInstancesRequestT = Model::ListApplicationInstancesRequest>
        Model::ListApplicationInstancesOutcomeCallable ListApplicationInstancesCallable(const ListApplicationInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListApplicationInstances, request);
        }
 
        template<typename ListApplicationInstancesRequestT = Model::ListApplicationInstancesRequest>
        void ListApplicationInstancesAsync(const ListApplicationInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListApplicationInstances, request, handler, context);
        }
 
        virtual Model::ListDevicesOutcome ListDevices(const Model::ListDevicesRequest& request = {}) const;
 
        template<typename ListDevicesRequestT = Model::ListDevicesRequest>
        Model::ListDevicesOutcomeCallable ListDevicesCallable(const ListDevicesRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListDevices, request);
        }
 
        template<typename ListDevicesRequestT = Model::ListDevicesRequest>
        void ListDevicesAsync(const ListDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDevicesRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListDevices, request, handler, context);
        }
 
        virtual Model::ListDevicesJobsOutcome ListDevicesJobs(const Model::ListDevicesJobsRequest& request = {}) const;
 
        template<typename ListDevicesJobsRequestT = Model::ListDevicesJobsRequest>
        Model::ListDevicesJobsOutcomeCallable ListDevicesJobsCallable(const ListDevicesJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListDevicesJobs, request);
        }
 
        template<typename ListDevicesJobsRequestT = Model::ListDevicesJobsRequest>
        void ListDevicesJobsAsync(const ListDevicesJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDevicesJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListDevicesJobs, request, handler, context);
        }
 
        virtual Model::ListNodeFromTemplateJobsOutcome ListNodeFromTemplateJobs(const Model::ListNodeFromTemplateJobsRequest& request = {}) const;
 
        template<typename ListNodeFromTemplateJobsRequestT = Model::ListNodeFromTemplateJobsRequest>
        Model::ListNodeFromTemplateJobsOutcomeCallable ListNodeFromTemplateJobsCallable(const ListNodeFromTemplateJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListNodeFromTemplateJobs, request);
        }
 
        template<typename ListNodeFromTemplateJobsRequestT = Model::ListNodeFromTemplateJobsRequest>
        void ListNodeFromTemplateJobsAsync(const ListNodeFromTemplateJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNodeFromTemplateJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListNodeFromTemplateJobs, request, handler, context);
        }
 
        virtual Model::ListNodesOutcome ListNodes(const Model::ListNodesRequest& request = {}) const;
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        Model::ListNodesOutcomeCallable ListNodesCallable(const ListNodesRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListNodes, request);
        }
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        void ListNodesAsync(const ListNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNodesRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListNodes, request, handler, context);
        }
 
        virtual Model::ListPackageImportJobsOutcome ListPackageImportJobs(const Model::ListPackageImportJobsRequest& request = {}) const;
 
        template<typename ListPackageImportJobsRequestT = Model::ListPackageImportJobsRequest>
        Model::ListPackageImportJobsOutcomeCallable ListPackageImportJobsCallable(const ListPackageImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListPackageImportJobs, request);
        }
 
        template<typename ListPackageImportJobsRequestT = Model::ListPackageImportJobsRequest>
        void ListPackageImportJobsAsync(const ListPackageImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPackageImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListPackageImportJobs, request, handler, context);
        }
 
        virtual Model::ListPackagesOutcome ListPackages(const Model::ListPackagesRequest& request = {}) const;
 
        template<typename ListPackagesRequestT = Model::ListPackagesRequest>
        Model::ListPackagesOutcomeCallable ListPackagesCallable(const ListPackagesRequestT& request = {}) const
        {
            return SubmitCallable(&PanoramaClient::ListPackages, request);
        }
 
        template<typename ListPackagesRequestT = Model::ListPackagesRequest>
        void ListPackagesAsync(const ListPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPackagesRequestT& request = {}) const
        {
            return SubmitAsync(&PanoramaClient::ListPackages, 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(&PanoramaClient::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(&PanoramaClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ProvisionDeviceOutcome ProvisionDevice(const Model::ProvisionDeviceRequest& request) const;
 
        template<typename ProvisionDeviceRequestT = Model::ProvisionDeviceRequest>
        Model::ProvisionDeviceOutcomeCallable ProvisionDeviceCallable(const ProvisionDeviceRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::ProvisionDevice, request);
        }
 
        template<typename ProvisionDeviceRequestT = Model::ProvisionDeviceRequest>
        void ProvisionDeviceAsync(const ProvisionDeviceRequestT& request, const ProvisionDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::ProvisionDevice, request, handler, context);
        }
 
        virtual Model::RegisterPackageVersionOutcome RegisterPackageVersion(const Model::RegisterPackageVersionRequest& request) const;
 
        template<typename RegisterPackageVersionRequestT = Model::RegisterPackageVersionRequest>
        Model::RegisterPackageVersionOutcomeCallable RegisterPackageVersionCallable(const RegisterPackageVersionRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::RegisterPackageVersion, request);
        }
 
        template<typename RegisterPackageVersionRequestT = Model::RegisterPackageVersionRequest>
        void RegisterPackageVersionAsync(const RegisterPackageVersionRequestT& request, const RegisterPackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::RegisterPackageVersion, request, handler, context);
        }
 
        virtual Model::RemoveApplicationInstanceOutcome RemoveApplicationInstance(const Model::RemoveApplicationInstanceRequest& request) const;
 
        template<typename RemoveApplicationInstanceRequestT = Model::RemoveApplicationInstanceRequest>
        Model::RemoveApplicationInstanceOutcomeCallable RemoveApplicationInstanceCallable(const RemoveApplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::RemoveApplicationInstance, request);
        }
 
        template<typename RemoveApplicationInstanceRequestT = Model::RemoveApplicationInstanceRequest>
        void RemoveApplicationInstanceAsync(const RemoveApplicationInstanceRequestT& request, const RemoveApplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::RemoveApplicationInstance, request, handler, context);
        }
 
        virtual Model::SignalApplicationInstanceNodeInstancesOutcome SignalApplicationInstanceNodeInstances(const Model::SignalApplicationInstanceNodeInstancesRequest& request) const;
 
        template<typename SignalApplicationInstanceNodeInstancesRequestT = Model::SignalApplicationInstanceNodeInstancesRequest>
        Model::SignalApplicationInstanceNodeInstancesOutcomeCallable SignalApplicationInstanceNodeInstancesCallable(const SignalApplicationInstanceNodeInstancesRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::SignalApplicationInstanceNodeInstances, request);
        }
 
        template<typename SignalApplicationInstanceNodeInstancesRequestT = Model::SignalApplicationInstanceNodeInstancesRequest>
        void SignalApplicationInstanceNodeInstancesAsync(const SignalApplicationInstanceNodeInstancesRequestT& request, const SignalApplicationInstanceNodeInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::SignalApplicationInstanceNodeInstances, 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(&PanoramaClient::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(&PanoramaClient::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(&PanoramaClient::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(&PanoramaClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDeviceMetadataOutcome UpdateDeviceMetadata(const Model::UpdateDeviceMetadataRequest& request) const;
 
        template<typename UpdateDeviceMetadataRequestT = Model::UpdateDeviceMetadataRequest>
        Model::UpdateDeviceMetadataOutcomeCallable UpdateDeviceMetadataCallable(const UpdateDeviceMetadataRequestT& request) const
        {
            return SubmitCallable(&PanoramaClient::UpdateDeviceMetadata, request);
        }
 
        template<typename UpdateDeviceMetadataRequestT = Model::UpdateDeviceMetadataRequest>
        void UpdateDeviceMetadataAsync(const UpdateDeviceMetadataRequestT& request, const UpdateDeviceMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PanoramaClient::UpdateDeviceMetadata, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<PanoramaEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<PanoramaClient>;
      void init(const PanoramaClientConfiguration& clientConfiguration);
 
      PanoramaClientConfiguration m_clientConfiguration;
      std::shared_ptr<PanoramaEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Panorama
} // namespace Aws