sdksio-verizon-apis-sdk 1.5.0 → 1.5.1

data/lib/verizon/controllers/exclusions_controller.rb

@@ -6,10 +6,86 @@
 module Verizon
   # ExclusionsController
   class ExclusionsController < BaseController
+    # Get the consent settings for the entire account or device list in an
+    # account.
+    # @param [String] account_name Required parameter: The numeric name of the
+    # account.
+    # @param [String] device_id Optional parameter: The IMEI of the device being
+    # queried
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def devices_location_get_consent_async(account_name,
+                                           device_id: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/devicelocations/action/consents',
+                                     Server::DEVICE_LOCATION)
+                   .query_param(new_parameter(account_name, key: 'accountName'))
+                   .query_param(new_parameter(device_id, key: 'deviceId'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetAccountDeviceConsent.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Unexpected error.',
+                                 DeviceLocationResultException))
+        .execute
+    end
+
+    # Create a consent record to use location services as an asynchronous
+    # request.
+    # @param [AccountConsentCreate] body Optional parameter: Account details to
+    # create a consent record.
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def devices_location_give_consent_async(body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/devicelocations/action/consents',
+                                     Server::DEVICE_LOCATION)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConsentTransactionID.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Unexpected error.',
+                                 DeviceLocationResultException))
+        .execute
+    end
+
+    # Update the location services consent record for an entire account.
+    # @param [AccountConsentUpdate] body Optional parameter: Account details to
+    # update a consent record.
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def devices_location_update_consent(body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/devicelocations/action/consents',
+                                     Server::DEVICE_LOCATION)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConsentTransactionID.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Unexpected error.',
+                                 DeviceLocationResultException))
+        .execute
+    end
+
     # This consents endpoint sets a new exclusion list.
     # @param [ConsentRequest] body Required parameter: Request to update account
     # consent exclusion list.
-    # @return [DeviceLocationSuccessResult] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def exclude_devices(body)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
@@ -21,12 +97,12 @@ module Verizon
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(DeviceLocationSuccessResult.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                DeviceLocationResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DeviceLocationSuccessResult.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 DeviceLocationResultException))
         .execute
     end
 
@@ -36,7 +112,7 @@ module Verizon
     # account.
     # @param [String] device_list Required parameter: A list of the device IDs
     # to remove from the exclusion list.
-    # @return [DeviceLocationSuccessResult] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def remove_devices_from_exclusion_list(account_name,
                                            device_list)
       new_api_call_builder
@@ -48,40 +124,40 @@ module Verizon
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(DeviceLocationSuccessResult.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                DeviceLocationResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DeviceLocationSuccessResult.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 DeviceLocationResultException))
         .execute
     end
 
     # This consents endpoint retrieves a list of excluded devices in an account.
-    # @param [String] account Required parameter: Account identifier in
+    # @param [String] account_name Required parameter: Account identifier in
     # "##########-#####".
     # @param [String] start_index Required parameter: Zero-based number of the
     # first record to return.
-    # @return [DevicesConsentResult] response from the API call
-    def list_excluded_devices(account,
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def list_excluded_devices(account_name,
                               start_index)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/consents/{account}/index/{startIndex}',
+                                     '/consents/{accountName}/index/{startIndex}',
                                      Server::DEVICE_LOCATION)
-                   .template_param(new_parameter(account, key: 'account')
+                   .template_param(new_parameter(account_name, key: 'accountName')
                                     .should_encode(true))
                    .template_param(new_parameter(start_index, key: 'startIndex')
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(DevicesConsentResult.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                DeviceLocationResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DevicesConsentResult.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 DeviceLocationResultException))
         .execute
     end
   end

data/lib/verizon/controllers/firmware_v1_controller.rb

@@ -10,7 +10,7 @@ module Verizon
     # devices registered to that account.
     # @param [String] account Required parameter: Account identifier in
     # "##########-#####".
-    # @return [Array[Firmware]] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def list_available_firmware(account)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::GET,
@@ -21,20 +21,20 @@ module Verizon
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(Firmware.method(:from_hash))
-                   .is_api_response(true)
-                   .is_response_array(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV1ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Firmware.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV1ResultException))
         .execute
     end
 
     # Schedules a firmware upgrade for devices.
     # @param [FirmwareUpgradeRequest] body Required parameter: Details of the
     # firmware upgrade request.
-    # @return [FirmwareUpgrade] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def schedule_firmware_upgrade(body)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
@@ -46,61 +46,61 @@ module Verizon
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(FirmwareUpgrade.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV1ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(FirmwareUpgrade.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV1ResultException))
         .execute
     end
 
     # Returns information about a specified upgrade, include the target date of
     # the upgrade, the list of devices in the upgrade, and the status of the
     # upgrade for each device.
-    # @param [String] account Required parameter: Account identifier in
+    # @param [String] account_name Required parameter: Account identifier in
     # "##########-#####".
     # @param [String] upgrade_id Required parameter: The UUID of the upgrade,
     # returned by POST /upgrades when the upgrade was scheduled.
-    # @return [FirmwareUpgrade] response from the API call
-    def list_firmware_upgrade_details(account,
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def list_firmware_upgrade_details(account_name,
                                       upgrade_id)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/upgrades/{account}/upgrade/{upgradeId}',
+                                     '/upgrades/{accountName}/upgrade/{upgradeId}',
                                      Server::SOFTWARE_MANAGEMENT_V1)
-                   .template_param(new_parameter(account, key: 'account')
+                   .template_param(new_parameter(account_name, key: 'accountName')
                                     .should_encode(true))
                    .template_param(new_parameter(upgrade_id, key: 'upgradeId')
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(FirmwareUpgrade.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV1ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(FirmwareUpgrade.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV1ResultException))
         .execute
     end
 
     # Add or remove devices from a scheduled upgrade.
-    # @param [String] account Required parameter: Account identifier in
+    # @param [String] account_name Required parameter: Account identifier in
     # "##########-#####".
     # @param [String] upgrade_id Required parameter: The UUID of the upgrade,
     # returned by POST /upgrades when the upgrade was scheduled.
     # @param [FirmwareUpgradeChangeRequest] body Required parameter: List of
     # devices to add or remove.
-    # @return [FirmwareUpgradeChangeResult] response from the API call
-    def update_firmware_upgrade_devices(account,
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def update_firmware_upgrade_devices(account_name,
                                         upgrade_id,
                                         body)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::PUT,
-                                     '/upgrades/{account}/upgrade/{upgradeId}',
+                                     '/upgrades/{accountName}/upgrade/{upgradeId}',
                                      Server::SOFTWARE_MANAGEMENT_V1)
-                   .template_param(new_parameter(account, key: 'account')
+                   .template_param(new_parameter(account_name, key: 'accountName')
                                     .should_encode(true))
                    .template_param(new_parameter(upgrade_id, key: 'upgradeId')
                                     .should_encode(true))
@@ -110,40 +110,40 @@ module Verizon
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(FirmwareUpgradeChangeResult.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV1ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(FirmwareUpgradeChangeResult.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV1ResultException))
         .execute
     end
 
     # Cancel a scheduled firmware upgrade.
-    # @param [String] account Required parameter: Account identifier in
+    # @param [String] account_name Required parameter: Account identifier in
     # "##########-#####".
     # @param [String] upgrade_id Required parameter: The UUID of the scheduled
     # upgrade that you want to cancel.
-    # @return [FotaV1SuccessResult] response from the API call
-    def cancel_scheduled_firmware_upgrade(account,
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def cancel_scheduled_firmware_upgrade(account_name,
                                           upgrade_id)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::DELETE,
-                                     '/upgrades/{account}/upgrade/{upgradeId}',
+                                     '/upgrades/{accountName}/upgrade/{upgradeId}',
                                      Server::SOFTWARE_MANAGEMENT_V1)
-                   .template_param(new_parameter(account, key: 'account')
+                   .template_param(new_parameter(account_name, key: 'accountName')
                                     .should_encode(true))
                    .template_param(new_parameter(upgrade_id, key: 'upgradeId')
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(FotaV1SuccessResult.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV1ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(FotaV1SuccessResult.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV1ResultException))
         .execute
     end
   end

data/lib/verizon/controllers/firmware_v3_controller.rb

@@ -10,7 +10,7 @@ module Verizon
     # @param [String] acc Required parameter: Account identifier.
     # @param [FirmwareProtocolEnum] protocol Required parameter: Filter to
     # retrieve a specific protocol type used.
-    # @return [Array[FirmwarePackage]] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def list_available_firmware(acc,
                                 protocol)
       new_api_call_builder
@@ -23,13 +23,13 @@ module Verizon
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(FirmwarePackage.method(:from_hash))
-                   .is_api_response(true)
-                   .is_response_array(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV3ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(FirmwarePackage.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV3ResultException))
         .execute
     end
 
@@ -37,7 +37,7 @@ module Verizon
     # @param [String] acc Required parameter: Account identifier.
     # @param [FirmwareIMEI] body Required parameter: DeviceIds to get firmware
     # info synchronously.
-    # @return [DeviceFirmwareList] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def synchronize_device_firmware(acc,
                                     body)
       new_api_call_builder
@@ -52,19 +52,19 @@ module Verizon
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(DeviceFirmwareList.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV3ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DeviceFirmwareList.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV3ResultException))
         .execute
     end
 
     # Ask a device to report its firmware version asynchronously.
     # @param [String] acc Required parameter: Account identifier.
     # @param [String] device_id Required parameter: Device identifier.
-    # @return [DeviceFirmwareVersionUpdateResult] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def report_device_firmware(acc,
                                device_id)
       new_api_call_builder
@@ -78,12 +78,12 @@ module Verizon
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(DeviceFirmwareVersionUpdateResult.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Unexpected error.',
-                                FotaV3ResultException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DeviceFirmwareVersionUpdateResult.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Unexpected error.',
+                                 FotaV3ResultException))
         .execute
     end
   end

data/lib/verizon/controllers/fixed_wireless_qualification_controller.rb

@@ -10,7 +10,7 @@ module Verizon
     # types include: LTE, C-BAND and MMWAVE.
     # @param [GetWirelessCoverageRequestFWA] body Required parameter: Request
     # for network coverage details.
-    # @return [WNPRequestResponse] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def domestic4g_and_5g_fixed_wireless_qualification(body)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
@@ -22,12 +22,12 @@ module Verizon
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(WNPRequestResponse.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('default',
-                                'Error response',
-                                WNPRestErrorResponseException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WNPRequestResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 WNPRestErrorResponseException))
         .execute
     end
   end

data/lib/verizon/controllers/global_reporting_controller.rb

@@ -6,10 +6,10 @@
 module Verizon
   # GlobalReportingController
   class GlobalReportingController < BaseController
-    # Retreive the provisioning history of a specific device or devices.
+    # Retrieve the provisioning history of a specific device or devices.
     # @param [ESIMProvhistoryRequest] body Required parameter: Device
     # Provisioning History
-    # @return [ESIMRequestResponse] response from the API call
+    # @return [ApiResponse]  the complete http response with raw body and status code.
     def deviceprovhistory_using_post(body)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
@@ -21,74 +21,71 @@ module Verizon
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(ESIMRequestResponse.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Bad request',
-                                ESIMRestErrorResponseException)
-                   .local_error('401',
-                                'Unauthorized',
-                                ESIMRestErrorResponseException)
-                   .local_error('403',
-                                'Forbidden',
-                                ESIMRestErrorResponseException)
-                   .local_error('404',
-                                'Not Found / Does not exist',
-                                ESIMRestErrorResponseException)
-                   .local_error('406',
-                                'Format / Request Unacceptable',
-                                ESIMRestErrorResponseException)
-                   .local_error('429',
-                                'Too many requests',
-                                ESIMRestErrorResponseException)
-                   .local_error('default',
-                                'Error response',
-                                ESIMRestErrorResponseException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ESIMRequestResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad request',
+                                 ESIMRestErrorResponseException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 ESIMRestErrorResponseException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ESIMRestErrorResponseException)
+                    .local_error('404',
+                                 'Not Found / Does not exist',
+                                 ESIMRestErrorResponseException)
+                    .local_error('406',
+                                 'Format / Request Unacceptable',
+                                 ESIMRestErrorResponseException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 ESIMRestErrorResponseException)
+                    .local_error('default',
+                                 'Error response',
+                                 ESIMRestErrorResponseException))
         .execute
     end
 
-    # Get the status of a request made with the Device Actions.
-    # @param [String] accountname Required parameter: Example:
-    # @param [String] request_id Required parameter: Example:
-    # @return [ESIMStatusResponse] response from the API call
-    def requeststatususing_get(accountname,
-                               request_id)
+    # Retrieve a list of all devices associated with an account.
+    # @param [ESIMGlobalDeviceList] body Required parameter: Device List
+    # @return [ApiResponse]  the complete http response with raw body and status code.
+    def retrieve_global_list(body)
       new_api_call_builder
-        .request(new_request_builder(HttpMethodEnum::GET,
-                                     '/m2m/v2/accounts/{accountname}/requests/{requestID}/status',
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/m2m/v2/devices/actions/list',
                                      Server::THINGSPACE)
-                   .template_param(new_parameter(accountname, key: 'accountname')
-                                    .should_encode(true))
-                   .template_param(new_parameter(request_id, key: 'requestID')
-                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
                    .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(And.new('thingspace_oauth', 'VZ-M2M-Token')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(ESIMStatusResponse.method(:from_hash))
-                   .is_api_response(true)
-                   .local_error('400',
-                                'Bad request',
-                                ESIMRestErrorResponseException)
-                   .local_error('401',
-                                'Unauthorized',
-                                ESIMRestErrorResponseException)
-                   .local_error('403',
-                                'Forbidden',
-                                ESIMRestErrorResponseException)
-                   .local_error('404',
-                                'Not Found / Does not exist',
-                                ESIMRestErrorResponseException)
-                   .local_error('406',
-                                'Format / Request Unacceptable',
-                                ESIMRestErrorResponseException)
-                   .local_error('429',
-                                'Too many requests',
-                                ESIMRestErrorResponseException)
-                   .local_error('default',
-                                'Error response',
-                                ESIMRestErrorResponseException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ESIMRequestResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad request',
+                                 ESIMRestErrorResponseException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 ESIMRestErrorResponseException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ESIMRestErrorResponseException)
+                    .local_error('404',
+                                 'Not Found / Does not exist',
+                                 ESIMRestErrorResponseException)
+                    .local_error('406',
+                                 'Format / Request Unacceptable',
+                                 ESIMRestErrorResponseException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 ESIMRestErrorResponseException)
+                    .local_error('default',
+                                 'Error response',
+                                 ESIMRestErrorResponseException))
         .execute
     end
   end