PanoramaClient.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/panorama/PanoramaPaginationBase.h>
#include <aws/panorama/PanoramaServiceClientModel.h>
#include <aws/panorama/PanoramaWaiter.h>
#include <aws/panorama/Panorama_EXPORTS.h>
 
namespace Aws {
namespace Panorama {
class AWS_PANORAMA_API PanoramaClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<PanoramaClient>,
                                        public PanoramaPaginationBase<PanoramaClient>,
                                        public PanoramaWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PanoramaEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PanoramaClient>;
  void init(const PanoramaClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PanoramaError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  PanoramaClientConfiguration m_clientConfiguration;
  std::shared_ptr<PanoramaEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Panorama
}  // namespace Aws