IoTWirelessClient.h

 
#pragma once
#include <aws/iotwireless/IoTWireless_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/iotwireless/IoTWirelessServiceClientModel.h>
 
namespace Aws
{
namespace IoTWireless
{
  class AWS_IOTWIRELESS_API IoTWirelessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTWirelessClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTWirelessClientConfiguration ClientConfigurationType;
      typedef IoTWirelessEndpointProvider EndpointProviderType;
 
        IoTWirelessClient(const Aws::IoTWireless::IoTWirelessClientConfiguration& clientConfiguration = Aws::IoTWireless::IoTWirelessClientConfiguration(),
                          std::shared_ptr<IoTWirelessEndpointProviderBase> endpointProvider = nullptr);
 
        IoTWirelessClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<IoTWirelessEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::IoTWireless::IoTWirelessClientConfiguration& clientConfiguration = Aws::IoTWireless::IoTWirelessClientConfiguration());
 
        IoTWirelessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<IoTWirelessEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::IoTWireless::IoTWirelessClientConfiguration& clientConfiguration = Aws::IoTWireless::IoTWirelessClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTWirelessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTWirelessClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTWirelessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTWirelessClient();
 
        virtual Model::AssociateAwsAccountWithPartnerAccountOutcome AssociateAwsAccountWithPartnerAccount(const Model::AssociateAwsAccountWithPartnerAccountRequest& request) const;
 
        template<typename AssociateAwsAccountWithPartnerAccountRequestT = Model::AssociateAwsAccountWithPartnerAccountRequest>
        Model::AssociateAwsAccountWithPartnerAccountOutcomeCallable AssociateAwsAccountWithPartnerAccountCallable(const AssociateAwsAccountWithPartnerAccountRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateAwsAccountWithPartnerAccount, request);
        }
 
        template<typename AssociateAwsAccountWithPartnerAccountRequestT = Model::AssociateAwsAccountWithPartnerAccountRequest>
        void AssociateAwsAccountWithPartnerAccountAsync(const AssociateAwsAccountWithPartnerAccountRequestT& request, const AssociateAwsAccountWithPartnerAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateAwsAccountWithPartnerAccount, request, handler, context);
        }
 
        virtual Model::AssociateMulticastGroupWithFuotaTaskOutcome AssociateMulticastGroupWithFuotaTask(const Model::AssociateMulticastGroupWithFuotaTaskRequest& request) const;
 
        template<typename AssociateMulticastGroupWithFuotaTaskRequestT = Model::AssociateMulticastGroupWithFuotaTaskRequest>
        Model::AssociateMulticastGroupWithFuotaTaskOutcomeCallable AssociateMulticastGroupWithFuotaTaskCallable(const AssociateMulticastGroupWithFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateMulticastGroupWithFuotaTask, request);
        }
 
        template<typename AssociateMulticastGroupWithFuotaTaskRequestT = Model::AssociateMulticastGroupWithFuotaTaskRequest>
        void AssociateMulticastGroupWithFuotaTaskAsync(const AssociateMulticastGroupWithFuotaTaskRequestT& request, const AssociateMulticastGroupWithFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateMulticastGroupWithFuotaTask, request, handler, context);
        }
 
        virtual Model::AssociateWirelessDeviceWithFuotaTaskOutcome AssociateWirelessDeviceWithFuotaTask(const Model::AssociateWirelessDeviceWithFuotaTaskRequest& request) const;
 
        template<typename AssociateWirelessDeviceWithFuotaTaskRequestT = Model::AssociateWirelessDeviceWithFuotaTaskRequest>
        Model::AssociateWirelessDeviceWithFuotaTaskOutcomeCallable AssociateWirelessDeviceWithFuotaTaskCallable(const AssociateWirelessDeviceWithFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateWirelessDeviceWithFuotaTask, request);
        }
 
        template<typename AssociateWirelessDeviceWithFuotaTaskRequestT = Model::AssociateWirelessDeviceWithFuotaTaskRequest>
        void AssociateWirelessDeviceWithFuotaTaskAsync(const AssociateWirelessDeviceWithFuotaTaskRequestT& request, const AssociateWirelessDeviceWithFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateWirelessDeviceWithFuotaTask, request, handler, context);
        }
 
        virtual Model::AssociateWirelessDeviceWithMulticastGroupOutcome AssociateWirelessDeviceWithMulticastGroup(const Model::AssociateWirelessDeviceWithMulticastGroupRequest& request) const;
 
        template<typename AssociateWirelessDeviceWithMulticastGroupRequestT = Model::AssociateWirelessDeviceWithMulticastGroupRequest>
        Model::AssociateWirelessDeviceWithMulticastGroupOutcomeCallable AssociateWirelessDeviceWithMulticastGroupCallable(const AssociateWirelessDeviceWithMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateWirelessDeviceWithMulticastGroup, request);
        }
 
        template<typename AssociateWirelessDeviceWithMulticastGroupRequestT = Model::AssociateWirelessDeviceWithMulticastGroupRequest>
        void AssociateWirelessDeviceWithMulticastGroupAsync(const AssociateWirelessDeviceWithMulticastGroupRequestT& request, const AssociateWirelessDeviceWithMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateWirelessDeviceWithMulticastGroup, request, handler, context);
        }
 
        virtual Model::AssociateWirelessDeviceWithThingOutcome AssociateWirelessDeviceWithThing(const Model::AssociateWirelessDeviceWithThingRequest& request) const;
 
        template<typename AssociateWirelessDeviceWithThingRequestT = Model::AssociateWirelessDeviceWithThingRequest>
        Model::AssociateWirelessDeviceWithThingOutcomeCallable AssociateWirelessDeviceWithThingCallable(const AssociateWirelessDeviceWithThingRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateWirelessDeviceWithThing, request);
        }
 
        template<typename AssociateWirelessDeviceWithThingRequestT = Model::AssociateWirelessDeviceWithThingRequest>
        void AssociateWirelessDeviceWithThingAsync(const AssociateWirelessDeviceWithThingRequestT& request, const AssociateWirelessDeviceWithThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateWirelessDeviceWithThing, request, handler, context);
        }
 
        virtual Model::AssociateWirelessGatewayWithCertificateOutcome AssociateWirelessGatewayWithCertificate(const Model::AssociateWirelessGatewayWithCertificateRequest& request) const;
 
        template<typename AssociateWirelessGatewayWithCertificateRequestT = Model::AssociateWirelessGatewayWithCertificateRequest>
        Model::AssociateWirelessGatewayWithCertificateOutcomeCallable AssociateWirelessGatewayWithCertificateCallable(const AssociateWirelessGatewayWithCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateWirelessGatewayWithCertificate, request);
        }
 
        template<typename AssociateWirelessGatewayWithCertificateRequestT = Model::AssociateWirelessGatewayWithCertificateRequest>
        void AssociateWirelessGatewayWithCertificateAsync(const AssociateWirelessGatewayWithCertificateRequestT& request, const AssociateWirelessGatewayWithCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateWirelessGatewayWithCertificate, request, handler, context);
        }
 
        virtual Model::AssociateWirelessGatewayWithThingOutcome AssociateWirelessGatewayWithThing(const Model::AssociateWirelessGatewayWithThingRequest& request) const;
 
        template<typename AssociateWirelessGatewayWithThingRequestT = Model::AssociateWirelessGatewayWithThingRequest>
        Model::AssociateWirelessGatewayWithThingOutcomeCallable AssociateWirelessGatewayWithThingCallable(const AssociateWirelessGatewayWithThingRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::AssociateWirelessGatewayWithThing, request);
        }
 
        template<typename AssociateWirelessGatewayWithThingRequestT = Model::AssociateWirelessGatewayWithThingRequest>
        void AssociateWirelessGatewayWithThingAsync(const AssociateWirelessGatewayWithThingRequestT& request, const AssociateWirelessGatewayWithThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::AssociateWirelessGatewayWithThing, request, handler, context);
        }
 
        virtual Model::CancelMulticastGroupSessionOutcome CancelMulticastGroupSession(const Model::CancelMulticastGroupSessionRequest& request) const;
 
        template<typename CancelMulticastGroupSessionRequestT = Model::CancelMulticastGroupSessionRequest>
        Model::CancelMulticastGroupSessionOutcomeCallable CancelMulticastGroupSessionCallable(const CancelMulticastGroupSessionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CancelMulticastGroupSession, request);
        }
 
        template<typename CancelMulticastGroupSessionRequestT = Model::CancelMulticastGroupSessionRequest>
        void CancelMulticastGroupSessionAsync(const CancelMulticastGroupSessionRequestT& request, const CancelMulticastGroupSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CancelMulticastGroupSession, request, handler, context);
        }
 
        virtual Model::CreateDestinationOutcome CreateDestination(const Model::CreateDestinationRequest& request) const;
 
        template<typename CreateDestinationRequestT = Model::CreateDestinationRequest>
        Model::CreateDestinationOutcomeCallable CreateDestinationCallable(const CreateDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateDestination, request);
        }
 
        template<typename CreateDestinationRequestT = Model::CreateDestinationRequest>
        void CreateDestinationAsync(const CreateDestinationRequestT& request, const CreateDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateDestination, request, handler, context);
        }
 
        virtual Model::CreateDeviceProfileOutcome CreateDeviceProfile(const Model::CreateDeviceProfileRequest& request = {}) const;
 
        template<typename CreateDeviceProfileRequestT = Model::CreateDeviceProfileRequest>
        Model::CreateDeviceProfileOutcomeCallable CreateDeviceProfileCallable(const CreateDeviceProfileRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateDeviceProfile, request);
        }
 
        template<typename CreateDeviceProfileRequestT = Model::CreateDeviceProfileRequest>
        void CreateDeviceProfileAsync(const CreateDeviceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateDeviceProfileRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateDeviceProfile, request, handler, context);
        }
 
        virtual Model::CreateFuotaTaskOutcome CreateFuotaTask(const Model::CreateFuotaTaskRequest& request) const;
 
        template<typename CreateFuotaTaskRequestT = Model::CreateFuotaTaskRequest>
        Model::CreateFuotaTaskOutcomeCallable CreateFuotaTaskCallable(const CreateFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateFuotaTask, request);
        }
 
        template<typename CreateFuotaTaskRequestT = Model::CreateFuotaTaskRequest>
        void CreateFuotaTaskAsync(const CreateFuotaTaskRequestT& request, const CreateFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateFuotaTask, request, handler, context);
        }
 
        virtual Model::CreateMulticastGroupOutcome CreateMulticastGroup(const Model::CreateMulticastGroupRequest& request) const;
 
        template<typename CreateMulticastGroupRequestT = Model::CreateMulticastGroupRequest>
        Model::CreateMulticastGroupOutcomeCallable CreateMulticastGroupCallable(const CreateMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateMulticastGroup, request);
        }
 
        template<typename CreateMulticastGroupRequestT = Model::CreateMulticastGroupRequest>
        void CreateMulticastGroupAsync(const CreateMulticastGroupRequestT& request, const CreateMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateMulticastGroup, request, handler, context);
        }
 
        virtual Model::CreateNetworkAnalyzerConfigurationOutcome CreateNetworkAnalyzerConfiguration(const Model::CreateNetworkAnalyzerConfigurationRequest& request) const;
 
        template<typename CreateNetworkAnalyzerConfigurationRequestT = Model::CreateNetworkAnalyzerConfigurationRequest>
        Model::CreateNetworkAnalyzerConfigurationOutcomeCallable CreateNetworkAnalyzerConfigurationCallable(const CreateNetworkAnalyzerConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateNetworkAnalyzerConfiguration, request);
        }
 
        template<typename CreateNetworkAnalyzerConfigurationRequestT = Model::CreateNetworkAnalyzerConfigurationRequest>
        void CreateNetworkAnalyzerConfigurationAsync(const CreateNetworkAnalyzerConfigurationRequestT& request, const CreateNetworkAnalyzerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateNetworkAnalyzerConfiguration, request, handler, context);
        }
 
        virtual Model::CreateServiceProfileOutcome CreateServiceProfile(const Model::CreateServiceProfileRequest& request = {}) const;
 
        template<typename CreateServiceProfileRequestT = Model::CreateServiceProfileRequest>
        Model::CreateServiceProfileOutcomeCallable CreateServiceProfileCallable(const CreateServiceProfileRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateServiceProfile, request);
        }
 
        template<typename CreateServiceProfileRequestT = Model::CreateServiceProfileRequest>
        void CreateServiceProfileAsync(const CreateServiceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateServiceProfileRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateServiceProfile, request, handler, context);
        }
 
        virtual Model::CreateWirelessDeviceOutcome CreateWirelessDevice(const Model::CreateWirelessDeviceRequest& request) const;
 
        template<typename CreateWirelessDeviceRequestT = Model::CreateWirelessDeviceRequest>
        Model::CreateWirelessDeviceOutcomeCallable CreateWirelessDeviceCallable(const CreateWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateWirelessDevice, request);
        }
 
        template<typename CreateWirelessDeviceRequestT = Model::CreateWirelessDeviceRequest>
        void CreateWirelessDeviceAsync(const CreateWirelessDeviceRequestT& request, const CreateWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateWirelessDevice, request, handler, context);
        }
 
        virtual Model::CreateWirelessGatewayOutcome CreateWirelessGateway(const Model::CreateWirelessGatewayRequest& request) const;
 
        template<typename CreateWirelessGatewayRequestT = Model::CreateWirelessGatewayRequest>
        Model::CreateWirelessGatewayOutcomeCallable CreateWirelessGatewayCallable(const CreateWirelessGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateWirelessGateway, request);
        }
 
        template<typename CreateWirelessGatewayRequestT = Model::CreateWirelessGatewayRequest>
        void CreateWirelessGatewayAsync(const CreateWirelessGatewayRequestT& request, const CreateWirelessGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateWirelessGateway, request, handler, context);
        }
 
        virtual Model::CreateWirelessGatewayTaskOutcome CreateWirelessGatewayTask(const Model::CreateWirelessGatewayTaskRequest& request) const;
 
        template<typename CreateWirelessGatewayTaskRequestT = Model::CreateWirelessGatewayTaskRequest>
        Model::CreateWirelessGatewayTaskOutcomeCallable CreateWirelessGatewayTaskCallable(const CreateWirelessGatewayTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateWirelessGatewayTask, request);
        }
 
        template<typename CreateWirelessGatewayTaskRequestT = Model::CreateWirelessGatewayTaskRequest>
        void CreateWirelessGatewayTaskAsync(const CreateWirelessGatewayTaskRequestT& request, const CreateWirelessGatewayTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateWirelessGatewayTask, request, handler, context);
        }
 
        virtual Model::CreateWirelessGatewayTaskDefinitionOutcome CreateWirelessGatewayTaskDefinition(const Model::CreateWirelessGatewayTaskDefinitionRequest& request) const;
 
        template<typename CreateWirelessGatewayTaskDefinitionRequestT = Model::CreateWirelessGatewayTaskDefinitionRequest>
        Model::CreateWirelessGatewayTaskDefinitionOutcomeCallable CreateWirelessGatewayTaskDefinitionCallable(const CreateWirelessGatewayTaskDefinitionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::CreateWirelessGatewayTaskDefinition, request);
        }
 
        template<typename CreateWirelessGatewayTaskDefinitionRequestT = Model::CreateWirelessGatewayTaskDefinitionRequest>
        void CreateWirelessGatewayTaskDefinitionAsync(const CreateWirelessGatewayTaskDefinitionRequestT& request, const CreateWirelessGatewayTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::CreateWirelessGatewayTaskDefinition, request, handler, context);
        }
 
        virtual Model::DeleteDestinationOutcome DeleteDestination(const Model::DeleteDestinationRequest& request) const;
 
        template<typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
        Model::DeleteDestinationOutcomeCallable DeleteDestinationCallable(const DeleteDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteDestination, request);
        }
 
        template<typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
        void DeleteDestinationAsync(const DeleteDestinationRequestT& request, const DeleteDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteDestination, request, handler, context);
        }
 
        virtual Model::DeleteDeviceProfileOutcome DeleteDeviceProfile(const Model::DeleteDeviceProfileRequest& request) const;
 
        template<typename DeleteDeviceProfileRequestT = Model::DeleteDeviceProfileRequest>
        Model::DeleteDeviceProfileOutcomeCallable DeleteDeviceProfileCallable(const DeleteDeviceProfileRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteDeviceProfile, request);
        }
 
        template<typename DeleteDeviceProfileRequestT = Model::DeleteDeviceProfileRequest>
        void DeleteDeviceProfileAsync(const DeleteDeviceProfileRequestT& request, const DeleteDeviceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteDeviceProfile, request, handler, context);
        }
 
        virtual Model::DeleteFuotaTaskOutcome DeleteFuotaTask(const Model::DeleteFuotaTaskRequest& request) const;
 
        template<typename DeleteFuotaTaskRequestT = Model::DeleteFuotaTaskRequest>
        Model::DeleteFuotaTaskOutcomeCallable DeleteFuotaTaskCallable(const DeleteFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteFuotaTask, request);
        }
 
        template<typename DeleteFuotaTaskRequestT = Model::DeleteFuotaTaskRequest>
        void DeleteFuotaTaskAsync(const DeleteFuotaTaskRequestT& request, const DeleteFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteFuotaTask, request, handler, context);
        }
 
        virtual Model::DeleteMulticastGroupOutcome DeleteMulticastGroup(const Model::DeleteMulticastGroupRequest& request) const;
 
        template<typename DeleteMulticastGroupRequestT = Model::DeleteMulticastGroupRequest>
        Model::DeleteMulticastGroupOutcomeCallable DeleteMulticastGroupCallable(const DeleteMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteMulticastGroup, request);
        }
 
        template<typename DeleteMulticastGroupRequestT = Model::DeleteMulticastGroupRequest>
        void DeleteMulticastGroupAsync(const DeleteMulticastGroupRequestT& request, const DeleteMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteMulticastGroup, request, handler, context);
        }
 
        virtual Model::DeleteNetworkAnalyzerConfigurationOutcome DeleteNetworkAnalyzerConfiguration(const Model::DeleteNetworkAnalyzerConfigurationRequest& request) const;
 
        template<typename DeleteNetworkAnalyzerConfigurationRequestT = Model::DeleteNetworkAnalyzerConfigurationRequest>
        Model::DeleteNetworkAnalyzerConfigurationOutcomeCallable DeleteNetworkAnalyzerConfigurationCallable(const DeleteNetworkAnalyzerConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteNetworkAnalyzerConfiguration, request);
        }
 
        template<typename DeleteNetworkAnalyzerConfigurationRequestT = Model::DeleteNetworkAnalyzerConfigurationRequest>
        void DeleteNetworkAnalyzerConfigurationAsync(const DeleteNetworkAnalyzerConfigurationRequestT& request, const DeleteNetworkAnalyzerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteNetworkAnalyzerConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteQueuedMessagesOutcome DeleteQueuedMessages(const Model::DeleteQueuedMessagesRequest& request) const;
 
        template<typename DeleteQueuedMessagesRequestT = Model::DeleteQueuedMessagesRequest>
        Model::DeleteQueuedMessagesOutcomeCallable DeleteQueuedMessagesCallable(const DeleteQueuedMessagesRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteQueuedMessages, request);
        }
 
        template<typename DeleteQueuedMessagesRequestT = Model::DeleteQueuedMessagesRequest>
        void DeleteQueuedMessagesAsync(const DeleteQueuedMessagesRequestT& request, const DeleteQueuedMessagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteQueuedMessages, request, handler, context);
        }
 
        virtual Model::DeleteServiceProfileOutcome DeleteServiceProfile(const Model::DeleteServiceProfileRequest& request) const;
 
        template<typename DeleteServiceProfileRequestT = Model::DeleteServiceProfileRequest>
        Model::DeleteServiceProfileOutcomeCallable DeleteServiceProfileCallable(const DeleteServiceProfileRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteServiceProfile, request);
        }
 
        template<typename DeleteServiceProfileRequestT = Model::DeleteServiceProfileRequest>
        void DeleteServiceProfileAsync(const DeleteServiceProfileRequestT& request, const DeleteServiceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteServiceProfile, request, handler, context);
        }
 
        virtual Model::DeleteWirelessDeviceOutcome DeleteWirelessDevice(const Model::DeleteWirelessDeviceRequest& request) const;
 
        template<typename DeleteWirelessDeviceRequestT = Model::DeleteWirelessDeviceRequest>
        Model::DeleteWirelessDeviceOutcomeCallable DeleteWirelessDeviceCallable(const DeleteWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteWirelessDevice, request);
        }
 
        template<typename DeleteWirelessDeviceRequestT = Model::DeleteWirelessDeviceRequest>
        void DeleteWirelessDeviceAsync(const DeleteWirelessDeviceRequestT& request, const DeleteWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteWirelessDevice, request, handler, context);
        }
 
        virtual Model::DeleteWirelessDeviceImportTaskOutcome DeleteWirelessDeviceImportTask(const Model::DeleteWirelessDeviceImportTaskRequest& request) const;
 
        template<typename DeleteWirelessDeviceImportTaskRequestT = Model::DeleteWirelessDeviceImportTaskRequest>
        Model::DeleteWirelessDeviceImportTaskOutcomeCallable DeleteWirelessDeviceImportTaskCallable(const DeleteWirelessDeviceImportTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteWirelessDeviceImportTask, request);
        }
 
        template<typename DeleteWirelessDeviceImportTaskRequestT = Model::DeleteWirelessDeviceImportTaskRequest>
        void DeleteWirelessDeviceImportTaskAsync(const DeleteWirelessDeviceImportTaskRequestT& request, const DeleteWirelessDeviceImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteWirelessDeviceImportTask, request, handler, context);
        }
 
        virtual Model::DeleteWirelessGatewayOutcome DeleteWirelessGateway(const Model::DeleteWirelessGatewayRequest& request) const;
 
        template<typename DeleteWirelessGatewayRequestT = Model::DeleteWirelessGatewayRequest>
        Model::DeleteWirelessGatewayOutcomeCallable DeleteWirelessGatewayCallable(const DeleteWirelessGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteWirelessGateway, request);
        }
 
        template<typename DeleteWirelessGatewayRequestT = Model::DeleteWirelessGatewayRequest>
        void DeleteWirelessGatewayAsync(const DeleteWirelessGatewayRequestT& request, const DeleteWirelessGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteWirelessGateway, request, handler, context);
        }
 
        virtual Model::DeleteWirelessGatewayTaskOutcome DeleteWirelessGatewayTask(const Model::DeleteWirelessGatewayTaskRequest& request) const;
 
        template<typename DeleteWirelessGatewayTaskRequestT = Model::DeleteWirelessGatewayTaskRequest>
        Model::DeleteWirelessGatewayTaskOutcomeCallable DeleteWirelessGatewayTaskCallable(const DeleteWirelessGatewayTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteWirelessGatewayTask, request);
        }
 
        template<typename DeleteWirelessGatewayTaskRequestT = Model::DeleteWirelessGatewayTaskRequest>
        void DeleteWirelessGatewayTaskAsync(const DeleteWirelessGatewayTaskRequestT& request, const DeleteWirelessGatewayTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteWirelessGatewayTask, request, handler, context);
        }
 
        virtual Model::DeleteWirelessGatewayTaskDefinitionOutcome DeleteWirelessGatewayTaskDefinition(const Model::DeleteWirelessGatewayTaskDefinitionRequest& request) const;
 
        template<typename DeleteWirelessGatewayTaskDefinitionRequestT = Model::DeleteWirelessGatewayTaskDefinitionRequest>
        Model::DeleteWirelessGatewayTaskDefinitionOutcomeCallable DeleteWirelessGatewayTaskDefinitionCallable(const DeleteWirelessGatewayTaskDefinitionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeleteWirelessGatewayTaskDefinition, request);
        }
 
        template<typename DeleteWirelessGatewayTaskDefinitionRequestT = Model::DeleteWirelessGatewayTaskDefinitionRequest>
        void DeleteWirelessGatewayTaskDefinitionAsync(const DeleteWirelessGatewayTaskDefinitionRequestT& request, const DeleteWirelessGatewayTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeleteWirelessGatewayTaskDefinition, request, handler, context);
        }
 
        virtual Model::DeregisterWirelessDeviceOutcome DeregisterWirelessDevice(const Model::DeregisterWirelessDeviceRequest& request) const;
 
        template<typename DeregisterWirelessDeviceRequestT = Model::DeregisterWirelessDeviceRequest>
        Model::DeregisterWirelessDeviceOutcomeCallable DeregisterWirelessDeviceCallable(const DeregisterWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DeregisterWirelessDevice, request);
        }
 
        template<typename DeregisterWirelessDeviceRequestT = Model::DeregisterWirelessDeviceRequest>
        void DeregisterWirelessDeviceAsync(const DeregisterWirelessDeviceRequestT& request, const DeregisterWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DeregisterWirelessDevice, request, handler, context);
        }
 
        virtual Model::DisassociateAwsAccountFromPartnerAccountOutcome DisassociateAwsAccountFromPartnerAccount(const Model::DisassociateAwsAccountFromPartnerAccountRequest& request) const;
 
        template<typename DisassociateAwsAccountFromPartnerAccountRequestT = Model::DisassociateAwsAccountFromPartnerAccountRequest>
        Model::DisassociateAwsAccountFromPartnerAccountOutcomeCallable DisassociateAwsAccountFromPartnerAccountCallable(const DisassociateAwsAccountFromPartnerAccountRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateAwsAccountFromPartnerAccount, request);
        }
 
        template<typename DisassociateAwsAccountFromPartnerAccountRequestT = Model::DisassociateAwsAccountFromPartnerAccountRequest>
        void DisassociateAwsAccountFromPartnerAccountAsync(const DisassociateAwsAccountFromPartnerAccountRequestT& request, const DisassociateAwsAccountFromPartnerAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateAwsAccountFromPartnerAccount, request, handler, context);
        }
 
        virtual Model::DisassociateMulticastGroupFromFuotaTaskOutcome DisassociateMulticastGroupFromFuotaTask(const Model::DisassociateMulticastGroupFromFuotaTaskRequest& request) const;
 
        template<typename DisassociateMulticastGroupFromFuotaTaskRequestT = Model::DisassociateMulticastGroupFromFuotaTaskRequest>
        Model::DisassociateMulticastGroupFromFuotaTaskOutcomeCallable DisassociateMulticastGroupFromFuotaTaskCallable(const DisassociateMulticastGroupFromFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateMulticastGroupFromFuotaTask, request);
        }
 
        template<typename DisassociateMulticastGroupFromFuotaTaskRequestT = Model::DisassociateMulticastGroupFromFuotaTaskRequest>
        void DisassociateMulticastGroupFromFuotaTaskAsync(const DisassociateMulticastGroupFromFuotaTaskRequestT& request, const DisassociateMulticastGroupFromFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateMulticastGroupFromFuotaTask, request, handler, context);
        }
 
        virtual Model::DisassociateWirelessDeviceFromFuotaTaskOutcome DisassociateWirelessDeviceFromFuotaTask(const Model::DisassociateWirelessDeviceFromFuotaTaskRequest& request) const;
 
        template<typename DisassociateWirelessDeviceFromFuotaTaskRequestT = Model::DisassociateWirelessDeviceFromFuotaTaskRequest>
        Model::DisassociateWirelessDeviceFromFuotaTaskOutcomeCallable DisassociateWirelessDeviceFromFuotaTaskCallable(const DisassociateWirelessDeviceFromFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateWirelessDeviceFromFuotaTask, request);
        }
 
        template<typename DisassociateWirelessDeviceFromFuotaTaskRequestT = Model::DisassociateWirelessDeviceFromFuotaTaskRequest>
        void DisassociateWirelessDeviceFromFuotaTaskAsync(const DisassociateWirelessDeviceFromFuotaTaskRequestT& request, const DisassociateWirelessDeviceFromFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateWirelessDeviceFromFuotaTask, request, handler, context);
        }
 
        virtual Model::DisassociateWirelessDeviceFromMulticastGroupOutcome DisassociateWirelessDeviceFromMulticastGroup(const Model::DisassociateWirelessDeviceFromMulticastGroupRequest& request) const;
 
        template<typename DisassociateWirelessDeviceFromMulticastGroupRequestT = Model::DisassociateWirelessDeviceFromMulticastGroupRequest>
        Model::DisassociateWirelessDeviceFromMulticastGroupOutcomeCallable DisassociateWirelessDeviceFromMulticastGroupCallable(const DisassociateWirelessDeviceFromMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateWirelessDeviceFromMulticastGroup, request);
        }
 
        template<typename DisassociateWirelessDeviceFromMulticastGroupRequestT = Model::DisassociateWirelessDeviceFromMulticastGroupRequest>
        void DisassociateWirelessDeviceFromMulticastGroupAsync(const DisassociateWirelessDeviceFromMulticastGroupRequestT& request, const DisassociateWirelessDeviceFromMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateWirelessDeviceFromMulticastGroup, request, handler, context);
        }
 
        virtual Model::DisassociateWirelessDeviceFromThingOutcome DisassociateWirelessDeviceFromThing(const Model::DisassociateWirelessDeviceFromThingRequest& request) const;
 
        template<typename DisassociateWirelessDeviceFromThingRequestT = Model::DisassociateWirelessDeviceFromThingRequest>
        Model::DisassociateWirelessDeviceFromThingOutcomeCallable DisassociateWirelessDeviceFromThingCallable(const DisassociateWirelessDeviceFromThingRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateWirelessDeviceFromThing, request);
        }
 
        template<typename DisassociateWirelessDeviceFromThingRequestT = Model::DisassociateWirelessDeviceFromThingRequest>
        void DisassociateWirelessDeviceFromThingAsync(const DisassociateWirelessDeviceFromThingRequestT& request, const DisassociateWirelessDeviceFromThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateWirelessDeviceFromThing, request, handler, context);
        }
 
        virtual Model::DisassociateWirelessGatewayFromCertificateOutcome DisassociateWirelessGatewayFromCertificate(const Model::DisassociateWirelessGatewayFromCertificateRequest& request) const;
 
        template<typename DisassociateWirelessGatewayFromCertificateRequestT = Model::DisassociateWirelessGatewayFromCertificateRequest>
        Model::DisassociateWirelessGatewayFromCertificateOutcomeCallable DisassociateWirelessGatewayFromCertificateCallable(const DisassociateWirelessGatewayFromCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateWirelessGatewayFromCertificate, request);
        }
 
        template<typename DisassociateWirelessGatewayFromCertificateRequestT = Model::DisassociateWirelessGatewayFromCertificateRequest>
        void DisassociateWirelessGatewayFromCertificateAsync(const DisassociateWirelessGatewayFromCertificateRequestT& request, const DisassociateWirelessGatewayFromCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateWirelessGatewayFromCertificate, request, handler, context);
        }
 
        virtual Model::DisassociateWirelessGatewayFromThingOutcome DisassociateWirelessGatewayFromThing(const Model::DisassociateWirelessGatewayFromThingRequest& request) const;
 
        template<typename DisassociateWirelessGatewayFromThingRequestT = Model::DisassociateWirelessGatewayFromThingRequest>
        Model::DisassociateWirelessGatewayFromThingOutcomeCallable DisassociateWirelessGatewayFromThingCallable(const DisassociateWirelessGatewayFromThingRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::DisassociateWirelessGatewayFromThing, request);
        }
 
        template<typename DisassociateWirelessGatewayFromThingRequestT = Model::DisassociateWirelessGatewayFromThingRequest>
        void DisassociateWirelessGatewayFromThingAsync(const DisassociateWirelessGatewayFromThingRequestT& request, const DisassociateWirelessGatewayFromThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::DisassociateWirelessGatewayFromThing, request, handler, context);
        }
 
        virtual Model::GetDestinationOutcome GetDestination(const Model::GetDestinationRequest& request) const;
 
        template<typename GetDestinationRequestT = Model::GetDestinationRequest>
        Model::GetDestinationOutcomeCallable GetDestinationCallable(const GetDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetDestination, request);
        }
 
        template<typename GetDestinationRequestT = Model::GetDestinationRequest>
        void GetDestinationAsync(const GetDestinationRequestT& request, const GetDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetDestination, request, handler, context);
        }
 
        virtual Model::GetDeviceProfileOutcome GetDeviceProfile(const Model::GetDeviceProfileRequest& request) const;
 
        template<typename GetDeviceProfileRequestT = Model::GetDeviceProfileRequest>
        Model::GetDeviceProfileOutcomeCallable GetDeviceProfileCallable(const GetDeviceProfileRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetDeviceProfile, request);
        }
 
        template<typename GetDeviceProfileRequestT = Model::GetDeviceProfileRequest>
        void GetDeviceProfileAsync(const GetDeviceProfileRequestT& request, const GetDeviceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetDeviceProfile, request, handler, context);
        }
 
        virtual Model::GetEventConfigurationByResourceTypesOutcome GetEventConfigurationByResourceTypes(const Model::GetEventConfigurationByResourceTypesRequest& request = {}) const;
 
        template<typename GetEventConfigurationByResourceTypesRequestT = Model::GetEventConfigurationByResourceTypesRequest>
        Model::GetEventConfigurationByResourceTypesOutcomeCallable GetEventConfigurationByResourceTypesCallable(const GetEventConfigurationByResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::GetEventConfigurationByResourceTypes, request);
        }
 
        template<typename GetEventConfigurationByResourceTypesRequestT = Model::GetEventConfigurationByResourceTypesRequest>
        void GetEventConfigurationByResourceTypesAsync(const GetEventConfigurationByResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetEventConfigurationByResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::GetEventConfigurationByResourceTypes, request, handler, context);
        }
 
        virtual Model::GetFuotaTaskOutcome GetFuotaTask(const Model::GetFuotaTaskRequest& request) const;
 
        template<typename GetFuotaTaskRequestT = Model::GetFuotaTaskRequest>
        Model::GetFuotaTaskOutcomeCallable GetFuotaTaskCallable(const GetFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetFuotaTask, request);
        }
 
        template<typename GetFuotaTaskRequestT = Model::GetFuotaTaskRequest>
        void GetFuotaTaskAsync(const GetFuotaTaskRequestT& request, const GetFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetFuotaTask, request, handler, context);
        }
 
        virtual Model::GetLogLevelsByResourceTypesOutcome GetLogLevelsByResourceTypes(const Model::GetLogLevelsByResourceTypesRequest& request = {}) const;
 
        template<typename GetLogLevelsByResourceTypesRequestT = Model::GetLogLevelsByResourceTypesRequest>
        Model::GetLogLevelsByResourceTypesOutcomeCallable GetLogLevelsByResourceTypesCallable(const GetLogLevelsByResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::GetLogLevelsByResourceTypes, request);
        }
 
        template<typename GetLogLevelsByResourceTypesRequestT = Model::GetLogLevelsByResourceTypesRequest>
        void GetLogLevelsByResourceTypesAsync(const GetLogLevelsByResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetLogLevelsByResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::GetLogLevelsByResourceTypes, request, handler, context);
        }
 
        virtual Model::GetMetricConfigurationOutcome GetMetricConfiguration(const Model::GetMetricConfigurationRequest& request = {}) const;
 
        template<typename GetMetricConfigurationRequestT = Model::GetMetricConfigurationRequest>
        Model::GetMetricConfigurationOutcomeCallable GetMetricConfigurationCallable(const GetMetricConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::GetMetricConfiguration, request);
        }
 
        template<typename GetMetricConfigurationRequestT = Model::GetMetricConfigurationRequest>
        void GetMetricConfigurationAsync(const GetMetricConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetMetricConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::GetMetricConfiguration, request, handler, context);
        }
 
        virtual Model::GetMetricsOutcome GetMetrics(const Model::GetMetricsRequest& request = {}) const;
 
        template<typename GetMetricsRequestT = Model::GetMetricsRequest>
        Model::GetMetricsOutcomeCallable GetMetricsCallable(const GetMetricsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::GetMetrics, request);
        }
 
        template<typename GetMetricsRequestT = Model::GetMetricsRequest>
        void GetMetricsAsync(const GetMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetMetricsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::GetMetrics, request, handler, context);
        }
 
        virtual Model::GetMulticastGroupOutcome GetMulticastGroup(const Model::GetMulticastGroupRequest& request) const;
 
        template<typename GetMulticastGroupRequestT = Model::GetMulticastGroupRequest>
        Model::GetMulticastGroupOutcomeCallable GetMulticastGroupCallable(const GetMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetMulticastGroup, request);
        }
 
        template<typename GetMulticastGroupRequestT = Model::GetMulticastGroupRequest>
        void GetMulticastGroupAsync(const GetMulticastGroupRequestT& request, const GetMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetMulticastGroup, request, handler, context);
        }
 
        virtual Model::GetMulticastGroupSessionOutcome GetMulticastGroupSession(const Model::GetMulticastGroupSessionRequest& request) const;
 
        template<typename GetMulticastGroupSessionRequestT = Model::GetMulticastGroupSessionRequest>
        Model::GetMulticastGroupSessionOutcomeCallable GetMulticastGroupSessionCallable(const GetMulticastGroupSessionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetMulticastGroupSession, request);
        }
 
        template<typename GetMulticastGroupSessionRequestT = Model::GetMulticastGroupSessionRequest>
        void GetMulticastGroupSessionAsync(const GetMulticastGroupSessionRequestT& request, const GetMulticastGroupSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetMulticastGroupSession, request, handler, context);
        }
 
        virtual Model::GetNetworkAnalyzerConfigurationOutcome GetNetworkAnalyzerConfiguration(const Model::GetNetworkAnalyzerConfigurationRequest& request) const;
 
        template<typename GetNetworkAnalyzerConfigurationRequestT = Model::GetNetworkAnalyzerConfigurationRequest>
        Model::GetNetworkAnalyzerConfigurationOutcomeCallable GetNetworkAnalyzerConfigurationCallable(const GetNetworkAnalyzerConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetNetworkAnalyzerConfiguration, request);
        }
 
        template<typename GetNetworkAnalyzerConfigurationRequestT = Model::GetNetworkAnalyzerConfigurationRequest>
        void GetNetworkAnalyzerConfigurationAsync(const GetNetworkAnalyzerConfigurationRequestT& request, const GetNetworkAnalyzerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetNetworkAnalyzerConfiguration, request, handler, context);
        }
 
        virtual Model::GetPartnerAccountOutcome GetPartnerAccount(const Model::GetPartnerAccountRequest& request) const;
 
        template<typename GetPartnerAccountRequestT = Model::GetPartnerAccountRequest>
        Model::GetPartnerAccountOutcomeCallable GetPartnerAccountCallable(const GetPartnerAccountRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetPartnerAccount, request);
        }
 
        template<typename GetPartnerAccountRequestT = Model::GetPartnerAccountRequest>
        void GetPartnerAccountAsync(const GetPartnerAccountRequestT& request, const GetPartnerAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetPartnerAccount, request, handler, context);
        }
 
        virtual Model::GetPositionEstimateOutcome GetPositionEstimate(const Model::GetPositionEstimateRequest& request = {}) const;
 
        template<typename GetPositionEstimateRequestT = Model::GetPositionEstimateRequest>
        Model::GetPositionEstimateOutcomeCallable GetPositionEstimateCallable(const GetPositionEstimateRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::GetPositionEstimate, request);
        }
 
        template<typename GetPositionEstimateRequestT = Model::GetPositionEstimateRequest>
        void GetPositionEstimateAsync(const GetPositionEstimateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetPositionEstimateRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::GetPositionEstimate, request, handler, context);
        }
 
        virtual Model::GetResourceEventConfigurationOutcome GetResourceEventConfiguration(const Model::GetResourceEventConfigurationRequest& request) const;
 
        template<typename GetResourceEventConfigurationRequestT = Model::GetResourceEventConfigurationRequest>
        Model::GetResourceEventConfigurationOutcomeCallable GetResourceEventConfigurationCallable(const GetResourceEventConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetResourceEventConfiguration, request);
        }
 
        template<typename GetResourceEventConfigurationRequestT = Model::GetResourceEventConfigurationRequest>
        void GetResourceEventConfigurationAsync(const GetResourceEventConfigurationRequestT& request, const GetResourceEventConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetResourceEventConfiguration, request, handler, context);
        }
 
        virtual Model::GetResourceLogLevelOutcome GetResourceLogLevel(const Model::GetResourceLogLevelRequest& request) const;
 
        template<typename GetResourceLogLevelRequestT = Model::GetResourceLogLevelRequest>
        Model::GetResourceLogLevelOutcomeCallable GetResourceLogLevelCallable(const GetResourceLogLevelRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetResourceLogLevel, request);
        }
 
        template<typename GetResourceLogLevelRequestT = Model::GetResourceLogLevelRequest>
        void GetResourceLogLevelAsync(const GetResourceLogLevelRequestT& request, const GetResourceLogLevelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetResourceLogLevel, request, handler, context);
        }
 
        virtual Model::GetResourcePositionOutcome GetResourcePosition(const Model::GetResourcePositionRequest& request) const;
 
        template<typename GetResourcePositionRequestT = Model::GetResourcePositionRequest>
        Model::GetResourcePositionOutcomeCallable GetResourcePositionCallable(const GetResourcePositionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetResourcePosition, request);
        }
 
        template<typename GetResourcePositionRequestT = Model::GetResourcePositionRequest>
        void GetResourcePositionAsync(const GetResourcePositionRequestT& request, const GetResourcePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetResourcePosition, request, handler, context);
        }
 
        virtual Model::GetServiceEndpointOutcome GetServiceEndpoint(const Model::GetServiceEndpointRequest& request = {}) const;
 
        template<typename GetServiceEndpointRequestT = Model::GetServiceEndpointRequest>
        Model::GetServiceEndpointOutcomeCallable GetServiceEndpointCallable(const GetServiceEndpointRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::GetServiceEndpoint, request);
        }
 
        template<typename GetServiceEndpointRequestT = Model::GetServiceEndpointRequest>
        void GetServiceEndpointAsync(const GetServiceEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetServiceEndpointRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::GetServiceEndpoint, request, handler, context);
        }
 
        virtual Model::GetServiceProfileOutcome GetServiceProfile(const Model::GetServiceProfileRequest& request) const;
 
        template<typename GetServiceProfileRequestT = Model::GetServiceProfileRequest>
        Model::GetServiceProfileOutcomeCallable GetServiceProfileCallable(const GetServiceProfileRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetServiceProfile, request);
        }
 
        template<typename GetServiceProfileRequestT = Model::GetServiceProfileRequest>
        void GetServiceProfileAsync(const GetServiceProfileRequestT& request, const GetServiceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetServiceProfile, request, handler, context);
        }
 
        virtual Model::GetWirelessDeviceOutcome GetWirelessDevice(const Model::GetWirelessDeviceRequest& request) const;
 
        template<typename GetWirelessDeviceRequestT = Model::GetWirelessDeviceRequest>
        Model::GetWirelessDeviceOutcomeCallable GetWirelessDeviceCallable(const GetWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessDevice, request);
        }
 
        template<typename GetWirelessDeviceRequestT = Model::GetWirelessDeviceRequest>
        void GetWirelessDeviceAsync(const GetWirelessDeviceRequestT& request, const GetWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessDevice, request, handler, context);
        }
 
        virtual Model::GetWirelessDeviceImportTaskOutcome GetWirelessDeviceImportTask(const Model::GetWirelessDeviceImportTaskRequest& request) const;
 
        template<typename GetWirelessDeviceImportTaskRequestT = Model::GetWirelessDeviceImportTaskRequest>
        Model::GetWirelessDeviceImportTaskOutcomeCallable GetWirelessDeviceImportTaskCallable(const GetWirelessDeviceImportTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessDeviceImportTask, request);
        }
 
        template<typename GetWirelessDeviceImportTaskRequestT = Model::GetWirelessDeviceImportTaskRequest>
        void GetWirelessDeviceImportTaskAsync(const GetWirelessDeviceImportTaskRequestT& request, const GetWirelessDeviceImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessDeviceImportTask, request, handler, context);
        }
 
        virtual Model::GetWirelessDeviceStatisticsOutcome GetWirelessDeviceStatistics(const Model::GetWirelessDeviceStatisticsRequest& request) const;
 
        template<typename GetWirelessDeviceStatisticsRequestT = Model::GetWirelessDeviceStatisticsRequest>
        Model::GetWirelessDeviceStatisticsOutcomeCallable GetWirelessDeviceStatisticsCallable(const GetWirelessDeviceStatisticsRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessDeviceStatistics, request);
        }
 
        template<typename GetWirelessDeviceStatisticsRequestT = Model::GetWirelessDeviceStatisticsRequest>
        void GetWirelessDeviceStatisticsAsync(const GetWirelessDeviceStatisticsRequestT& request, const GetWirelessDeviceStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessDeviceStatistics, request, handler, context);
        }
 
        virtual Model::GetWirelessGatewayOutcome GetWirelessGateway(const Model::GetWirelessGatewayRequest& request) const;
 
        template<typename GetWirelessGatewayRequestT = Model::GetWirelessGatewayRequest>
        Model::GetWirelessGatewayOutcomeCallable GetWirelessGatewayCallable(const GetWirelessGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessGateway, request);
        }
 
        template<typename GetWirelessGatewayRequestT = Model::GetWirelessGatewayRequest>
        void GetWirelessGatewayAsync(const GetWirelessGatewayRequestT& request, const GetWirelessGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessGateway, request, handler, context);
        }
 
        virtual Model::GetWirelessGatewayCertificateOutcome GetWirelessGatewayCertificate(const Model::GetWirelessGatewayCertificateRequest& request) const;
 
        template<typename GetWirelessGatewayCertificateRequestT = Model::GetWirelessGatewayCertificateRequest>
        Model::GetWirelessGatewayCertificateOutcomeCallable GetWirelessGatewayCertificateCallable(const GetWirelessGatewayCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayCertificate, request);
        }
 
        template<typename GetWirelessGatewayCertificateRequestT = Model::GetWirelessGatewayCertificateRequest>
        void GetWirelessGatewayCertificateAsync(const GetWirelessGatewayCertificateRequestT& request, const GetWirelessGatewayCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayCertificate, request, handler, context);
        }
 
        virtual Model::GetWirelessGatewayFirmwareInformationOutcome GetWirelessGatewayFirmwareInformation(const Model::GetWirelessGatewayFirmwareInformationRequest& request) const;
 
        template<typename GetWirelessGatewayFirmwareInformationRequestT = Model::GetWirelessGatewayFirmwareInformationRequest>
        Model::GetWirelessGatewayFirmwareInformationOutcomeCallable GetWirelessGatewayFirmwareInformationCallable(const GetWirelessGatewayFirmwareInformationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayFirmwareInformation, request);
        }
 
        template<typename GetWirelessGatewayFirmwareInformationRequestT = Model::GetWirelessGatewayFirmwareInformationRequest>
        void GetWirelessGatewayFirmwareInformationAsync(const GetWirelessGatewayFirmwareInformationRequestT& request, const GetWirelessGatewayFirmwareInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayFirmwareInformation, request, handler, context);
        }
 
        virtual Model::GetWirelessGatewayStatisticsOutcome GetWirelessGatewayStatistics(const Model::GetWirelessGatewayStatisticsRequest& request) const;
 
        template<typename GetWirelessGatewayStatisticsRequestT = Model::GetWirelessGatewayStatisticsRequest>
        Model::GetWirelessGatewayStatisticsOutcomeCallable GetWirelessGatewayStatisticsCallable(const GetWirelessGatewayStatisticsRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayStatistics, request);
        }
 
        template<typename GetWirelessGatewayStatisticsRequestT = Model::GetWirelessGatewayStatisticsRequest>
        void GetWirelessGatewayStatisticsAsync(const GetWirelessGatewayStatisticsRequestT& request, const GetWirelessGatewayStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayStatistics, request, handler, context);
        }
 
        virtual Model::GetWirelessGatewayTaskOutcome GetWirelessGatewayTask(const Model::GetWirelessGatewayTaskRequest& request) const;
 
        template<typename GetWirelessGatewayTaskRequestT = Model::GetWirelessGatewayTaskRequest>
        Model::GetWirelessGatewayTaskOutcomeCallable GetWirelessGatewayTaskCallable(const GetWirelessGatewayTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayTask, request);
        }
 
        template<typename GetWirelessGatewayTaskRequestT = Model::GetWirelessGatewayTaskRequest>
        void GetWirelessGatewayTaskAsync(const GetWirelessGatewayTaskRequestT& request, const GetWirelessGatewayTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayTask, request, handler, context);
        }
 
        virtual Model::GetWirelessGatewayTaskDefinitionOutcome GetWirelessGatewayTaskDefinition(const Model::GetWirelessGatewayTaskDefinitionRequest& request) const;
 
        template<typename GetWirelessGatewayTaskDefinitionRequestT = Model::GetWirelessGatewayTaskDefinitionRequest>
        Model::GetWirelessGatewayTaskDefinitionOutcomeCallable GetWirelessGatewayTaskDefinitionCallable(const GetWirelessGatewayTaskDefinitionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayTaskDefinition, request);
        }
 
        template<typename GetWirelessGatewayTaskDefinitionRequestT = Model::GetWirelessGatewayTaskDefinitionRequest>
        void GetWirelessGatewayTaskDefinitionAsync(const GetWirelessGatewayTaskDefinitionRequestT& request, const GetWirelessGatewayTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayTaskDefinition, request, handler, context);
        }
 
        virtual Model::ListDestinationsOutcome ListDestinations(const Model::ListDestinationsRequest& request = {}) const;
 
        template<typename ListDestinationsRequestT = Model::ListDestinationsRequest>
        Model::ListDestinationsOutcomeCallable ListDestinationsCallable(const ListDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListDestinations, request);
        }
 
        template<typename ListDestinationsRequestT = Model::ListDestinationsRequest>
        void ListDestinationsAsync(const ListDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListDestinations, request, handler, context);
        }
 
        virtual Model::ListDeviceProfilesOutcome ListDeviceProfiles(const Model::ListDeviceProfilesRequest& request = {}) const;
 
        template<typename ListDeviceProfilesRequestT = Model::ListDeviceProfilesRequest>
        Model::ListDeviceProfilesOutcomeCallable ListDeviceProfilesCallable(const ListDeviceProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListDeviceProfiles, request);
        }
 
        template<typename ListDeviceProfilesRequestT = Model::ListDeviceProfilesRequest>
        void ListDeviceProfilesAsync(const ListDeviceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeviceProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListDeviceProfiles, request, handler, context);
        }
 
        virtual Model::ListDevicesForWirelessDeviceImportTaskOutcome ListDevicesForWirelessDeviceImportTask(const Model::ListDevicesForWirelessDeviceImportTaskRequest& request) const;
 
        template<typename ListDevicesForWirelessDeviceImportTaskRequestT = Model::ListDevicesForWirelessDeviceImportTaskRequest>
        Model::ListDevicesForWirelessDeviceImportTaskOutcomeCallable ListDevicesForWirelessDeviceImportTaskCallable(const ListDevicesForWirelessDeviceImportTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::ListDevicesForWirelessDeviceImportTask, request);
        }
 
        template<typename ListDevicesForWirelessDeviceImportTaskRequestT = Model::ListDevicesForWirelessDeviceImportTaskRequest>
        void ListDevicesForWirelessDeviceImportTaskAsync(const ListDevicesForWirelessDeviceImportTaskRequestT& request, const ListDevicesForWirelessDeviceImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::ListDevicesForWirelessDeviceImportTask, request, handler, context);
        }
 
        virtual Model::ListEventConfigurationsOutcome ListEventConfigurations(const Model::ListEventConfigurationsRequest& request) const;
 
        template<typename ListEventConfigurationsRequestT = Model::ListEventConfigurationsRequest>
        Model::ListEventConfigurationsOutcomeCallable ListEventConfigurationsCallable(const ListEventConfigurationsRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::ListEventConfigurations, request);
        }
 
        template<typename ListEventConfigurationsRequestT = Model::ListEventConfigurationsRequest>
        void ListEventConfigurationsAsync(const ListEventConfigurationsRequestT& request, const ListEventConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::ListEventConfigurations, request, handler, context);
        }
 
        virtual Model::ListFuotaTasksOutcome ListFuotaTasks(const Model::ListFuotaTasksRequest& request = {}) const;
 
        template<typename ListFuotaTasksRequestT = Model::ListFuotaTasksRequest>
        Model::ListFuotaTasksOutcomeCallable ListFuotaTasksCallable(const ListFuotaTasksRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListFuotaTasks, request);
        }
 
        template<typename ListFuotaTasksRequestT = Model::ListFuotaTasksRequest>
        void ListFuotaTasksAsync(const ListFuotaTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFuotaTasksRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListFuotaTasks, request, handler, context);
        }
 
        virtual Model::ListMulticastGroupsOutcome ListMulticastGroups(const Model::ListMulticastGroupsRequest& request = {}) const;
 
        template<typename ListMulticastGroupsRequestT = Model::ListMulticastGroupsRequest>
        Model::ListMulticastGroupsOutcomeCallable ListMulticastGroupsCallable(const ListMulticastGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListMulticastGroups, request);
        }
 
        template<typename ListMulticastGroupsRequestT = Model::ListMulticastGroupsRequest>
        void ListMulticastGroupsAsync(const ListMulticastGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMulticastGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListMulticastGroups, request, handler, context);
        }
 
        virtual Model::ListMulticastGroupsByFuotaTaskOutcome ListMulticastGroupsByFuotaTask(const Model::ListMulticastGroupsByFuotaTaskRequest& request) const;
 
        template<typename ListMulticastGroupsByFuotaTaskRequestT = Model::ListMulticastGroupsByFuotaTaskRequest>
        Model::ListMulticastGroupsByFuotaTaskOutcomeCallable ListMulticastGroupsByFuotaTaskCallable(const ListMulticastGroupsByFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::ListMulticastGroupsByFuotaTask, request);
        }
 
        template<typename ListMulticastGroupsByFuotaTaskRequestT = Model::ListMulticastGroupsByFuotaTaskRequest>
        void ListMulticastGroupsByFuotaTaskAsync(const ListMulticastGroupsByFuotaTaskRequestT& request, const ListMulticastGroupsByFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::ListMulticastGroupsByFuotaTask, request, handler, context);
        }
 
        virtual Model::ListNetworkAnalyzerConfigurationsOutcome ListNetworkAnalyzerConfigurations(const Model::ListNetworkAnalyzerConfigurationsRequest& request = {}) const;
 
        template<typename ListNetworkAnalyzerConfigurationsRequestT = Model::ListNetworkAnalyzerConfigurationsRequest>
        Model::ListNetworkAnalyzerConfigurationsOutcomeCallable ListNetworkAnalyzerConfigurationsCallable(const ListNetworkAnalyzerConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListNetworkAnalyzerConfigurations, request);
        }
 
        template<typename ListNetworkAnalyzerConfigurationsRequestT = Model::ListNetworkAnalyzerConfigurationsRequest>
        void ListNetworkAnalyzerConfigurationsAsync(const ListNetworkAnalyzerConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNetworkAnalyzerConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListNetworkAnalyzerConfigurations, request, handler, context);
        }
 
        virtual Model::ListPartnerAccountsOutcome ListPartnerAccounts(const Model::ListPartnerAccountsRequest& request = {}) const;
 
        template<typename ListPartnerAccountsRequestT = Model::ListPartnerAccountsRequest>
        Model::ListPartnerAccountsOutcomeCallable ListPartnerAccountsCallable(const ListPartnerAccountsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListPartnerAccounts, request);
        }
 
        template<typename ListPartnerAccountsRequestT = Model::ListPartnerAccountsRequest>
        void ListPartnerAccountsAsync(const ListPartnerAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPartnerAccountsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListPartnerAccounts, request, handler, context);
        }
 
        virtual Model::ListQueuedMessagesOutcome ListQueuedMessages(const Model::ListQueuedMessagesRequest& request) const;
 
        template<typename ListQueuedMessagesRequestT = Model::ListQueuedMessagesRequest>
        Model::ListQueuedMessagesOutcomeCallable ListQueuedMessagesCallable(const ListQueuedMessagesRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::ListQueuedMessages, request);
        }
 
        template<typename ListQueuedMessagesRequestT = Model::ListQueuedMessagesRequest>
        void ListQueuedMessagesAsync(const ListQueuedMessagesRequestT& request, const ListQueuedMessagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::ListQueuedMessages, request, handler, context);
        }
 
        virtual Model::ListServiceProfilesOutcome ListServiceProfiles(const Model::ListServiceProfilesRequest& request = {}) const;
 
        template<typename ListServiceProfilesRequestT = Model::ListServiceProfilesRequest>
        Model::ListServiceProfilesOutcomeCallable ListServiceProfilesCallable(const ListServiceProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListServiceProfiles, request);
        }
 
        template<typename ListServiceProfilesRequestT = Model::ListServiceProfilesRequest>
        void ListServiceProfilesAsync(const ListServiceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListServiceProfiles, 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(&IoTWirelessClient::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(&IoTWirelessClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWirelessDeviceImportTasksOutcome ListWirelessDeviceImportTasks(const Model::ListWirelessDeviceImportTasksRequest& request = {}) const;
 
        template<typename ListWirelessDeviceImportTasksRequestT = Model::ListWirelessDeviceImportTasksRequest>
        Model::ListWirelessDeviceImportTasksOutcomeCallable ListWirelessDeviceImportTasksCallable(const ListWirelessDeviceImportTasksRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListWirelessDeviceImportTasks, request);
        }
 
        template<typename ListWirelessDeviceImportTasksRequestT = Model::ListWirelessDeviceImportTasksRequest>
        void ListWirelessDeviceImportTasksAsync(const ListWirelessDeviceImportTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWirelessDeviceImportTasksRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListWirelessDeviceImportTasks, request, handler, context);
        }
 
        virtual Model::ListWirelessDevicesOutcome ListWirelessDevices(const Model::ListWirelessDevicesRequest& request = {}) const;
 
        template<typename ListWirelessDevicesRequestT = Model::ListWirelessDevicesRequest>
        Model::ListWirelessDevicesOutcomeCallable ListWirelessDevicesCallable(const ListWirelessDevicesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListWirelessDevices, request);
        }
 
        template<typename ListWirelessDevicesRequestT = Model::ListWirelessDevicesRequest>
        void ListWirelessDevicesAsync(const ListWirelessDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWirelessDevicesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListWirelessDevices, request, handler, context);
        }
 
        virtual Model::ListWirelessGatewayTaskDefinitionsOutcome ListWirelessGatewayTaskDefinitions(const Model::ListWirelessGatewayTaskDefinitionsRequest& request = {}) const;
 
        template<typename ListWirelessGatewayTaskDefinitionsRequestT = Model::ListWirelessGatewayTaskDefinitionsRequest>
        Model::ListWirelessGatewayTaskDefinitionsOutcomeCallable ListWirelessGatewayTaskDefinitionsCallable(const ListWirelessGatewayTaskDefinitionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListWirelessGatewayTaskDefinitions, request);
        }
 
        template<typename ListWirelessGatewayTaskDefinitionsRequestT = Model::ListWirelessGatewayTaskDefinitionsRequest>
        void ListWirelessGatewayTaskDefinitionsAsync(const ListWirelessGatewayTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWirelessGatewayTaskDefinitionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListWirelessGatewayTaskDefinitions, request, handler, context);
        }
 
        virtual Model::ListWirelessGatewaysOutcome ListWirelessGateways(const Model::ListWirelessGatewaysRequest& request = {}) const;
 
        template<typename ListWirelessGatewaysRequestT = Model::ListWirelessGatewaysRequest>
        Model::ListWirelessGatewaysOutcomeCallable ListWirelessGatewaysCallable(const ListWirelessGatewaysRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ListWirelessGateways, request);
        }
 
        template<typename ListWirelessGatewaysRequestT = Model::ListWirelessGatewaysRequest>
        void ListWirelessGatewaysAsync(const ListWirelessGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWirelessGatewaysRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ListWirelessGateways, request, handler, context);
        }
 
        virtual Model::PutResourceLogLevelOutcome PutResourceLogLevel(const Model::PutResourceLogLevelRequest& request) const;
 
        template<typename PutResourceLogLevelRequestT = Model::PutResourceLogLevelRequest>
        Model::PutResourceLogLevelOutcomeCallable PutResourceLogLevelCallable(const PutResourceLogLevelRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::PutResourceLogLevel, request);
        }
 
        template<typename PutResourceLogLevelRequestT = Model::PutResourceLogLevelRequest>
        void PutResourceLogLevelAsync(const PutResourceLogLevelRequestT& request, const PutResourceLogLevelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::PutResourceLogLevel, request, handler, context);
        }
 
        virtual Model::ResetAllResourceLogLevelsOutcome ResetAllResourceLogLevels(const Model::ResetAllResourceLogLevelsRequest& request = {}) const;
 
        template<typename ResetAllResourceLogLevelsRequestT = Model::ResetAllResourceLogLevelsRequest>
        Model::ResetAllResourceLogLevelsOutcomeCallable ResetAllResourceLogLevelsCallable(const ResetAllResourceLogLevelsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::ResetAllResourceLogLevels, request);
        }
 
        template<typename ResetAllResourceLogLevelsRequestT = Model::ResetAllResourceLogLevelsRequest>
        void ResetAllResourceLogLevelsAsync(const ResetAllResourceLogLevelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ResetAllResourceLogLevelsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::ResetAllResourceLogLevels, request, handler, context);
        }
 
        virtual Model::ResetResourceLogLevelOutcome ResetResourceLogLevel(const Model::ResetResourceLogLevelRequest& request) const;
 
        template<typename ResetResourceLogLevelRequestT = Model::ResetResourceLogLevelRequest>
        Model::ResetResourceLogLevelOutcomeCallable ResetResourceLogLevelCallable(const ResetResourceLogLevelRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::ResetResourceLogLevel, request);
        }
 
        template<typename ResetResourceLogLevelRequestT = Model::ResetResourceLogLevelRequest>
        void ResetResourceLogLevelAsync(const ResetResourceLogLevelRequestT& request, const ResetResourceLogLevelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::ResetResourceLogLevel, request, handler, context);
        }
 
        virtual Model::SendDataToMulticastGroupOutcome SendDataToMulticastGroup(const Model::SendDataToMulticastGroupRequest& request) const;
 
        template<typename SendDataToMulticastGroupRequestT = Model::SendDataToMulticastGroupRequest>
        Model::SendDataToMulticastGroupOutcomeCallable SendDataToMulticastGroupCallable(const SendDataToMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::SendDataToMulticastGroup, request);
        }
 
        template<typename SendDataToMulticastGroupRequestT = Model::SendDataToMulticastGroupRequest>
        void SendDataToMulticastGroupAsync(const SendDataToMulticastGroupRequestT& request, const SendDataToMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::SendDataToMulticastGroup, request, handler, context);
        }
 
        virtual Model::SendDataToWirelessDeviceOutcome SendDataToWirelessDevice(const Model::SendDataToWirelessDeviceRequest& request) const;
 
        template<typename SendDataToWirelessDeviceRequestT = Model::SendDataToWirelessDeviceRequest>
        Model::SendDataToWirelessDeviceOutcomeCallable SendDataToWirelessDeviceCallable(const SendDataToWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::SendDataToWirelessDevice, request);
        }
 
        template<typename SendDataToWirelessDeviceRequestT = Model::SendDataToWirelessDeviceRequest>
        void SendDataToWirelessDeviceAsync(const SendDataToWirelessDeviceRequestT& request, const SendDataToWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::SendDataToWirelessDevice, request, handler, context);
        }
 
        virtual Model::StartBulkAssociateWirelessDeviceWithMulticastGroupOutcome StartBulkAssociateWirelessDeviceWithMulticastGroup(const Model::StartBulkAssociateWirelessDeviceWithMulticastGroupRequest& request) const;
 
        template<typename StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT = Model::StartBulkAssociateWirelessDeviceWithMulticastGroupRequest>
        Model::StartBulkAssociateWirelessDeviceWithMulticastGroupOutcomeCallable StartBulkAssociateWirelessDeviceWithMulticastGroupCallable(const StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::StartBulkAssociateWirelessDeviceWithMulticastGroup, request);
        }
 
        template<typename StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT = Model::StartBulkAssociateWirelessDeviceWithMulticastGroupRequest>
        void StartBulkAssociateWirelessDeviceWithMulticastGroupAsync(const StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT& request, const StartBulkAssociateWirelessDeviceWithMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::StartBulkAssociateWirelessDeviceWithMulticastGroup, request, handler, context);
        }
 
        virtual Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupOutcome StartBulkDisassociateWirelessDeviceFromMulticastGroup(const Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest& request) const;
 
        template<typename StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT = Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest>
        Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupOutcomeCallable StartBulkDisassociateWirelessDeviceFromMulticastGroupCallable(const StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::StartBulkDisassociateWirelessDeviceFromMulticastGroup, request);
        }
 
        template<typename StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT = Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest>
        void StartBulkDisassociateWirelessDeviceFromMulticastGroupAsync(const StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT& request, const StartBulkDisassociateWirelessDeviceFromMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::StartBulkDisassociateWirelessDeviceFromMulticastGroup, request, handler, context);
        }
 
        virtual Model::StartFuotaTaskOutcome StartFuotaTask(const Model::StartFuotaTaskRequest& request) const;
 
        template<typename StartFuotaTaskRequestT = Model::StartFuotaTaskRequest>
        Model::StartFuotaTaskOutcomeCallable StartFuotaTaskCallable(const StartFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::StartFuotaTask, request);
        }
 
        template<typename StartFuotaTaskRequestT = Model::StartFuotaTaskRequest>
        void StartFuotaTaskAsync(const StartFuotaTaskRequestT& request, const StartFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::StartFuotaTask, request, handler, context);
        }
 
        virtual Model::StartMulticastGroupSessionOutcome StartMulticastGroupSession(const Model::StartMulticastGroupSessionRequest& request) const;
 
        template<typename StartMulticastGroupSessionRequestT = Model::StartMulticastGroupSessionRequest>
        Model::StartMulticastGroupSessionOutcomeCallable StartMulticastGroupSessionCallable(const StartMulticastGroupSessionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::StartMulticastGroupSession, request);
        }
 
        template<typename StartMulticastGroupSessionRequestT = Model::StartMulticastGroupSessionRequest>
        void StartMulticastGroupSessionAsync(const StartMulticastGroupSessionRequestT& request, const StartMulticastGroupSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::StartMulticastGroupSession, request, handler, context);
        }
 
        virtual Model::StartSingleWirelessDeviceImportTaskOutcome StartSingleWirelessDeviceImportTask(const Model::StartSingleWirelessDeviceImportTaskRequest& request) const;
 
        template<typename StartSingleWirelessDeviceImportTaskRequestT = Model::StartSingleWirelessDeviceImportTaskRequest>
        Model::StartSingleWirelessDeviceImportTaskOutcomeCallable StartSingleWirelessDeviceImportTaskCallable(const StartSingleWirelessDeviceImportTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::StartSingleWirelessDeviceImportTask, request);
        }
 
        template<typename StartSingleWirelessDeviceImportTaskRequestT = Model::StartSingleWirelessDeviceImportTaskRequest>
        void StartSingleWirelessDeviceImportTaskAsync(const StartSingleWirelessDeviceImportTaskRequestT& request, const StartSingleWirelessDeviceImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::StartSingleWirelessDeviceImportTask, request, handler, context);
        }
 
        virtual Model::StartWirelessDeviceImportTaskOutcome StartWirelessDeviceImportTask(const Model::StartWirelessDeviceImportTaskRequest& request) const;
 
        template<typename StartWirelessDeviceImportTaskRequestT = Model::StartWirelessDeviceImportTaskRequest>
        Model::StartWirelessDeviceImportTaskOutcomeCallable StartWirelessDeviceImportTaskCallable(const StartWirelessDeviceImportTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::StartWirelessDeviceImportTask, request);
        }
 
        template<typename StartWirelessDeviceImportTaskRequestT = Model::StartWirelessDeviceImportTaskRequest>
        void StartWirelessDeviceImportTaskAsync(const StartWirelessDeviceImportTaskRequestT& request, const StartWirelessDeviceImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::StartWirelessDeviceImportTask, 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(&IoTWirelessClient::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(&IoTWirelessClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestWirelessDeviceOutcome TestWirelessDevice(const Model::TestWirelessDeviceRequest& request) const;
 
        template<typename TestWirelessDeviceRequestT = Model::TestWirelessDeviceRequest>
        Model::TestWirelessDeviceOutcomeCallable TestWirelessDeviceCallable(const TestWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::TestWirelessDevice, request);
        }
 
        template<typename TestWirelessDeviceRequestT = Model::TestWirelessDeviceRequest>
        void TestWirelessDeviceAsync(const TestWirelessDeviceRequestT& request, const TestWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::TestWirelessDevice, 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(&IoTWirelessClient::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(&IoTWirelessClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDestinationOutcome UpdateDestination(const Model::UpdateDestinationRequest& request) const;
 
        template<typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
        Model::UpdateDestinationOutcomeCallable UpdateDestinationCallable(const UpdateDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateDestination, request);
        }
 
        template<typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
        void UpdateDestinationAsync(const UpdateDestinationRequestT& request, const UpdateDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateDestination, request, handler, context);
        }
 
        virtual Model::UpdateEventConfigurationByResourceTypesOutcome UpdateEventConfigurationByResourceTypes(const Model::UpdateEventConfigurationByResourceTypesRequest& request = {}) const;
 
        template<typename UpdateEventConfigurationByResourceTypesRequestT = Model::UpdateEventConfigurationByResourceTypesRequest>
        Model::UpdateEventConfigurationByResourceTypesOutcomeCallable UpdateEventConfigurationByResourceTypesCallable(const UpdateEventConfigurationByResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateEventConfigurationByResourceTypes, request);
        }
 
        template<typename UpdateEventConfigurationByResourceTypesRequestT = Model::UpdateEventConfigurationByResourceTypesRequest>
        void UpdateEventConfigurationByResourceTypesAsync(const UpdateEventConfigurationByResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateEventConfigurationByResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateEventConfigurationByResourceTypes, request, handler, context);
        }
 
        virtual Model::UpdateFuotaTaskOutcome UpdateFuotaTask(const Model::UpdateFuotaTaskRequest& request) const;
 
        template<typename UpdateFuotaTaskRequestT = Model::UpdateFuotaTaskRequest>
        Model::UpdateFuotaTaskOutcomeCallable UpdateFuotaTaskCallable(const UpdateFuotaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateFuotaTask, request);
        }
 
        template<typename UpdateFuotaTaskRequestT = Model::UpdateFuotaTaskRequest>
        void UpdateFuotaTaskAsync(const UpdateFuotaTaskRequestT& request, const UpdateFuotaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateFuotaTask, request, handler, context);
        }
 
        virtual Model::UpdateLogLevelsByResourceTypesOutcome UpdateLogLevelsByResourceTypes(const Model::UpdateLogLevelsByResourceTypesRequest& request = {}) const;
 
        template<typename UpdateLogLevelsByResourceTypesRequestT = Model::UpdateLogLevelsByResourceTypesRequest>
        Model::UpdateLogLevelsByResourceTypesOutcomeCallable UpdateLogLevelsByResourceTypesCallable(const UpdateLogLevelsByResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateLogLevelsByResourceTypes, request);
        }
 
        template<typename UpdateLogLevelsByResourceTypesRequestT = Model::UpdateLogLevelsByResourceTypesRequest>
        void UpdateLogLevelsByResourceTypesAsync(const UpdateLogLevelsByResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateLogLevelsByResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateLogLevelsByResourceTypes, request, handler, context);
        }
 
        virtual Model::UpdateMetricConfigurationOutcome UpdateMetricConfiguration(const Model::UpdateMetricConfigurationRequest& request = {}) const;
 
        template<typename UpdateMetricConfigurationRequestT = Model::UpdateMetricConfigurationRequest>
        Model::UpdateMetricConfigurationOutcomeCallable UpdateMetricConfigurationCallable(const UpdateMetricConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateMetricConfiguration, request);
        }
 
        template<typename UpdateMetricConfigurationRequestT = Model::UpdateMetricConfigurationRequest>
        void UpdateMetricConfigurationAsync(const UpdateMetricConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateMetricConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateMetricConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateMulticastGroupOutcome UpdateMulticastGroup(const Model::UpdateMulticastGroupRequest& request) const;
 
        template<typename UpdateMulticastGroupRequestT = Model::UpdateMulticastGroupRequest>
        Model::UpdateMulticastGroupOutcomeCallable UpdateMulticastGroupCallable(const UpdateMulticastGroupRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateMulticastGroup, request);
        }
 
        template<typename UpdateMulticastGroupRequestT = Model::UpdateMulticastGroupRequest>
        void UpdateMulticastGroupAsync(const UpdateMulticastGroupRequestT& request, const UpdateMulticastGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateMulticastGroup, request, handler, context);
        }
 
        virtual Model::UpdateNetworkAnalyzerConfigurationOutcome UpdateNetworkAnalyzerConfiguration(const Model::UpdateNetworkAnalyzerConfigurationRequest& request) const;
 
        template<typename UpdateNetworkAnalyzerConfigurationRequestT = Model::UpdateNetworkAnalyzerConfigurationRequest>
        Model::UpdateNetworkAnalyzerConfigurationOutcomeCallable UpdateNetworkAnalyzerConfigurationCallable(const UpdateNetworkAnalyzerConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateNetworkAnalyzerConfiguration, request);
        }
 
        template<typename UpdateNetworkAnalyzerConfigurationRequestT = Model::UpdateNetworkAnalyzerConfigurationRequest>
        void UpdateNetworkAnalyzerConfigurationAsync(const UpdateNetworkAnalyzerConfigurationRequestT& request, const UpdateNetworkAnalyzerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateNetworkAnalyzerConfiguration, request, handler, context);
        }
 
        virtual Model::UpdatePartnerAccountOutcome UpdatePartnerAccount(const Model::UpdatePartnerAccountRequest& request) const;
 
        template<typename UpdatePartnerAccountRequestT = Model::UpdatePartnerAccountRequest>
        Model::UpdatePartnerAccountOutcomeCallable UpdatePartnerAccountCallable(const UpdatePartnerAccountRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdatePartnerAccount, request);
        }
 
        template<typename UpdatePartnerAccountRequestT = Model::UpdatePartnerAccountRequest>
        void UpdatePartnerAccountAsync(const UpdatePartnerAccountRequestT& request, const UpdatePartnerAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdatePartnerAccount, request, handler, context);
        }
 
        virtual Model::UpdateResourceEventConfigurationOutcome UpdateResourceEventConfiguration(const Model::UpdateResourceEventConfigurationRequest& request) const;
 
        template<typename UpdateResourceEventConfigurationRequestT = Model::UpdateResourceEventConfigurationRequest>
        Model::UpdateResourceEventConfigurationOutcomeCallable UpdateResourceEventConfigurationCallable(const UpdateResourceEventConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateResourceEventConfiguration, request);
        }
 
        template<typename UpdateResourceEventConfigurationRequestT = Model::UpdateResourceEventConfigurationRequest>
        void UpdateResourceEventConfigurationAsync(const UpdateResourceEventConfigurationRequestT& request, const UpdateResourceEventConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateResourceEventConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateResourcePositionOutcome UpdateResourcePosition(const Model::UpdateResourcePositionRequest& request) const;
 
        template<typename UpdateResourcePositionRequestT = Model::UpdateResourcePositionRequest>
        Model::UpdateResourcePositionOutcomeCallable UpdateResourcePositionCallable(const UpdateResourcePositionRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateResourcePosition, request);
        }
 
        template<typename UpdateResourcePositionRequestT = Model::UpdateResourcePositionRequest>
        void UpdateResourcePositionAsync(const UpdateResourcePositionRequestT& request, const UpdateResourcePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateResourcePosition, request, handler, context);
        }
 
        virtual Model::UpdateWirelessDeviceOutcome UpdateWirelessDevice(const Model::UpdateWirelessDeviceRequest& request) const;
 
        template<typename UpdateWirelessDeviceRequestT = Model::UpdateWirelessDeviceRequest>
        Model::UpdateWirelessDeviceOutcomeCallable UpdateWirelessDeviceCallable(const UpdateWirelessDeviceRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateWirelessDevice, request);
        }
 
        template<typename UpdateWirelessDeviceRequestT = Model::UpdateWirelessDeviceRequest>
        void UpdateWirelessDeviceAsync(const UpdateWirelessDeviceRequestT& request, const UpdateWirelessDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateWirelessDevice, request, handler, context);
        }
 
        virtual Model::UpdateWirelessDeviceImportTaskOutcome UpdateWirelessDeviceImportTask(const Model::UpdateWirelessDeviceImportTaskRequest& request) const;
 
        template<typename UpdateWirelessDeviceImportTaskRequestT = Model::UpdateWirelessDeviceImportTaskRequest>
        Model::UpdateWirelessDeviceImportTaskOutcomeCallable UpdateWirelessDeviceImportTaskCallable(const UpdateWirelessDeviceImportTaskRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateWirelessDeviceImportTask, request);
        }
 
        template<typename UpdateWirelessDeviceImportTaskRequestT = Model::UpdateWirelessDeviceImportTaskRequest>
        void UpdateWirelessDeviceImportTaskAsync(const UpdateWirelessDeviceImportTaskRequestT& request, const UpdateWirelessDeviceImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateWirelessDeviceImportTask, request, handler, context);
        }
 
        virtual Model::UpdateWirelessGatewayOutcome UpdateWirelessGateway(const Model::UpdateWirelessGatewayRequest& request) const;
 
        template<typename UpdateWirelessGatewayRequestT = Model::UpdateWirelessGatewayRequest>
        Model::UpdateWirelessGatewayOutcomeCallable UpdateWirelessGatewayCallable(const UpdateWirelessGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTWirelessClient::UpdateWirelessGateway, request);
        }
 
        template<typename UpdateWirelessGatewayRequestT = Model::UpdateWirelessGatewayRequest>
        void UpdateWirelessGatewayAsync(const UpdateWirelessGatewayRequestT& request, const UpdateWirelessGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTWirelessClient::UpdateWirelessGateway, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTWirelessEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTWirelessClient>;
      void init(const IoTWirelessClientConfiguration& clientConfiguration);
 
      IoTWirelessClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTWirelessEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTWireless
} // namespace Aws