Generated 2018-01-20 for Iot.

ChangeLog.txt

@@ -1,3 +1,8 @@
+2019-12-31 Version: v1.60.313
+- Generated 2018-01-20 for `Iot`.
+- Add OTA APIs, including GenerateOTAUploadURL, CreateOTAFirmware, etc.
+- Add UpdateProductFilterConfig interface, support setting product filter config.
+
 2019-12-31 Version: v1.60.312
 - Generated 2019-12-30 for `ocr`.
 - First version.

services/iot/batch_add_device_group_relations.go

@@ -105,7 +105,7 @@ func CreateBatchAddDeviceGroupRelationsRequest() (request *BatchAddDeviceGroupRe
 	request = &BatchAddDeviceGroupRelationsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchAddDeviceGroupRelations", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchAddDeviceGroupRelations", "iot", "openAPI")
 	return
 }
 

services/iot/batch_add_thing_topo.go

@@ -107,7 +107,7 @@ func CreateBatchAddThingTopoRequest() (request *BatchAddThingTopoRequest) {
 	request = &BatchAddThingTopoRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchAddThingTopo", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchAddThingTopo", "iot", "openAPI")
 	return
 }
 

services/iot/batch_bind_device_to_edge_instance_with_driver.go

@@ -96,7 +96,7 @@ func CreateBatchBindDeviceToEdgeInstanceWithDriverRequest() (request *BatchBindD
 	request = &BatchBindDeviceToEdgeInstanceWithDriverRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchBindDeviceToEdgeInstanceWithDriver", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchBindDeviceToEdgeInstanceWithDriver", "iot", "openAPI")
 	return
 }
 

services/iot/batch_check_device_names.go

@@ -96,7 +96,7 @@ func CreateBatchCheckDeviceNamesRequest() (request *BatchCheckDeviceNamesRequest
 	request = &BatchCheckDeviceNamesRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchCheckDeviceNames", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchCheckDeviceNames", "iot", "openAPI")
 	return
 }
 

services/iot/batch_clear_edge_instance_device_config.go

@@ -95,7 +95,7 @@ func CreateBatchClearEdgeInstanceDeviceConfigRequest() (request *BatchClearEdgeI
 	request = &BatchClearEdgeInstanceDeviceConfigRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchClearEdgeInstanceDeviceConfig", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchClearEdgeInstanceDeviceConfig", "iot", "openAPI")
 	return
 }
 

services/iot/batch_delete_device_group_relations.go

@@ -104,7 +104,7 @@ func CreateBatchDeleteDeviceGroupRelationsRequest() (request *BatchDeleteDeviceG
 	request = &BatchDeleteDeviceGroupRelationsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchDeleteDeviceGroupRelations", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchDeleteDeviceGroupRelations", "iot", "openAPI")
 	return
 }
 

services/iot/batch_get_device_driver.go

@@ -96,7 +96,7 @@ func CreateBatchGetDeviceDriverRequest() (request *BatchGetDeviceDriverRequest)
 	request = &BatchGetDeviceDriverRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetDeviceDriver", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetDeviceDriver", "iot", "openAPI")
 	return
 }
 

services/iot/batch_get_device_state.go

@@ -97,7 +97,7 @@ func CreateBatchGetDeviceStateRequest() (request *BatchGetDeviceStateRequest) {
 	request = &BatchGetDeviceStateRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetDeviceState", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetDeviceState", "iot", "openAPI")
 	return
 }
 

services/iot/batch_get_edge_instance_device_config.go

@@ -96,7 +96,7 @@ func CreateBatchGetEdgeInstanceDeviceConfigRequest() (request *BatchGetEdgeInsta
 	request = &BatchGetEdgeInstanceDeviceConfigRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetEdgeInstanceDeviceConfig", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetEdgeInstanceDeviceConfig", "iot", "openAPI")
 	return
 }
 

services/iot/batch_get_edge_instance_driver_configs.go

@@ -96,7 +96,7 @@ func CreateBatchGetEdgeInstanceDriverConfigsRequest() (request *BatchGetEdgeInst
 	request = &BatchGetEdgeInstanceDriverConfigsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetEdgeInstanceDriverConfigs", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchGetEdgeInstanceDriverConfigs", "iot", "openAPI")
 	return
 }
 

services/iot/batch_query_device_detail.go

@@ -96,7 +96,7 @@ func CreateBatchQueryDeviceDetailRequest() (request *BatchQueryDeviceDetailReque
 	request = &BatchQueryDeviceDetailRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchQueryDeviceDetail", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchQueryDeviceDetail", "iot", "openAPI")
 	return
 }
 

services/iot/batch_register_device.go

@@ -96,7 +96,7 @@ func CreateBatchRegisterDeviceRequest() (request *BatchRegisterDeviceRequest) {
 	request = &BatchRegisterDeviceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchRegisterDevice", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchRegisterDevice", "iot", "openAPI")
 	return
 }
 

services/iot/batch_register_device_with_apply_id.go

@@ -96,7 +96,7 @@ func CreateBatchRegisterDeviceWithApplyIdRequest() (request *BatchRegisterDevice
 	request = &BatchRegisterDeviceWithApplyIdRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchRegisterDeviceWithApplyId", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchRegisterDeviceWithApplyId", "iot", "openAPI")
 	return
 }
 

services/iot/batch_set_edge_instance_device_config.go

@@ -101,7 +101,7 @@ func CreateBatchSetEdgeInstanceDeviceConfigRequest() (request *BatchSetEdgeInsta
 	request = &BatchSetEdgeInstanceDeviceConfigRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchSetEdgeInstanceDeviceConfig", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchSetEdgeInstanceDeviceConfig", "iot", "openAPI")
 	return
 }
 

services/iot/batch_unbind_device_from_edge_instance.go

@@ -95,7 +95,7 @@ func CreateBatchUnbindDeviceFromEdgeInstanceRequest() (request *BatchUnbindDevic
 	request = &BatchUnbindDeviceFromEdgeInstanceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchUnbindDeviceFromEdgeInstance", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchUnbindDeviceFromEdgeInstance", "iot", "openAPI")
 	return
 }
 

services/iot/batch_update_device_nickname.go

@@ -102,7 +102,7 @@ func CreateBatchUpdateDeviceNicknameRequest() (request *BatchUpdateDeviceNicknam
 	request = &BatchUpdateDeviceNicknameRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BatchUpdateDeviceNickname", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BatchUpdateDeviceNickname", "iot", "openAPI")
 	return
 }
 

services/iot/bind_driver_to_edge_instance.go

@@ -97,7 +97,7 @@ func CreateBindDriverToEdgeInstanceRequest() (request *BindDriverToEdgeInstanceR
 	request = &BindDriverToEdgeInstanceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BindDriverToEdgeInstance", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BindDriverToEdgeInstance", "iot", "openAPI")
 	return
 }
 

services/iot/bind_gateway_to_edge_instance.go

@@ -97,7 +97,7 @@ func CreateBindGatewayToEdgeInstanceRequest() (request *BindGatewayToEdgeInstanc
 	request = &BindGatewayToEdgeInstanceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "BindGatewayToEdgeInstance", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "BindGatewayToEdgeInstance", "iot", "openAPI")
 	return
 }
 

services/iot/cancel_ota_strategy_by_job.go

@@ -0,0 +1,107 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CancelOTAStrategyByJob invokes the iot.CancelOTAStrategyByJob API synchronously
+// api document: https://help.aliyun.com/api/iot/cancelotastrategybyjob.html
+func (client *Client) CancelOTAStrategyByJob(request *CancelOTAStrategyByJobRequest) (response *CancelOTAStrategyByJobResponse, err error) {
+	response = CreateCancelOTAStrategyByJobResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CancelOTAStrategyByJobWithChan invokes the iot.CancelOTAStrategyByJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/cancelotastrategybyjob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CancelOTAStrategyByJobWithChan(request *CancelOTAStrategyByJobRequest) (<-chan *CancelOTAStrategyByJobResponse, <-chan error) {
+	responseChan := make(chan *CancelOTAStrategyByJobResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CancelOTAStrategyByJob(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CancelOTAStrategyByJobWithCallback invokes the iot.CancelOTAStrategyByJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/cancelotastrategybyjob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CancelOTAStrategyByJobWithCallback(request *CancelOTAStrategyByJobRequest, callback func(response *CancelOTAStrategyByJobResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CancelOTAStrategyByJobResponse
+		var err error
+		defer close(result)
+		response, err = client.CancelOTAStrategyByJob(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CancelOTAStrategyByJobRequest is the request struct for api CancelOTAStrategyByJob
+type CancelOTAStrategyByJobRequest struct {
+	*requests.RpcRequest
+	JobId         string `position:"Query" name:"JobId"`
+	IotInstanceId string `position:"Query" name:"IotInstanceId"`
+}
+
+// CancelOTAStrategyByJobResponse is the response struct for api CancelOTAStrategyByJob
+type CancelOTAStrategyByJobResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+}
+
+// CreateCancelOTAStrategyByJobRequest creates a request to invoke CancelOTAStrategyByJob API
+func CreateCancelOTAStrategyByJobRequest() (request *CancelOTAStrategyByJobRequest) {
+	request = &CancelOTAStrategyByJobRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CancelOTAStrategyByJob", "iot", "openAPI")
+	return
+}
+
+// CreateCancelOTAStrategyByJobResponse creates a response to parse from CancelOTAStrategyByJob response
+func CreateCancelOTAStrategyByJobResponse() (response *CancelOTAStrategyByJobResponse) {
+	response = &CancelOTAStrategyByJobResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/cancel_ota_task_by_device.go

@@ -0,0 +1,110 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CancelOTATaskByDevice invokes the iot.CancelOTATaskByDevice API synchronously
+// api document: https://help.aliyun.com/api/iot/cancelotataskbydevice.html
+func (client *Client) CancelOTATaskByDevice(request *CancelOTATaskByDeviceRequest) (response *CancelOTATaskByDeviceResponse, err error) {
+	response = CreateCancelOTATaskByDeviceResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CancelOTATaskByDeviceWithChan invokes the iot.CancelOTATaskByDevice API asynchronously
+// api document: https://help.aliyun.com/api/iot/cancelotataskbydevice.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CancelOTATaskByDeviceWithChan(request *CancelOTATaskByDeviceRequest) (<-chan *CancelOTATaskByDeviceResponse, <-chan error) {
+	responseChan := make(chan *CancelOTATaskByDeviceResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CancelOTATaskByDevice(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CancelOTATaskByDeviceWithCallback invokes the iot.CancelOTATaskByDevice API asynchronously
+// api document: https://help.aliyun.com/api/iot/cancelotataskbydevice.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CancelOTATaskByDeviceWithCallback(request *CancelOTATaskByDeviceRequest, callback func(response *CancelOTATaskByDeviceResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CancelOTATaskByDeviceResponse
+		var err error
+		defer close(result)
+		response, err = client.CancelOTATaskByDevice(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CancelOTATaskByDeviceRequest is the request struct for api CancelOTATaskByDevice
+type CancelOTATaskByDeviceRequest struct {
+	*requests.RpcRequest
+	FirmwareId    string    `position:"Query" name:"FirmwareId"`
+	ProductKey    string    `position:"Query" name:"ProductKey"`
+	JobId         string    `position:"Query" name:"JobId"`
+	IotInstanceId string    `position:"Query" name:"IotInstanceId"`
+	DeviceName    *[]string `position:"Query" name:"DeviceName"  type:"Repeated"`
+}
+
+// CancelOTATaskByDeviceResponse is the response struct for api CancelOTATaskByDevice
+type CancelOTATaskByDeviceResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+}
+
+// CreateCancelOTATaskByDeviceRequest creates a request to invoke CancelOTATaskByDevice API
+func CreateCancelOTATaskByDeviceRequest() (request *CancelOTATaskByDeviceRequest) {
+	request = &CancelOTATaskByDeviceRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CancelOTATaskByDevice", "iot", "openAPI")
+	return
+}
+
+// CreateCancelOTATaskByDeviceResponse creates a response to parse from CancelOTATaskByDevice response
+func CreateCancelOTATaskByDeviceResponse() (response *CancelOTATaskByDeviceResponse) {
+	response = &CancelOTATaskByDeviceResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/cancel_ota_task_by_job.go

@@ -0,0 +1,110 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CancelOTATaskByJob invokes the iot.CancelOTATaskByJob API synchronously
+// api document: https://help.aliyun.com/api/iot/cancelotataskbyjob.html
+func (client *Client) CancelOTATaskByJob(request *CancelOTATaskByJobRequest) (response *CancelOTATaskByJobResponse, err error) {
+	response = CreateCancelOTATaskByJobResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CancelOTATaskByJobWithChan invokes the iot.CancelOTATaskByJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/cancelotataskbyjob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CancelOTATaskByJobWithChan(request *CancelOTATaskByJobRequest) (<-chan *CancelOTATaskByJobResponse, <-chan error) {
+	responseChan := make(chan *CancelOTATaskByJobResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CancelOTATaskByJob(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CancelOTATaskByJobWithCallback invokes the iot.CancelOTATaskByJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/cancelotataskbyjob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CancelOTATaskByJobWithCallback(request *CancelOTATaskByJobRequest, callback func(response *CancelOTATaskByJobResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CancelOTATaskByJobResponse
+		var err error
+		defer close(result)
+		response, err = client.CancelOTATaskByJob(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CancelOTATaskByJobRequest is the request struct for api CancelOTATaskByJob
+type CancelOTATaskByJobRequest struct {
+	*requests.RpcRequest
+	CancelScheduledTask  requests.Boolean `position:"Query" name:"CancelScheduledTask"`
+	CancelInProgressTask requests.Boolean `position:"Query" name:"CancelInProgressTask"`
+	JobId                string           `position:"Query" name:"JobId"`
+	IotInstanceId        string           `position:"Query" name:"IotInstanceId"`
+	CancelQueuedTask     requests.Boolean `position:"Query" name:"CancelQueuedTask"`
+}
+
+// CancelOTATaskByJobResponse is the response struct for api CancelOTATaskByJob
+type CancelOTATaskByJobResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+}
+
+// CreateCancelOTATaskByJobRequest creates a request to invoke CancelOTATaskByJob API
+func CreateCancelOTATaskByJobRequest() (request *CancelOTATaskByJobRequest) {
+	request = &CancelOTATaskByJobRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CancelOTATaskByJob", "iot", "openAPI")
+	return
+}
+
+// CreateCancelOTATaskByJobResponse creates a response to parse from CancelOTATaskByJob response
+func CreateCancelOTATaskByJobResponse() (response *CancelOTATaskByJobResponse) {
+	response = &CancelOTATaskByJobResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/clear_edge_instance_driver_configs.go

@@ -95,7 +95,7 @@ func CreateClearEdgeInstanceDriverConfigsRequest() (request *ClearEdgeInstanceDr
 	request = &ClearEdgeInstanceDriverConfigsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "ClearEdgeInstanceDriverConfigs", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "ClearEdgeInstanceDriverConfigs", "iot", "openAPI")
 	return
 }
 

services/iot/close_edge_instance_deployment.go

@@ -94,7 +94,7 @@ func CreateCloseEdgeInstanceDeploymentRequest() (request *CloseEdgeInstanceDeplo
 	request = &CloseEdgeInstanceDeploymentRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CloseEdgeInstanceDeployment", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CloseEdgeInstanceDeployment", "iot", "openAPI")
 	return
 }
 

services/iot/create_data_api_service.go

@@ -119,7 +119,7 @@ func CreateCreateDataAPIServiceRequest() (request *CreateDataAPIServiceRequest)
 	request = &CreateDataAPIServiceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateDataAPIService", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateDataAPIService", "iot", "openAPI")
 	return
 }
 

services/iot/create_device_group.go

@@ -97,7 +97,7 @@ func CreateCreateDeviceGroupRequest() (request *CreateDeviceGroupRequest) {
 	request = &CreateDeviceGroupRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateDeviceGroup", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateDeviceGroup", "iot", "openAPI")
 	return
 }
 

services/iot/create_edge_instance.go

@@ -97,7 +97,7 @@ func CreateCreateEdgeInstanceRequest() (request *CreateEdgeInstanceRequest) {
 	request = &CreateEdgeInstanceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateEdgeInstance", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateEdgeInstance", "iot", "openAPI")
 	return
 }
 

services/iot/create_edge_instance_deployment.go

@@ -96,7 +96,7 @@ func CreateCreateEdgeInstanceDeploymentRequest() (request *CreateEdgeInstanceDep
 	request = &CreateEdgeInstanceDeploymentRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateEdgeInstanceDeployment", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateEdgeInstanceDeployment", "iot", "openAPI")
 	return
 }
 

services/iot/create_lo_ra_nodes_task.go

@@ -102,7 +102,7 @@ func CreateCreateLoRaNodesTaskRequest() (request *CreateLoRaNodesTaskRequest) {
 	request = &CreateLoRaNodesTaskRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateLoRaNodesTask", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateLoRaNodesTask", "iot", "openAPI")
 	return
 }
 

services/iot/create_ota_dynamic_upgrade_job.go

@@ -0,0 +1,114 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CreateOTADynamicUpgradeJob invokes the iot.CreateOTADynamicUpgradeJob API synchronously
+// api document: https://help.aliyun.com/api/iot/createotadynamicupgradejob.html
+func (client *Client) CreateOTADynamicUpgradeJob(request *CreateOTADynamicUpgradeJobRequest) (response *CreateOTADynamicUpgradeJobResponse, err error) {
+	response = CreateCreateOTADynamicUpgradeJobResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CreateOTADynamicUpgradeJobWithChan invokes the iot.CreateOTADynamicUpgradeJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotadynamicupgradejob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTADynamicUpgradeJobWithChan(request *CreateOTADynamicUpgradeJobRequest) (<-chan *CreateOTADynamicUpgradeJobResponse, <-chan error) {
+	responseChan := make(chan *CreateOTADynamicUpgradeJobResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CreateOTADynamicUpgradeJob(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CreateOTADynamicUpgradeJobWithCallback invokes the iot.CreateOTADynamicUpgradeJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotadynamicupgradejob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTADynamicUpgradeJobWithCallback(request *CreateOTADynamicUpgradeJobRequest, callback func(response *CreateOTADynamicUpgradeJobResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CreateOTADynamicUpgradeJobResponse
+		var err error
+		defer close(result)
+		response, err = client.CreateOTADynamicUpgradeJob(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CreateOTADynamicUpgradeJobRequest is the request struct for api CreateOTADynamicUpgradeJob
+type CreateOTADynamicUpgradeJobRequest struct {
+	*requests.RpcRequest
+	RetryCount       requests.Integer `position:"Query" name:"RetryCount"`
+	FirmwareId       string           `position:"Query" name:"FirmwareId"`
+	ProductKey       string           `position:"Query" name:"ProductKey"`
+	TimeoutInMinutes requests.Integer `position:"Query" name:"TimeoutInMinutes"`
+	RetryInterval    requests.Integer `position:"Query" name:"RetryInterval"`
+	SrcVersion       *[]string        `position:"Query" name:"SrcVersion"  type:"Repeated"`
+	IotInstanceId    string           `position:"Query" name:"IotInstanceId"`
+	MaximumPerMinute requests.Integer `position:"Query" name:"MaximumPerMinute"`
+}
+
+// CreateOTADynamicUpgradeJobResponse is the response struct for api CreateOTADynamicUpgradeJob
+type CreateOTADynamicUpgradeJobResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+	Data         Data   `json:"Data" xml:"Data"`
+}
+
+// CreateCreateOTADynamicUpgradeJobRequest creates a request to invoke CreateOTADynamicUpgradeJob API
+func CreateCreateOTADynamicUpgradeJobRequest() (request *CreateOTADynamicUpgradeJobRequest) {
+	request = &CreateOTADynamicUpgradeJobRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateOTADynamicUpgradeJob", "iot", "openAPI")
+	return
+}
+
+// CreateCreateOTADynamicUpgradeJobResponse creates a response to parse from CreateOTADynamicUpgradeJob response
+func CreateCreateOTADynamicUpgradeJobResponse() (response *CreateOTADynamicUpgradeJobResponse) {
+	response = &CreateOTADynamicUpgradeJobResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/create_ota_firmware.go

@@ -0,0 +1,117 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CreateOTAFirmware invokes the iot.CreateOTAFirmware API synchronously
+// api document: https://help.aliyun.com/api/iot/createotafirmware.html
+func (client *Client) CreateOTAFirmware(request *CreateOTAFirmwareRequest) (response *CreateOTAFirmwareResponse, err error) {
+	response = CreateCreateOTAFirmwareResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CreateOTAFirmwareWithChan invokes the iot.CreateOTAFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotafirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTAFirmwareWithChan(request *CreateOTAFirmwareRequest) (<-chan *CreateOTAFirmwareResponse, <-chan error) {
+	responseChan := make(chan *CreateOTAFirmwareResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CreateOTAFirmware(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CreateOTAFirmwareWithCallback invokes the iot.CreateOTAFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotafirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTAFirmwareWithCallback(request *CreateOTAFirmwareRequest, callback func(response *CreateOTAFirmwareResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CreateOTAFirmwareResponse
+		var err error
+		defer close(result)
+		response, err = client.CreateOTAFirmware(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CreateOTAFirmwareRequest is the request struct for api CreateOTAFirmware
+type CreateOTAFirmwareRequest struct {
+	*requests.RpcRequest
+	SignMethod    string           `position:"Query" name:"SignMethod"`
+	Type          requests.Integer `position:"Query" name:"Type"`
+	FirmwareUrl   string           `position:"Query" name:"FirmwareUrl"`
+	IotInstanceId string           `position:"Query" name:"IotInstanceId"`
+	FirmwareDesc  string           `position:"Query" name:"FirmwareDesc"`
+	FirmwareSign  string           `position:"Query" name:"FirmwareSign"`
+	FirmwareSize  requests.Integer `position:"Query" name:"FirmwareSize"`
+	FirmwareName  string           `position:"Query" name:"FirmwareName"`
+	ProductKey    string           `position:"Query" name:"ProductKey"`
+	SrcVersion    string           `position:"Query" name:"SrcVersion"`
+	DestVersion   string           `position:"Query" name:"DestVersion"`
+}
+
+// CreateOTAFirmwareResponse is the response struct for api CreateOTAFirmware
+type CreateOTAFirmwareResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+	Data         Data   `json:"Data" xml:"Data"`
+}
+
+// CreateCreateOTAFirmwareRequest creates a request to invoke CreateOTAFirmware API
+func CreateCreateOTAFirmwareRequest() (request *CreateOTAFirmwareRequest) {
+	request = &CreateOTAFirmwareRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateOTAFirmware", "iot", "openAPI")
+	return
+}
+
+// CreateCreateOTAFirmwareResponse creates a response to parse from CreateOTAFirmware response
+func CreateCreateOTAFirmwareResponse() (response *CreateOTAFirmwareResponse) {
+	response = &CreateOTAFirmwareResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/create_ota_static_upgrade_job.go

@@ -0,0 +1,118 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CreateOTAStaticUpgradeJob invokes the iot.CreateOTAStaticUpgradeJob API synchronously
+// api document: https://help.aliyun.com/api/iot/createotastaticupgradejob.html
+func (client *Client) CreateOTAStaticUpgradeJob(request *CreateOTAStaticUpgradeJobRequest) (response *CreateOTAStaticUpgradeJobResponse, err error) {
+	response = CreateCreateOTAStaticUpgradeJobResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CreateOTAStaticUpgradeJobWithChan invokes the iot.CreateOTAStaticUpgradeJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotastaticupgradejob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTAStaticUpgradeJobWithChan(request *CreateOTAStaticUpgradeJobRequest) (<-chan *CreateOTAStaticUpgradeJobResponse, <-chan error) {
+	responseChan := make(chan *CreateOTAStaticUpgradeJobResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CreateOTAStaticUpgradeJob(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CreateOTAStaticUpgradeJobWithCallback invokes the iot.CreateOTAStaticUpgradeJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotastaticupgradejob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTAStaticUpgradeJobWithCallback(request *CreateOTAStaticUpgradeJobRequest, callback func(response *CreateOTAStaticUpgradeJobResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CreateOTAStaticUpgradeJobResponse
+		var err error
+		defer close(result)
+		response, err = client.CreateOTAStaticUpgradeJob(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CreateOTAStaticUpgradeJobRequest is the request struct for api CreateOTAStaticUpgradeJob
+type CreateOTAStaticUpgradeJobRequest struct {
+	*requests.RpcRequest
+	RetryCount       requests.Integer `position:"Query" name:"RetryCount"`
+	TimeoutInMinutes requests.Integer `position:"Query" name:"TimeoutInMinutes"`
+	IotInstanceId    string           `position:"Query" name:"IotInstanceId"`
+	TargetSelection  string           `position:"Query" name:"TargetSelection"`
+	GrayPercent      string           `position:"Query" name:"GrayPercent"`
+	FirmwareId       string           `position:"Query" name:"FirmwareId"`
+	ProductKey       string           `position:"Query" name:"ProductKey"`
+	RetryInterval    requests.Integer `position:"Query" name:"RetryInterval"`
+	SrcVersion       *[]string        `position:"Query" name:"SrcVersion"  type:"Repeated"`
+	ScheduleTime     requests.Integer `position:"Query" name:"ScheduleTime"`
+	MaximumPerMinute requests.Integer `position:"Query" name:"MaximumPerMinute"`
+	TargetDeviceName *[]string        `position:"Query" name:"TargetDeviceName"  type:"Repeated"`
+}
+
+// CreateOTAStaticUpgradeJobResponse is the response struct for api CreateOTAStaticUpgradeJob
+type CreateOTAStaticUpgradeJobResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+	Data         Data   `json:"Data" xml:"Data"`
+}
+
+// CreateCreateOTAStaticUpgradeJobRequest creates a request to invoke CreateOTAStaticUpgradeJob API
+func CreateCreateOTAStaticUpgradeJobRequest() (request *CreateOTAStaticUpgradeJobRequest) {
+	request = &CreateOTAStaticUpgradeJobRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateOTAStaticUpgradeJob", "iot", "openAPI")
+	return
+}
+
+// CreateCreateOTAStaticUpgradeJobResponse creates a response to parse from CreateOTAStaticUpgradeJob response
+func CreateCreateOTAStaticUpgradeJobResponse() (response *CreateOTAStaticUpgradeJobResponse) {
+	response = &CreateOTAStaticUpgradeJobResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/create_ota_verify_job.go

@@ -0,0 +1,111 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CreateOTAVerifyJob invokes the iot.CreateOTAVerifyJob API synchronously
+// api document: https://help.aliyun.com/api/iot/createotaverifyjob.html
+func (client *Client) CreateOTAVerifyJob(request *CreateOTAVerifyJobRequest) (response *CreateOTAVerifyJobResponse, err error) {
+	response = CreateCreateOTAVerifyJobResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CreateOTAVerifyJobWithChan invokes the iot.CreateOTAVerifyJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotaverifyjob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTAVerifyJobWithChan(request *CreateOTAVerifyJobRequest) (<-chan *CreateOTAVerifyJobResponse, <-chan error) {
+	responseChan := make(chan *CreateOTAVerifyJobResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CreateOTAVerifyJob(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CreateOTAVerifyJobWithCallback invokes the iot.CreateOTAVerifyJob API asynchronously
+// api document: https://help.aliyun.com/api/iot/createotaverifyjob.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CreateOTAVerifyJobWithCallback(request *CreateOTAVerifyJobRequest, callback func(response *CreateOTAVerifyJobResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CreateOTAVerifyJobResponse
+		var err error
+		defer close(result)
+		response, err = client.CreateOTAVerifyJob(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CreateOTAVerifyJobRequest is the request struct for api CreateOTAVerifyJob
+type CreateOTAVerifyJobRequest struct {
+	*requests.RpcRequest
+	FirmwareId       string           `position:"Query" name:"FirmwareId"`
+	ProductKey       string           `position:"Query" name:"ProductKey"`
+	TimeoutInMinutes requests.Integer `position:"Query" name:"TimeoutInMinutes"`
+	IotInstanceId    string           `position:"Query" name:"IotInstanceId"`
+	TargetDeviceName *[]string        `position:"Query" name:"TargetDeviceName"  type:"Repeated"`
+}
+
+// CreateOTAVerifyJobResponse is the response struct for api CreateOTAVerifyJob
+type CreateOTAVerifyJobResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+	Data         Data   `json:"Data" xml:"Data"`
+}
+
+// CreateCreateOTAVerifyJobRequest creates a request to invoke CreateOTAVerifyJob API
+func CreateCreateOTAVerifyJobRequest() (request *CreateOTAVerifyJobRequest) {
+	request = &CreateOTAVerifyJobRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateOTAVerifyJob", "iot", "openAPI")
+	return
+}
+
+// CreateCreateOTAVerifyJobResponse creates a response to parse from CreateOTAVerifyJob response
+func CreateCreateOTAVerifyJobResponse() (response *CreateOTAVerifyJobResponse) {
+	response = &CreateOTAVerifyJobResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/create_product.go

@@ -107,7 +107,7 @@ func CreateCreateProductRequest() (request *CreateProductRequest) {
 	request = &CreateProductRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateProduct", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateProduct", "iot", "openAPI")
 	return
 }
 

services/iot/create_product_tags.go

@@ -102,7 +102,7 @@ func CreateCreateProductTagsRequest() (request *CreateProductTagsRequest) {
 	request = &CreateProductTagsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateProductTags", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateProductTags", "iot", "openAPI")
 	return
 }
 

services/iot/create_product_topic.go

@@ -98,7 +98,7 @@ func CreateCreateProductTopicRequest() (request *CreateProductTopicRequest) {
 	request = &CreateProductTopicRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateProductTopic", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateProductTopic", "iot", "openAPI")
 	return
 }
 

services/iot/create_rule.go

@@ -103,7 +103,7 @@ func CreateCreateRuleRequest() (request *CreateRuleRequest) {
 	request = &CreateRuleRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateRule", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateRule", "iot", "openAPI")
 	return
 }
 

services/iot/create_rule_action.go

@@ -98,7 +98,7 @@ func CreateCreateRuleActionRequest() (request *CreateRuleActionRequest) {
 	request = &CreateRuleActionRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateRuleAction", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateRuleAction", "iot", "openAPI")
 	return
 }
 

services/iot/create_topic_route_table.go

@@ -97,7 +97,7 @@ func CreateCreateTopicRouteTableRequest() (request *CreateTopicRouteTableRequest
 	request = &CreateTopicRouteTableRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "CreateTopicRouteTable", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "CreateTopicRouteTable", "iot", "openAPI")
 	return
 }
 

services/iot/delete_device.go

@@ -96,7 +96,7 @@ func CreateDeleteDeviceRequest() (request *DeleteDeviceRequest) {
 	request = &DeleteDeviceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDevice", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDevice", "iot", "openAPI")
 	return
 }
 

services/iot/delete_device_file.go

@@ -97,7 +97,7 @@ func CreateDeleteDeviceFileRequest() (request *DeleteDeviceFileRequest) {
 	request = &DeleteDeviceFileRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDeviceFile", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDeviceFile", "iot", "openAPI")
 	return
 }
 

services/iot/delete_device_group.go

@@ -94,7 +94,7 @@ func CreateDeleteDeviceGroupRequest() (request *DeleteDeviceGroupRequest) {
 	request = &DeleteDeviceGroupRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDeviceGroup", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDeviceGroup", "iot", "openAPI")
 	return
 }
 

services/iot/delete_device_prop.go

@@ -97,7 +97,7 @@ func CreateDeleteDevicePropRequest() (request *DeleteDevicePropRequest) {
 	request = &DeleteDevicePropRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDeviceProp", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteDeviceProp", "iot", "openAPI")
 	return
 }
 

services/iot/delete_edge_instance.go

@@ -94,7 +94,7 @@ func CreateDeleteEdgeInstanceRequest() (request *DeleteEdgeInstanceRequest) {
 	request = &DeleteEdgeInstanceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteEdgeInstance", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteEdgeInstance", "iot", "openAPI")
 	return
 }
 

services/iot/delete_ota_firmware.go

@@ -0,0 +1,107 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteOTAFirmware invokes the iot.DeleteOTAFirmware API synchronously
+// api document: https://help.aliyun.com/api/iot/deleteotafirmware.html
+func (client *Client) DeleteOTAFirmware(request *DeleteOTAFirmwareRequest) (response *DeleteOTAFirmwareResponse, err error) {
+	response = CreateDeleteOTAFirmwareResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteOTAFirmwareWithChan invokes the iot.DeleteOTAFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/deleteotafirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteOTAFirmwareWithChan(request *DeleteOTAFirmwareRequest) (<-chan *DeleteOTAFirmwareResponse, <-chan error) {
+	responseChan := make(chan *DeleteOTAFirmwareResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteOTAFirmware(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteOTAFirmwareWithCallback invokes the iot.DeleteOTAFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/deleteotafirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteOTAFirmwareWithCallback(request *DeleteOTAFirmwareRequest, callback func(response *DeleteOTAFirmwareResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteOTAFirmwareResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteOTAFirmware(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteOTAFirmwareRequest is the request struct for api DeleteOTAFirmware
+type DeleteOTAFirmwareRequest struct {
+	*requests.RpcRequest
+	FirmwareId    string `position:"Query" name:"FirmwareId"`
+	IotInstanceId string `position:"Query" name:"IotInstanceId"`
+}
+
+// DeleteOTAFirmwareResponse is the response struct for api DeleteOTAFirmware
+type DeleteOTAFirmwareResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+}
+
+// CreateDeleteOTAFirmwareRequest creates a request to invoke DeleteOTAFirmware API
+func CreateDeleteOTAFirmwareRequest() (request *DeleteOTAFirmwareRequest) {
+	request = &DeleteOTAFirmwareRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteOTAFirmware", "iot", "openAPI")
+	return
+}
+
+// CreateDeleteOTAFirmwareResponse creates a response to parse from DeleteOTAFirmware response
+func CreateDeleteOTAFirmwareResponse() (response *DeleteOTAFirmwareResponse) {
+	response = &DeleteOTAFirmwareResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/delete_product.go

@@ -94,7 +94,7 @@ func CreateDeleteProductRequest() (request *DeleteProductRequest) {
 	request = &DeleteProductRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteProduct", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteProduct", "iot", "openAPI")
 	return
 }
 

services/iot/delete_product_tags.go

@@ -95,7 +95,7 @@ func CreateDeleteProductTagsRequest() (request *DeleteProductTagsRequest) {
 	request = &DeleteProductTagsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteProductTags", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteProductTags", "iot", "openAPI")
 	return
 }
 

services/iot/delete_product_topic.go

@@ -94,7 +94,7 @@ func CreateDeleteProductTopicRequest() (request *DeleteProductTopicRequest) {
 	request = &DeleteProductTopicRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteProductTopic", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteProductTopic", "iot", "openAPI")
 	return
 }
 

services/iot/delete_rule.go

@@ -94,7 +94,7 @@ func CreateDeleteRuleRequest() (request *DeleteRuleRequest) {
 	request = &DeleteRuleRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteRule", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteRule", "iot", "openAPI")
 	return
 }
 

services/iot/delete_rule_action.go

@@ -94,7 +94,7 @@ func CreateDeleteRuleActionRequest() (request *DeleteRuleActionRequest) {
 	request = &DeleteRuleActionRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteRuleAction", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteRuleAction", "iot", "openAPI")
 	return
 }
 

services/iot/delete_topic_route_table.go

@@ -97,7 +97,7 @@ func CreateDeleteTopicRouteTableRequest() (request *DeleteTopicRouteTableRequest
 	request = &DeleteTopicRouteTableRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteTopicRouteTable", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DeleteTopicRouteTable", "iot", "openAPI")
 	return
 }
 

services/iot/disable_thing.go

@@ -96,7 +96,7 @@ func CreateDisableThingRequest() (request *DisableThingRequest) {
 	request = &DisableThingRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "DisableThing", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "DisableThing", "iot", "openAPI")
 	return
 }
 

services/iot/enable_thing.go

@@ -96,7 +96,7 @@ func CreateEnableThingRequest() (request *EnableThingRequest) {
 	request = &EnableThingRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "EnableThing", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "EnableThing", "iot", "openAPI")
 	return
 }
 

services/iot/generate_ota_upload_url.go

@@ -0,0 +1,107 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// GenerateOTAUploadURL invokes the iot.GenerateOTAUploadURL API synchronously
+// api document: https://help.aliyun.com/api/iot/generateotauploadurl.html
+func (client *Client) GenerateOTAUploadURL(request *GenerateOTAUploadURLRequest) (response *GenerateOTAUploadURLResponse, err error) {
+	response = CreateGenerateOTAUploadURLResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// GenerateOTAUploadURLWithChan invokes the iot.GenerateOTAUploadURL API asynchronously
+// api document: https://help.aliyun.com/api/iot/generateotauploadurl.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) GenerateOTAUploadURLWithChan(request *GenerateOTAUploadURLRequest) (<-chan *GenerateOTAUploadURLResponse, <-chan error) {
+	responseChan := make(chan *GenerateOTAUploadURLResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.GenerateOTAUploadURL(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// GenerateOTAUploadURLWithCallback invokes the iot.GenerateOTAUploadURL API asynchronously
+// api document: https://help.aliyun.com/api/iot/generateotauploadurl.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) GenerateOTAUploadURLWithCallback(request *GenerateOTAUploadURLRequest, callback func(response *GenerateOTAUploadURLResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *GenerateOTAUploadURLResponse
+		var err error
+		defer close(result)
+		response, err = client.GenerateOTAUploadURL(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// GenerateOTAUploadURLRequest is the request struct for api GenerateOTAUploadURL
+type GenerateOTAUploadURLRequest struct {
+	*requests.RpcRequest
+	IotInstanceId string `position:"Query" name:"IotInstanceId"`
+}
+
+// GenerateOTAUploadURLResponse is the response struct for api GenerateOTAUploadURL
+type GenerateOTAUploadURLResponse struct {
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	Success      bool   `json:"Success" xml:"Success"`
+	Code         string `json:"Code" xml:"Code"`
+	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
+	Data         Data   `json:"Data" xml:"Data"`
+}
+
+// CreateGenerateOTAUploadURLRequest creates a request to invoke GenerateOTAUploadURL API
+func CreateGenerateOTAUploadURLRequest() (request *GenerateOTAUploadURLRequest) {
+	request = &GenerateOTAUploadURLRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "GenerateOTAUploadURL", "iot", "openAPI")
+	return
+}
+
+// CreateGenerateOTAUploadURLResponse creates a response to parse from GenerateOTAUploadURL response
+func CreateGenerateOTAUploadURLResponse() (response *GenerateOTAUploadURLResponse) {
+	response = &GenerateOTAUploadURLResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/get_data_api_service_detail.go

@@ -94,7 +94,7 @@ func CreateGetDataAPIServiceDetailRequest() (request *GetDataAPIServiceDetailReq
 	request = &GetDataAPIServiceDetailRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetDataAPIServiceDetail", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetDataAPIServiceDetail", "iot", "openAPI")
 	return
 }
 

services/iot/get_device_list_by_iot_ids.go

@@ -96,7 +96,7 @@ func CreateGetDeviceListByIotIdsRequest() (request *GetDeviceListByIotIdsRequest
 	request = &GetDeviceListByIotIdsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetDeviceListByIotIds", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetDeviceListByIotIds", "iot", "openAPI")
 	return
 }
 

services/iot/get_device_shadow.go

@@ -97,7 +97,7 @@ func CreateGetDeviceShadowRequest() (request *GetDeviceShadowRequest) {
 	request = &GetDeviceShadowRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetDeviceShadow", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetDeviceShadow", "iot", "openAPI")
 	return
 }
 

services/iot/get_device_status.go

@@ -97,7 +97,7 @@ func CreateGetDeviceStatusRequest() (request *GetDeviceStatusRequest) {
 	request = &GetDeviceStatusRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetDeviceStatus", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetDeviceStatus", "iot", "openAPI")
 	return
 }
 

services/iot/get_edge_instance.go

@@ -95,7 +95,7 @@ func CreateGetEdgeInstanceRequest() (request *GetEdgeInstanceRequest) {
 	request = &GetEdgeInstanceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetEdgeInstance", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetEdgeInstance", "iot", "openAPI")
 	return
 }
 

services/iot/get_edge_instance_deployment.go

@@ -96,7 +96,7 @@ func CreateGetEdgeInstanceDeploymentRequest() (request *GetEdgeInstanceDeploymen
 	request = &GetEdgeInstanceDeploymentRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetEdgeInstanceDeployment", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetEdgeInstanceDeployment", "iot", "openAPI")
 	return
 }
 

services/iot/get_gateway_by_sub_device.go

@@ -97,7 +97,7 @@ func CreateGetGatewayBySubDeviceRequest() (request *GetGatewayBySubDeviceRequest
 	request = &GetGatewayBySubDeviceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetGatewayBySubDevice", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetGatewayBySubDevice", "iot", "openAPI")
 	return
 }
 

services/iot/get_lora_nodes_task.go

@@ -99,7 +99,7 @@ func CreateGetLoraNodesTaskRequest() (request *GetLoraNodesTaskRequest) {
 	request = &GetLoraNodesTaskRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetLoraNodesTask", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetLoraNodesTask", "iot", "openAPI")
 	return
 }
 

services/iot/get_nodes_adding_task.go

@@ -99,7 +99,7 @@ func CreateGetNodesAddingTaskRequest() (request *GetNodesAddingTaskRequest) {
 	request = &GetNodesAddingTaskRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetNodesAddingTask", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetNodesAddingTask", "iot", "openAPI")
 	return
 }
 

services/iot/get_product_key_list_by_name.go

@@ -97,7 +97,7 @@ func CreateGetProductKeyListByNameRequest() (request *GetProductKeyListByNameReq
 	request = &GetProductKeyListByNameRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetProductKeyListByName", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetProductKeyListByName", "iot", "openAPI")
 	return
 }
 

services/iot/get_product_meta_list_by_name.go

@@ -98,7 +98,7 @@ func CreateGetProductMetaListByNameRequest() (request *GetProductMetaListByNameR
 	request = &GetProductMetaListByNameRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetProductMetaListByName", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetProductMetaListByName", "iot", "openAPI")
 	return
 }
 

services/iot/get_rule.go

@@ -95,7 +95,7 @@ func CreateGetRuleRequest() (request *GetRuleRequest) {
 	request = &GetRuleRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetRule", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetRule", "iot", "openAPI")
 	return
 }
 

services/iot/get_rule_action.go

@@ -95,7 +95,7 @@ func CreateGetRuleActionRequest() (request *GetRuleActionRequest) {
 	request = &GetRuleActionRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetRuleAction", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetRuleAction", "iot", "openAPI")
 	return
 }
 

services/iot/get_thing_topo.go

@@ -99,7 +99,7 @@ func CreateGetThingTopoRequest() (request *GetThingTopoRequest) {
 	request = &GetThingTopoRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GetThingTopo", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GetThingTopo", "iot", "openAPI")
 	return
 }
 

services/iot/gis_query_device_location.go

@@ -97,7 +97,7 @@ func CreateGisQueryDeviceLocationRequest() (request *GisQueryDeviceLocationReque
 	request = &GisQueryDeviceLocationRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "GisQueryDeviceLocation", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "GisQueryDeviceLocation", "iot", "openAPI")
 	return
 }
 

services/iot/invoke_data_api_service.go

@@ -103,7 +103,7 @@ func CreateInvokeDataAPIServiceRequest() (request *InvokeDataAPIServiceRequest)
 	request = &InvokeDataAPIServiceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "InvokeDataAPIService", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "InvokeDataAPIService", "iot", "openAPI")
 	return
 }
 

services/iot/invoke_thing_service.go

@@ -99,7 +99,7 @@ func CreateInvokeThingServiceRequest() (request *InvokeThingServiceRequest) {
 	request = &InvokeThingServiceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "InvokeThingService", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "InvokeThingService", "iot", "openAPI")
 	return
 }
 

services/iot/invoke_things_service.go

@@ -97,7 +97,7 @@ func CreateInvokeThingsServiceRequest() (request *InvokeThingsServiceRequest) {
 	request = &InvokeThingsServiceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "InvokeThingsService", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "InvokeThingsService", "iot", "openAPI")
 	return
 }
 

services/iot/list_ota_firmware.go

@@ -0,0 +1,115 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// ListOTAFirmware invokes the iot.ListOTAFirmware API synchronously
+// api document: https://help.aliyun.com/api/iot/listotafirmware.html
+func (client *Client) ListOTAFirmware(request *ListOTAFirmwareRequest) (response *ListOTAFirmwareResponse, err error) {
+	response = CreateListOTAFirmwareResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// ListOTAFirmwareWithChan invokes the iot.ListOTAFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/listotafirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ListOTAFirmwareWithChan(request *ListOTAFirmwareRequest) (<-chan *ListOTAFirmwareResponse, <-chan error) {
+	responseChan := make(chan *ListOTAFirmwareResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ListOTAFirmware(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// ListOTAFirmwareWithCallback invokes the iot.ListOTAFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/listotafirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ListOTAFirmwareWithCallback(request *ListOTAFirmwareRequest, callback func(response *ListOTAFirmwareResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ListOTAFirmwareResponse
+		var err error
+		defer close(result)
+		response, err = client.ListOTAFirmware(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// ListOTAFirmwareRequest is the request struct for api ListOTAFirmware
+type ListOTAFirmwareRequest struct {
+	*requests.RpcRequest
+	CurrentPage   requests.Integer `position:"Query" name:"CurrentPage"`
+	ProductKey    string           `position:"Query" name:"ProductKey"`
+	IotInstanceId string           `position:"Query" name:"IotInstanceId"`
+	PageSize      requests.Integer `position:"Query" name:"PageSize"`
+	DestVersion   string           `position:"Query" name:"DestVersion"`
+}
+
+// ListOTAFirmwareResponse is the response struct for api ListOTAFirmware
+type ListOTAFirmwareResponse struct {
+	*responses.BaseResponse
+	RequestId    string                        `json:"RequestId" xml:"RequestId"`
+	Success      bool                          `json:"Success" xml:"Success"`
+	Code         string                        `json:"Code" xml:"Code"`
+	ErrorMessage string                        `json:"ErrorMessage" xml:"ErrorMessage"`
+	Total        int                           `json:"Total" xml:"Total"`
+	PageSize     int                           `json:"PageSize" xml:"PageSize"`
+	PageCount    int                           `json:"PageCount" xml:"PageCount"`
+	CurrentPage  int                           `json:"CurrentPage" xml:"CurrentPage"`
+	FirmwareInfo FirmwareInfoInListOTAFirmware `json:"FirmwareInfo" xml:"FirmwareInfo"`
+}
+
+// CreateListOTAFirmwareRequest creates a request to invoke ListOTAFirmware API
+func CreateListOTAFirmwareRequest() (request *ListOTAFirmwareRequest) {
+	request = &ListOTAFirmwareRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "ListOTAFirmware", "iot", "openAPI")
+	return
+}
+
+// CreateListOTAFirmwareResponse creates a response to parse from ListOTAFirmware response
+func CreateListOTAFirmwareResponse() (response *ListOTAFirmwareResponse) {
+	response = &ListOTAFirmwareResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/list_ota_job_by_firmware.go

@@ -0,0 +1,116 @@
+package iot
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// ListOTAJobByFirmware invokes the iot.ListOTAJobByFirmware API synchronously
+// api document: https://help.aliyun.com/api/iot/listotajobbyfirmware.html
+func (client *Client) ListOTAJobByFirmware(request *ListOTAJobByFirmwareRequest) (response *ListOTAJobByFirmwareResponse, err error) {
+	response = CreateListOTAJobByFirmwareResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// ListOTAJobByFirmwareWithChan invokes the iot.ListOTAJobByFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/listotajobbyfirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ListOTAJobByFirmwareWithChan(request *ListOTAJobByFirmwareRequest) (<-chan *ListOTAJobByFirmwareResponse, <-chan error) {
+	responseChan := make(chan *ListOTAJobByFirmwareResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ListOTAJobByFirmware(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// ListOTAJobByFirmwareWithCallback invokes the iot.ListOTAJobByFirmware API asynchronously
+// api document: https://help.aliyun.com/api/iot/listotajobbyfirmware.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ListOTAJobByFirmwareWithCallback(request *ListOTAJobByFirmwareRequest, callback func(response *ListOTAJobByFirmwareResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ListOTAJobByFirmwareResponse
+		var err error
+		defer close(result)
+		response, err = client.ListOTAJobByFirmware(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// ListOTAJobByFirmwareRequest is the request struct for api ListOTAJobByFirmware
+type ListOTAJobByFirmwareRequest struct {
+	*requests.RpcRequest
+	FirmwareId    string           `position:"Query" name:"FirmwareId"`
+	CurrentPage   requests.Integer `position:"Query" name:"CurrentPage"`
+	ProductKey    string           `position:"Query" name:"ProductKey"`
+	IotInstanceId string           `position:"Query" name:"IotInstanceId"`
+	PageSize      requests.Integer `position:"Query" name:"PageSize"`
+	DeviceName    string           `position:"Query" name:"DeviceName"`
+}
+
+// ListOTAJobByFirmwareResponse is the response struct for api ListOTAJobByFirmware
+type ListOTAJobByFirmwareResponse struct {
+	*responses.BaseResponse
+	RequestId    string                     `json:"RequestId" xml:"RequestId"`
+	Success      bool                       `json:"Success" xml:"Success"`
+	Code         string                     `json:"Code" xml:"Code"`
+	ErrorMessage string                     `json:"ErrorMessage" xml:"ErrorMessage"`
+	Total        int                        `json:"Total" xml:"Total"`
+	PageSize     int                        `json:"PageSize" xml:"PageSize"`
+	PageCount    int                        `json:"PageCount" xml:"PageCount"`
+	CurrentPage  int                        `json:"CurrentPage" xml:"CurrentPage"`
+	Data         DataInListOTAJobByFirmware `json:"Data" xml:"Data"`
+}
+
+// CreateListOTAJobByFirmwareRequest creates a request to invoke ListOTAJobByFirmware API
+func CreateListOTAJobByFirmwareRequest() (request *ListOTAJobByFirmwareRequest) {
+	request = &ListOTAJobByFirmwareRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Iot", "2018-01-20", "ListOTAJobByFirmware", "iot", "openAPI")
+	return
+}
+
+// CreateListOTAJobByFirmwareResponse creates a response to parse from ListOTAJobByFirmware response
+func CreateListOTAJobByFirmwareResponse() (response *ListOTAJobByFirmwareResponse) {
+	response = &ListOTAJobByFirmwareResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

services/iot/list_product_by_tags.go

@@ -103,7 +103,7 @@ func CreateListProductByTagsRequest() (request *ListProductByTagsRequest) {
 	request = &ListProductByTagsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "ListProductByTags", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "ListProductByTags", "iot", "openAPI")
 	return
 }
 

services/iot/list_product_tags.go

@@ -95,7 +95,7 @@ func CreateListProductTagsRequest() (request *ListProductTagsRequest) {
 	request = &ListProductTagsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "ListProductTags", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "ListProductTags", "iot", "openAPI")
 	return
 }
 

services/iot/list_rule.go

@@ -101,7 +101,7 @@ func CreateListRuleRequest() (request *ListRuleRequest) {
 	request = &ListRuleRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "ListRule", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "ListRule", "iot", "openAPI")
 	return
 }
 

services/iot/list_rule_actions.go

@@ -95,7 +95,7 @@ func CreateListRuleActionsRequest() (request *ListRuleActionsRequest) {
 	request = &ListRuleActionsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "ListRuleActions", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "ListRuleActions", "iot", "openAPI")
 	return
 }
 

services/iot/notify_add_thing_topo.go

@@ -98,7 +98,7 @@ func CreateNotifyAddThingTopoRequest() (request *NotifyAddThingTopoRequest) {
 	request = &NotifyAddThingTopoRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "NotifyAddThingTopo", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "NotifyAddThingTopo", "iot", "openAPI")
 	return
 }
 

services/iot/pub.go

@@ -98,7 +98,7 @@ func CreatePubRequest() (request *PubRequest) {
 	request = &PubRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "Pub", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "Pub", "iot", "openAPI")
 	return
 }
 

services/iot/pub_broadcast.go

@@ -96,7 +96,7 @@ func CreatePubBroadcastRequest() (request *PubBroadcastRequest) {
 	request = &PubBroadcastRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "PubBroadcast", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "PubBroadcast", "iot", "openAPI")
 	return
 }
 

services/iot/query_app_device_list.go

@@ -110,7 +110,7 @@ func CreateQueryAppDeviceListRequest() (request *QueryAppDeviceListRequest) {
 	request = &QueryAppDeviceListRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryAppDeviceList", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryAppDeviceList", "iot", "openAPI")
 	return
 }
 

services/iot/query_batch_register_device_status.go

@@ -96,7 +96,7 @@ func CreateQueryBatchRegisterDeviceStatusRequest() (request *QueryBatchRegisterD
 	request = &QueryBatchRegisterDeviceStatusRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryBatchRegisterDeviceStatus", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryBatchRegisterDeviceStatus", "iot", "openAPI")
 	return
 }
 

services/iot/query_cert_url_by_apply_id.go

@@ -95,7 +95,7 @@ func CreateQueryCertUrlByApplyIdRequest() (request *QueryCertUrlByApplyIdRequest
 	request = &QueryCertUrlByApplyIdRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryCertUrlByApplyId", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryCertUrlByApplyId", "iot", "openAPI")
 	return
 }
 

services/iot/query_device.go

@@ -101,7 +101,7 @@ func CreateQueryDeviceRequest() (request *QueryDeviceRequest) {
 	request = &QueryDeviceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDevice", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDevice", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_by_driver.go

@@ -98,7 +98,7 @@ func CreateQueryDeviceByDriverRequest() (request *QueryDeviceByDriverRequest) {
 	request = &QueryDeviceByDriverRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceByDriver", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceByDriver", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_by_status.go

@@ -104,7 +104,7 @@ func CreateQueryDeviceByStatusRequest() (request *QueryDeviceByStatusRequest) {
 	request = &QueryDeviceByStatusRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceByStatus", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceByStatus", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_by_tags.go

@@ -107,7 +107,7 @@ func CreateQueryDeviceByTagsRequest() (request *QueryDeviceByTagsRequest) {
 	request = &QueryDeviceByTagsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceByTags", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceByTags", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_cert.go

@@ -96,7 +96,7 @@ func CreateQueryDeviceCertRequest() (request *QueryDeviceCertRequest) {
 	request = &QueryDeviceCertRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceCert", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceCert", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_desired_property.go

@@ -98,7 +98,7 @@ func CreateQueryDeviceDesiredPropertyRequest() (request *QueryDeviceDesiredPrope
 	request = &QueryDeviceDesiredPropertyRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceDesiredProperty", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceDesiredProperty", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_detail.go

@@ -97,7 +97,7 @@ func CreateQueryDeviceDetailRequest() (request *QueryDeviceDetailRequest) {
 	request = &QueryDeviceDetailRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceDetail", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceDetail", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_event_data.go

@@ -103,7 +103,7 @@ func CreateQueryDeviceEventDataRequest() (request *QueryDeviceEventDataRequest)
 	request = &QueryDeviceEventDataRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceEventData", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceEventData", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_file.go

@@ -98,7 +98,7 @@ func CreateQueryDeviceFileRequest() (request *QueryDeviceFileRequest) {
 	request = &QueryDeviceFileRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceFile", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceFile", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_file_list.go

@@ -103,7 +103,7 @@ func CreateQueryDeviceFileListRequest() (request *QueryDeviceFileListRequest) {
 	request = &QueryDeviceFileListRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceFileList", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceFileList", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_group_by_device.go

@@ -96,7 +96,7 @@ func CreateQueryDeviceGroupByDeviceRequest() (request *QueryDeviceGroupByDeviceR
 	request = &QueryDeviceGroupByDeviceRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupByDevice", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupByDevice", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_group_by_tags.go

@@ -107,7 +107,7 @@ func CreateQueryDeviceGroupByTagsRequest() (request *QueryDeviceGroupByTagsReque
 	request = &QueryDeviceGroupByTagsRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupByTags", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupByTags", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_group_info.go

@@ -95,7 +95,7 @@ func CreateQueryDeviceGroupInfoRequest() (request *QueryDeviceGroupInfoRequest)
 	request = &QueryDeviceGroupInfoRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupInfo", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupInfo", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_group_list.go

@@ -102,7 +102,7 @@ func CreateQueryDeviceGroupListRequest() (request *QueryDeviceGroupListRequest)
 	request = &QueryDeviceGroupListRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupList", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupList", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_group_tag_list.go

@@ -95,7 +95,7 @@ func CreateQueryDeviceGroupTagListRequest() (request *QueryDeviceGroupTagListReq
 	request = &QueryDeviceGroupTagListRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupTagList", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceGroupTagList", "iot", "openAPI")
 	return
 }
 

services/iot/query_device_list_by_device_group.go

@@ -101,7 +101,7 @@ func CreateQueryDeviceListByDeviceGroupRequest() (request *QueryDeviceListByDevi
 	request = &QueryDeviceListByDeviceGroupRequest{
 		RpcRequest: &requests.RpcRequest{},
 	}
-	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceListByDeviceGroup", "Iot", "openAPI")
+	request.InitWithApiInfo("Iot", "2018-01-20", "QueryDeviceListByDeviceGroup", "iot", "openAPI")
 	return
 }