1// Copyright (c) 2017-2018 THL A29 Limited, a Tencent company. All Rights Reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//    http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package v20190423
16
17import (
18    "encoding/json"
19    "errors"
20
21    tchttp "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http"
22)
23
24type CallDeviceActionAsyncRequest struct {
25	*tchttp.BaseRequest
26
27	// 产品Id
28	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
29
30	// 设备名称
31	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
32
33	// 产品数据模板中行为功能的标识符，由开发者自行根据设备的应用场景定义
34	ActionId *string `json:"ActionId,omitempty" name:"ActionId"`
35
36	// 输入参数
37	InputParams *string `json:"InputParams,omitempty" name:"InputParams"`
38}
39
40func (r *CallDeviceActionAsyncRequest) ToJsonString() string {
41    b, _ := json.Marshal(r)
42    return string(b)
43}
44
45// It is highly **NOT** recommended to use this function
46// because it has no param check, nor strict type check
47func (r *CallDeviceActionAsyncRequest) FromJsonString(s string) error {
48	f := make(map[string]interface{})
49	if err := json.Unmarshal([]byte(s), &f); err != nil {
50		return err
51	}
52	delete(f, "ProductId")
53	delete(f, "DeviceName")
54	delete(f, "ActionId")
55	delete(f, "InputParams")
56	if len(f) > 0 {
57		return errors.New("CallDeviceActionAsyncRequest has unknown keys!")
58	}
59	return json.Unmarshal([]byte(s), &r)
60}
61
62type CallDeviceActionAsyncResponse struct {
63	*tchttp.BaseResponse
64	Response *struct {
65
66		// 调用Id
67		ClientToken *string `json:"ClientToken,omitempty" name:"ClientToken"`
68
69		// 异步调用状态
70		Status *string `json:"Status,omitempty" name:"Status"`
71
72		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
73		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
74	} `json:"Response"`
75}
76
77func (r *CallDeviceActionAsyncResponse) ToJsonString() string {
78    b, _ := json.Marshal(r)
79    return string(b)
80}
81
82// It is highly **NOT** recommended to use this function
83// because it has no param check, nor strict type check
84func (r *CallDeviceActionAsyncResponse) FromJsonString(s string) error {
85	return json.Unmarshal([]byte(s), &r)
86}
87
88type CallDeviceActionSyncRequest struct {
89	*tchttp.BaseRequest
90
91	// 产品Id
92	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
93
94	// 设备名称
95	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
96
97	// 产品数据模板中行为功能的标识符，由开发者自行根据设备的应用场景定义
98	ActionId *string `json:"ActionId,omitempty" name:"ActionId"`
99
100	// 输入参数
101	InputParams *string `json:"InputParams,omitempty" name:"InputParams"`
102}
103
104func (r *CallDeviceActionSyncRequest) ToJsonString() string {
105    b, _ := json.Marshal(r)
106    return string(b)
107}
108
109// It is highly **NOT** recommended to use this function
110// because it has no param check, nor strict type check
111func (r *CallDeviceActionSyncRequest) FromJsonString(s string) error {
112	f := make(map[string]interface{})
113	if err := json.Unmarshal([]byte(s), &f); err != nil {
114		return err
115	}
116	delete(f, "ProductId")
117	delete(f, "DeviceName")
118	delete(f, "ActionId")
119	delete(f, "InputParams")
120	if len(f) > 0 {
121		return errors.New("CallDeviceActionSyncRequest has unknown keys!")
122	}
123	return json.Unmarshal([]byte(s), &r)
124}
125
126type CallDeviceActionSyncResponse struct {
127	*tchttp.BaseResponse
128	Response *struct {
129
130		// 调用Id
131		ClientToken *string `json:"ClientToken,omitempty" name:"ClientToken"`
132
133		// 输出参数
134	// 注意：此字段可能返回 null，表示取不到有效值。
135		OutputParams *string `json:"OutputParams,omitempty" name:"OutputParams"`
136
137		// 返回状态
138		Status *string `json:"Status,omitempty" name:"Status"`
139
140		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
141		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
142	} `json:"Response"`
143}
144
145func (r *CallDeviceActionSyncResponse) ToJsonString() string {
146    b, _ := json.Marshal(r)
147    return string(b)
148}
149
150// It is highly **NOT** recommended to use this function
151// because it has no param check, nor strict type check
152func (r *CallDeviceActionSyncResponse) FromJsonString(s string) error {
153	return json.Unmarshal([]byte(s), &r)
154}
155
156type ControlDeviceDataRequest struct {
157	*tchttp.BaseRequest
158
159	// 产品ID
160	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
161
162	// 设备名称
163	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
164
165	// 属性数据, JSON格式字符串, 注意字段需要在物模型属性里定义
166	Data *string `json:"Data,omitempty" name:"Data"`
167
168	// 请求类型 , 不填该参数或者 desired 表示下发属性给设备,  reported 表示模拟设备上报属性
169	Method *string `json:"Method,omitempty" name:"Method"`
170
171	// 设备ID，该字段有值将代替 ProductId/DeviceName , 通常情况不需要填写
172	DeviceId *string `json:"DeviceId,omitempty" name:"DeviceId"`
173
174	// 上报数据UNIX时间戳(毫秒), 仅对Method:reported有效
175	DataTimestamp *int64 `json:"DataTimestamp,omitempty" name:"DataTimestamp"`
176}
177
178func (r *ControlDeviceDataRequest) ToJsonString() string {
179    b, _ := json.Marshal(r)
180    return string(b)
181}
182
183// It is highly **NOT** recommended to use this function
184// because it has no param check, nor strict type check
185func (r *ControlDeviceDataRequest) FromJsonString(s string) error {
186	f := make(map[string]interface{})
187	if err := json.Unmarshal([]byte(s), &f); err != nil {
188		return err
189	}
190	delete(f, "ProductId")
191	delete(f, "DeviceName")
192	delete(f, "Data")
193	delete(f, "Method")
194	delete(f, "DeviceId")
195	delete(f, "DataTimestamp")
196	if len(f) > 0 {
197		return errors.New("ControlDeviceDataRequest has unknown keys!")
198	}
199	return json.Unmarshal([]byte(s), &r)
200}
201
202type ControlDeviceDataResponse struct {
203	*tchttp.BaseResponse
204	Response *struct {
205
206		// 返回信息
207		Data *string `json:"Data,omitempty" name:"Data"`
208
209		// JSON字符串， 返回下发控制的结果信息,
210	// Sent = 1 表示设备已经在线并且订阅了控制下发的mqtt topic
211	// 注意：此字段可能返回 null，表示取不到有效值。
212		Result *string `json:"Result,omitempty" name:"Result"`
213
214		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
215		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
216	} `json:"Response"`
217}
218
219func (r *ControlDeviceDataResponse) ToJsonString() string {
220    b, _ := json.Marshal(r)
221    return string(b)
222}
223
224// It is highly **NOT** recommended to use this function
225// because it has no param check, nor strict type check
226func (r *ControlDeviceDataResponse) FromJsonString(s string) error {
227	return json.Unmarshal([]byte(s), &r)
228}
229
230type CreateDeviceRequest struct {
231	*tchttp.BaseRequest
232
233	// 产品ID。
234	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
235
236	// 设备名称。命名规则：[a-zA-Z0-9:_-]{1,48}。
237	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
238
239	// LoRaWAN 设备地址
240	DevAddr *string `json:"DevAddr,omitempty" name:"DevAddr"`
241
242	// LoRaWAN 应用密钥
243	AppKey *string `json:"AppKey,omitempty" name:"AppKey"`
244
245	// LoRaWAN 设备唯一标识
246	DevEUI *string `json:"DevEUI,omitempty" name:"DevEUI"`
247
248	// LoRaWAN 应用会话密钥
249	AppSKey *string `json:"AppSKey,omitempty" name:"AppSKey"`
250
251	// LoRaWAN 网络会话密钥
252	NwkSKey *string `json:"NwkSKey,omitempty" name:"NwkSKey"`
253}
254
255func (r *CreateDeviceRequest) ToJsonString() string {
256    b, _ := json.Marshal(r)
257    return string(b)
258}
259
260// It is highly **NOT** recommended to use this function
261// because it has no param check, nor strict type check
262func (r *CreateDeviceRequest) FromJsonString(s string) error {
263	f := make(map[string]interface{})
264	if err := json.Unmarshal([]byte(s), &f); err != nil {
265		return err
266	}
267	delete(f, "ProductId")
268	delete(f, "DeviceName")
269	delete(f, "DevAddr")
270	delete(f, "AppKey")
271	delete(f, "DevEUI")
272	delete(f, "AppSKey")
273	delete(f, "NwkSKey")
274	if len(f) > 0 {
275		return errors.New("CreateDeviceRequest has unknown keys!")
276	}
277	return json.Unmarshal([]byte(s), &r)
278}
279
280type CreateDeviceResponse struct {
281	*tchttp.BaseResponse
282	Response *struct {
283
284		// 设备参数描述。
285		Data *DeviceData `json:"Data,omitempty" name:"Data"`
286
287		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
288		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
289	} `json:"Response"`
290}
291
292func (r *CreateDeviceResponse) ToJsonString() string {
293    b, _ := json.Marshal(r)
294    return string(b)
295}
296
297// It is highly **NOT** recommended to use this function
298// because it has no param check, nor strict type check
299func (r *CreateDeviceResponse) FromJsonString(s string) error {
300	return json.Unmarshal([]byte(s), &r)
301}
302
303type CreateLoRaFrequencyRequest struct {
304	*tchttp.BaseRequest
305
306	// 频点配置名称
307	FreqName *string `json:"FreqName,omitempty" name:"FreqName"`
308
309	// 数据上行信道
310	ChannelsDataUp []*uint64 `json:"ChannelsDataUp,omitempty" name:"ChannelsDataUp" list`
311
312	// 数据下行RX1信道
313	ChannelsDataRX1 []*uint64 `json:"ChannelsDataRX1,omitempty" name:"ChannelsDataRX1" list`
314
315	// 数据下行RX2信道
316	ChannelsDataRX2 []*uint64 `json:"ChannelsDataRX2,omitempty" name:"ChannelsDataRX2" list`
317
318	// 入网上行信道
319	ChannelsJoinUp []*uint64 `json:"ChannelsJoinUp,omitempty" name:"ChannelsJoinUp" list`
320
321	// 入网下行RX1信道
322	ChannelsJoinRX1 []*uint64 `json:"ChannelsJoinRX1,omitempty" name:"ChannelsJoinRX1" list`
323
324	// 入网下行RX2信道
325	ChannelsJoinRX2 []*uint64 `json:"ChannelsJoinRX2,omitempty" name:"ChannelsJoinRX2" list`
326
327	// 频点配置描述
328	Description *string `json:"Description,omitempty" name:"Description"`
329}
330
331func (r *CreateLoRaFrequencyRequest) ToJsonString() string {
332    b, _ := json.Marshal(r)
333    return string(b)
334}
335
336// It is highly **NOT** recommended to use this function
337// because it has no param check, nor strict type check
338func (r *CreateLoRaFrequencyRequest) FromJsonString(s string) error {
339	f := make(map[string]interface{})
340	if err := json.Unmarshal([]byte(s), &f); err != nil {
341		return err
342	}
343	delete(f, "FreqName")
344	delete(f, "ChannelsDataUp")
345	delete(f, "ChannelsDataRX1")
346	delete(f, "ChannelsDataRX2")
347	delete(f, "ChannelsJoinUp")
348	delete(f, "ChannelsJoinRX1")
349	delete(f, "ChannelsJoinRX2")
350	delete(f, "Description")
351	if len(f) > 0 {
352		return errors.New("CreateLoRaFrequencyRequest has unknown keys!")
353	}
354	return json.Unmarshal([]byte(s), &r)
355}
356
357type CreateLoRaFrequencyResponse struct {
358	*tchttp.BaseResponse
359	Response *struct {
360
361		// LoRa频点信息
362		Data *LoRaFrequencyEntry `json:"Data,omitempty" name:"Data"`
363
364		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
365		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
366	} `json:"Response"`
367}
368
369func (r *CreateLoRaFrequencyResponse) ToJsonString() string {
370    b, _ := json.Marshal(r)
371    return string(b)
372}
373
374// It is highly **NOT** recommended to use this function
375// because it has no param check, nor strict type check
376func (r *CreateLoRaFrequencyResponse) FromJsonString(s string) error {
377	return json.Unmarshal([]byte(s), &r)
378}
379
380type CreateLoRaGatewayRequest struct {
381	*tchttp.BaseRequest
382
383	// LoRa 网关Id
384	GatewayId *string `json:"GatewayId,omitempty" name:"GatewayId"`
385
386	// 网关名称
387	Name *string `json:"Name,omitempty" name:"Name"`
388
389	// 详情描述
390	Description *string `json:"Description,omitempty" name:"Description"`
391
392	// 位置坐标
393	Location *LoRaGatewayLocation `json:"Location,omitempty" name:"Location"`
394
395	// 位置信息
396	Position *string `json:"Position,omitempty" name:"Position"`
397
398	// 位置详情
399	PositionDetails *string `json:"PositionDetails,omitempty" name:"PositionDetails"`
400
401	// 是否公开
402	IsPublic *bool `json:"IsPublic,omitempty" name:"IsPublic"`
403
404	// 频点ID
405	FrequencyId *string `json:"FrequencyId,omitempty" name:"FrequencyId"`
406}
407
408func (r *CreateLoRaGatewayRequest) ToJsonString() string {
409    b, _ := json.Marshal(r)
410    return string(b)
411}
412
413// It is highly **NOT** recommended to use this function
414// because it has no param check, nor strict type check
415func (r *CreateLoRaGatewayRequest) FromJsonString(s string) error {
416	f := make(map[string]interface{})
417	if err := json.Unmarshal([]byte(s), &f); err != nil {
418		return err
419	}
420	delete(f, "GatewayId")
421	delete(f, "Name")
422	delete(f, "Description")
423	delete(f, "Location")
424	delete(f, "Position")
425	delete(f, "PositionDetails")
426	delete(f, "IsPublic")
427	delete(f, "FrequencyId")
428	if len(f) > 0 {
429		return errors.New("CreateLoRaGatewayRequest has unknown keys!")
430	}
431	return json.Unmarshal([]byte(s), &r)
432}
433
434type CreateLoRaGatewayResponse struct {
435	*tchttp.BaseResponse
436	Response *struct {
437
438		// LoRa 网关信息
439		Gateway *LoRaGatewayItem `json:"Gateway,omitempty" name:"Gateway"`
440
441		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
442		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
443	} `json:"Response"`
444}
445
446func (r *CreateLoRaGatewayResponse) ToJsonString() string {
447    b, _ := json.Marshal(r)
448    return string(b)
449}
450
451// It is highly **NOT** recommended to use this function
452// because it has no param check, nor strict type check
453func (r *CreateLoRaGatewayResponse) FromJsonString(s string) error {
454	return json.Unmarshal([]byte(s), &r)
455}
456
457type CreateProjectRequest struct {
458	*tchttp.BaseRequest
459
460	// 项目名称
461	ProjectName *string `json:"ProjectName,omitempty" name:"ProjectName"`
462
463	// 项目描述
464	ProjectDesc *string `json:"ProjectDesc,omitempty" name:"ProjectDesc"`
465
466	// 实例ID，不带实例ID，默认为公共实例
467	InstanceId *string `json:"InstanceId,omitempty" name:"InstanceId"`
468}
469
470func (r *CreateProjectRequest) ToJsonString() string {
471    b, _ := json.Marshal(r)
472    return string(b)
473}
474
475// It is highly **NOT** recommended to use this function
476// because it has no param check, nor strict type check
477func (r *CreateProjectRequest) FromJsonString(s string) error {
478	f := make(map[string]interface{})
479	if err := json.Unmarshal([]byte(s), &f); err != nil {
480		return err
481	}
482	delete(f, "ProjectName")
483	delete(f, "ProjectDesc")
484	delete(f, "InstanceId")
485	if len(f) > 0 {
486		return errors.New("CreateProjectRequest has unknown keys!")
487	}
488	return json.Unmarshal([]byte(s), &r)
489}
490
491type CreateProjectResponse struct {
492	*tchttp.BaseResponse
493	Response *struct {
494
495		// 返回信息
496		Project *ProjectEntry `json:"Project,omitempty" name:"Project"`
497
498		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
499		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
500	} `json:"Response"`
501}
502
503func (r *CreateProjectResponse) ToJsonString() string {
504    b, _ := json.Marshal(r)
505    return string(b)
506}
507
508// It is highly **NOT** recommended to use this function
509// because it has no param check, nor strict type check
510func (r *CreateProjectResponse) FromJsonString(s string) error {
511	return json.Unmarshal([]byte(s), &r)
512}
513
514type CreateStudioProductRequest struct {
515	*tchttp.BaseRequest
516
517	// 产品名称，名称不能和已经存在的产品名称重复。命名规则：[a-zA-Z0-9:_-]{1,32}
518	ProductName *string `json:"ProductName,omitempty" name:"ProductName"`
519
520	// 产品分组模板ID , ( 自定义模板填写1 , 控制台调用会使用预置的其他ID)
521	CategoryId *int64 `json:"CategoryId,omitempty" name:"CategoryId"`
522
523	// 产品类型 填写 ( 0 普通产品 )
524	ProductType *int64 `json:"ProductType,omitempty" name:"ProductType"`
525
526	// 加密类型 加密类型，1表示证书认证，2表示签名认证。
527	EncryptionType *string `json:"EncryptionType,omitempty" name:"EncryptionType"`
528
529	// 连接类型 可以填写 wifi cellular else
530	NetType *string `json:"NetType,omitempty" name:"NetType"`
531
532	// 数据协议 (1 使用物模型 2 为自定义)
533	DataProtocol *int64 `json:"DataProtocol,omitempty" name:"DataProtocol"`
534
535	// 产品描述
536	ProductDesc *string `json:"ProductDesc,omitempty" name:"ProductDesc"`
537
538	// 产品的项目ID
539	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
540}
541
542func (r *CreateStudioProductRequest) ToJsonString() string {
543    b, _ := json.Marshal(r)
544    return string(b)
545}
546
547// It is highly **NOT** recommended to use this function
548// because it has no param check, nor strict type check
549func (r *CreateStudioProductRequest) FromJsonString(s string) error {
550	f := make(map[string]interface{})
551	if err := json.Unmarshal([]byte(s), &f); err != nil {
552		return err
553	}
554	delete(f, "ProductName")
555	delete(f, "CategoryId")
556	delete(f, "ProductType")
557	delete(f, "EncryptionType")
558	delete(f, "NetType")
559	delete(f, "DataProtocol")
560	delete(f, "ProductDesc")
561	delete(f, "ProjectId")
562	if len(f) > 0 {
563		return errors.New("CreateStudioProductRequest has unknown keys!")
564	}
565	return json.Unmarshal([]byte(s), &r)
566}
567
568type CreateStudioProductResponse struct {
569	*tchttp.BaseResponse
570	Response *struct {
571
572		// 产品描述
573		Product *ProductEntry `json:"Product,omitempty" name:"Product"`
574
575		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
576		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
577	} `json:"Response"`
578}
579
580func (r *CreateStudioProductResponse) ToJsonString() string {
581    b, _ := json.Marshal(r)
582    return string(b)
583}
584
585// It is highly **NOT** recommended to use this function
586// because it has no param check, nor strict type check
587func (r *CreateStudioProductResponse) FromJsonString(s string) error {
588	return json.Unmarshal([]byte(s), &r)
589}
590
591type CreateTopicRuleRequest struct {
592	*tchttp.BaseRequest
593
594	// 规则名称
595	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
596
597	// 规则内容
598	TopicRulePayload *TopicRulePayload `json:"TopicRulePayload,omitempty" name:"TopicRulePayload"`
599}
600
601func (r *CreateTopicRuleRequest) ToJsonString() string {
602    b, _ := json.Marshal(r)
603    return string(b)
604}
605
606// It is highly **NOT** recommended to use this function
607// because it has no param check, nor strict type check
608func (r *CreateTopicRuleRequest) FromJsonString(s string) error {
609	f := make(map[string]interface{})
610	if err := json.Unmarshal([]byte(s), &f); err != nil {
611		return err
612	}
613	delete(f, "RuleName")
614	delete(f, "TopicRulePayload")
615	if len(f) > 0 {
616		return errors.New("CreateTopicRuleRequest has unknown keys!")
617	}
618	return json.Unmarshal([]byte(s), &r)
619}
620
621type CreateTopicRuleResponse struct {
622	*tchttp.BaseResponse
623	Response *struct {
624
625		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
626		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
627	} `json:"Response"`
628}
629
630func (r *CreateTopicRuleResponse) ToJsonString() string {
631    b, _ := json.Marshal(r)
632    return string(b)
633}
634
635// It is highly **NOT** recommended to use this function
636// because it has no param check, nor strict type check
637func (r *CreateTopicRuleResponse) FromJsonString(s string) error {
638	return json.Unmarshal([]byte(s), &r)
639}
640
641type DeleteDeviceRequest struct {
642	*tchttp.BaseRequest
643
644	// 产品ID。
645	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
646
647	// 设备名称。
648	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
649}
650
651func (r *DeleteDeviceRequest) ToJsonString() string {
652    b, _ := json.Marshal(r)
653    return string(b)
654}
655
656// It is highly **NOT** recommended to use this function
657// because it has no param check, nor strict type check
658func (r *DeleteDeviceRequest) FromJsonString(s string) error {
659	f := make(map[string]interface{})
660	if err := json.Unmarshal([]byte(s), &f); err != nil {
661		return err
662	}
663	delete(f, "ProductId")
664	delete(f, "DeviceName")
665	if len(f) > 0 {
666		return errors.New("DeleteDeviceRequest has unknown keys!")
667	}
668	return json.Unmarshal([]byte(s), &r)
669}
670
671type DeleteDeviceResponse struct {
672	*tchttp.BaseResponse
673	Response *struct {
674
675		// 删除的结果代码
676	// 注意：此字段可能返回 null，表示取不到有效值。
677		ResultCode *string `json:"ResultCode,omitempty" name:"ResultCode"`
678
679		// 删除的结果信息
680	// 注意：此字段可能返回 null，表示取不到有效值。
681		ResultMessage *string `json:"ResultMessage,omitempty" name:"ResultMessage"`
682
683		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
684		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
685	} `json:"Response"`
686}
687
688func (r *DeleteDeviceResponse) ToJsonString() string {
689    b, _ := json.Marshal(r)
690    return string(b)
691}
692
693// It is highly **NOT** recommended to use this function
694// because it has no param check, nor strict type check
695func (r *DeleteDeviceResponse) FromJsonString(s string) error {
696	return json.Unmarshal([]byte(s), &r)
697}
698
699type DeleteLoRaFrequencyRequest struct {
700	*tchttp.BaseRequest
701
702	// 频点唯一ID
703	FreqId *string `json:"FreqId,omitempty" name:"FreqId"`
704}
705
706func (r *DeleteLoRaFrequencyRequest) ToJsonString() string {
707    b, _ := json.Marshal(r)
708    return string(b)
709}
710
711// It is highly **NOT** recommended to use this function
712// because it has no param check, nor strict type check
713func (r *DeleteLoRaFrequencyRequest) FromJsonString(s string) error {
714	f := make(map[string]interface{})
715	if err := json.Unmarshal([]byte(s), &f); err != nil {
716		return err
717	}
718	delete(f, "FreqId")
719	if len(f) > 0 {
720		return errors.New("DeleteLoRaFrequencyRequest has unknown keys!")
721	}
722	return json.Unmarshal([]byte(s), &r)
723}
724
725type DeleteLoRaFrequencyResponse struct {
726	*tchttp.BaseResponse
727	Response *struct {
728
729		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
730		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
731	} `json:"Response"`
732}
733
734func (r *DeleteLoRaFrequencyResponse) ToJsonString() string {
735    b, _ := json.Marshal(r)
736    return string(b)
737}
738
739// It is highly **NOT** recommended to use this function
740// because it has no param check, nor strict type check
741func (r *DeleteLoRaFrequencyResponse) FromJsonString(s string) error {
742	return json.Unmarshal([]byte(s), &r)
743}
744
745type DeleteLoRaGatewayRequest struct {
746	*tchttp.BaseRequest
747
748	// LoRa 网关 Id
749	GatewayId *string `json:"GatewayId,omitempty" name:"GatewayId"`
750}
751
752func (r *DeleteLoRaGatewayRequest) ToJsonString() string {
753    b, _ := json.Marshal(r)
754    return string(b)
755}
756
757// It is highly **NOT** recommended to use this function
758// because it has no param check, nor strict type check
759func (r *DeleteLoRaGatewayRequest) FromJsonString(s string) error {
760	f := make(map[string]interface{})
761	if err := json.Unmarshal([]byte(s), &f); err != nil {
762		return err
763	}
764	delete(f, "GatewayId")
765	if len(f) > 0 {
766		return errors.New("DeleteLoRaGatewayRequest has unknown keys!")
767	}
768	return json.Unmarshal([]byte(s), &r)
769}
770
771type DeleteLoRaGatewayResponse struct {
772	*tchttp.BaseResponse
773	Response *struct {
774
775		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
776		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
777	} `json:"Response"`
778}
779
780func (r *DeleteLoRaGatewayResponse) ToJsonString() string {
781    b, _ := json.Marshal(r)
782    return string(b)
783}
784
785// It is highly **NOT** recommended to use this function
786// because it has no param check, nor strict type check
787func (r *DeleteLoRaGatewayResponse) FromJsonString(s string) error {
788	return json.Unmarshal([]byte(s), &r)
789}
790
791type DeleteProjectRequest struct {
792	*tchttp.BaseRequest
793
794	// 项目ID
795	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
796}
797
798func (r *DeleteProjectRequest) ToJsonString() string {
799    b, _ := json.Marshal(r)
800    return string(b)
801}
802
803// It is highly **NOT** recommended to use this function
804// because it has no param check, nor strict type check
805func (r *DeleteProjectRequest) FromJsonString(s string) error {
806	f := make(map[string]interface{})
807	if err := json.Unmarshal([]byte(s), &f); err != nil {
808		return err
809	}
810	delete(f, "ProjectId")
811	if len(f) > 0 {
812		return errors.New("DeleteProjectRequest has unknown keys!")
813	}
814	return json.Unmarshal([]byte(s), &r)
815}
816
817type DeleteProjectResponse struct {
818	*tchttp.BaseResponse
819	Response *struct {
820
821		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
822		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
823	} `json:"Response"`
824}
825
826func (r *DeleteProjectResponse) ToJsonString() string {
827    b, _ := json.Marshal(r)
828    return string(b)
829}
830
831// It is highly **NOT** recommended to use this function
832// because it has no param check, nor strict type check
833func (r *DeleteProjectResponse) FromJsonString(s string) error {
834	return json.Unmarshal([]byte(s), &r)
835}
836
837type DeleteStudioProductRequest struct {
838	*tchttp.BaseRequest
839
840	// 产品ID
841	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
842}
843
844func (r *DeleteStudioProductRequest) ToJsonString() string {
845    b, _ := json.Marshal(r)
846    return string(b)
847}
848
849// It is highly **NOT** recommended to use this function
850// because it has no param check, nor strict type check
851func (r *DeleteStudioProductRequest) FromJsonString(s string) error {
852	f := make(map[string]interface{})
853	if err := json.Unmarshal([]byte(s), &f); err != nil {
854		return err
855	}
856	delete(f, "ProductId")
857	if len(f) > 0 {
858		return errors.New("DeleteStudioProductRequest has unknown keys!")
859	}
860	return json.Unmarshal([]byte(s), &r)
861}
862
863type DeleteStudioProductResponse struct {
864	*tchttp.BaseResponse
865	Response *struct {
866
867		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
868		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
869	} `json:"Response"`
870}
871
872func (r *DeleteStudioProductResponse) ToJsonString() string {
873    b, _ := json.Marshal(r)
874    return string(b)
875}
876
877// It is highly **NOT** recommended to use this function
878// because it has no param check, nor strict type check
879func (r *DeleteStudioProductResponse) FromJsonString(s string) error {
880	return json.Unmarshal([]byte(s), &r)
881}
882
883type DeleteTopicRuleRequest struct {
884	*tchttp.BaseRequest
885
886	// 规则名
887	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
888}
889
890func (r *DeleteTopicRuleRequest) ToJsonString() string {
891    b, _ := json.Marshal(r)
892    return string(b)
893}
894
895// It is highly **NOT** recommended to use this function
896// because it has no param check, nor strict type check
897func (r *DeleteTopicRuleRequest) FromJsonString(s string) error {
898	f := make(map[string]interface{})
899	if err := json.Unmarshal([]byte(s), &f); err != nil {
900		return err
901	}
902	delete(f, "RuleName")
903	if len(f) > 0 {
904		return errors.New("DeleteTopicRuleRequest has unknown keys!")
905	}
906	return json.Unmarshal([]byte(s), &r)
907}
908
909type DeleteTopicRuleResponse struct {
910	*tchttp.BaseResponse
911	Response *struct {
912
913		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
914		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
915	} `json:"Response"`
916}
917
918func (r *DeleteTopicRuleResponse) ToJsonString() string {
919    b, _ := json.Marshal(r)
920    return string(b)
921}
922
923// It is highly **NOT** recommended to use this function
924// because it has no param check, nor strict type check
925func (r *DeleteTopicRuleResponse) FromJsonString(s string) error {
926	return json.Unmarshal([]byte(s), &r)
927}
928
929type DescribeDeviceDataHistoryRequest struct {
930	*tchttp.BaseRequest
931
932	// 区间开始时间（Unix 时间戳，毫秒级）
933	MinTime *uint64 `json:"MinTime,omitempty" name:"MinTime"`
934
935	// 区间结束时间（Unix 时间戳，毫秒级）
936	MaxTime *uint64 `json:"MaxTime,omitempty" name:"MaxTime"`
937
938	// 产品ID
939	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
940
941	// 设备名称
942	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
943
944	// 属性字段名称，对应数据模板中功能属性的标识符
945	FieldName *string `json:"FieldName,omitempty" name:"FieldName"`
946
947	// 返回条数
948	Limit *int64 `json:"Limit,omitempty" name:"Limit"`
949
950	// 检索上下文
951	Context *string `json:"Context,omitempty" name:"Context"`
952}
953
954func (r *DescribeDeviceDataHistoryRequest) ToJsonString() string {
955    b, _ := json.Marshal(r)
956    return string(b)
957}
958
959// It is highly **NOT** recommended to use this function
960// because it has no param check, nor strict type check
961func (r *DescribeDeviceDataHistoryRequest) FromJsonString(s string) error {
962	f := make(map[string]interface{})
963	if err := json.Unmarshal([]byte(s), &f); err != nil {
964		return err
965	}
966	delete(f, "MinTime")
967	delete(f, "MaxTime")
968	delete(f, "ProductId")
969	delete(f, "DeviceName")
970	delete(f, "FieldName")
971	delete(f, "Limit")
972	delete(f, "Context")
973	if len(f) > 0 {
974		return errors.New("DescribeDeviceDataHistoryRequest has unknown keys!")
975	}
976	return json.Unmarshal([]byte(s), &r)
977}
978
979type DescribeDeviceDataHistoryResponse struct {
980	*tchttp.BaseResponse
981	Response *struct {
982
983		// 属性字段名称，对应数据模板中功能属性的标识符
984	// 注意：此字段可能返回 null，表示取不到有效值。
985		FieldName *string `json:"FieldName,omitempty" name:"FieldName"`
986
987		// 数据是否已全部返回，true 表示数据全部返回，false 表示还有数据待返回，可将 Context 作为入参，继续查询返回结果。
988	// 注意：此字段可能返回 null，表示取不到有效值。
989		Listover *bool `json:"Listover,omitempty" name:"Listover"`
990
991		// 检索上下文，当 ListOver 为false时，可以用此上下文，继续读取后续数据
992	// 注意：此字段可能返回 null，表示取不到有效值。
993		Context *string `json:"Context,omitempty" name:"Context"`
994
995		// 历史数据结果数组，返回对应时间点及取值。
996	// 注意：此字段可能返回 null，表示取不到有效值。
997		Results []*DeviceDataHistoryItem `json:"Results,omitempty" name:"Results" list`
998
999		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1000		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1001	} `json:"Response"`
1002}
1003
1004func (r *DescribeDeviceDataHistoryResponse) ToJsonString() string {
1005    b, _ := json.Marshal(r)
1006    return string(b)
1007}
1008
1009// It is highly **NOT** recommended to use this function
1010// because it has no param check, nor strict type check
1011func (r *DescribeDeviceDataHistoryResponse) FromJsonString(s string) error {
1012	return json.Unmarshal([]byte(s), &r)
1013}
1014
1015type DescribeDeviceDataRequest struct {
1016	*tchttp.BaseRequest
1017
1018	// 产品ID
1019	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1020
1021	// 设备名称
1022	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
1023
1024	// 设备ID，该字段有值将代替 ProductId/DeviceName
1025	DeviceId *string `json:"DeviceId,omitempty" name:"DeviceId"`
1026}
1027
1028func (r *DescribeDeviceDataRequest) ToJsonString() string {
1029    b, _ := json.Marshal(r)
1030    return string(b)
1031}
1032
1033// It is highly **NOT** recommended to use this function
1034// because it has no param check, nor strict type check
1035func (r *DescribeDeviceDataRequest) FromJsonString(s string) error {
1036	f := make(map[string]interface{})
1037	if err := json.Unmarshal([]byte(s), &f); err != nil {
1038		return err
1039	}
1040	delete(f, "ProductId")
1041	delete(f, "DeviceName")
1042	delete(f, "DeviceId")
1043	if len(f) > 0 {
1044		return errors.New("DescribeDeviceDataRequest has unknown keys!")
1045	}
1046	return json.Unmarshal([]byte(s), &r)
1047}
1048
1049type DescribeDeviceDataResponse struct {
1050	*tchttp.BaseResponse
1051	Response *struct {
1052
1053		// 设备数据
1054		Data *string `json:"Data,omitempty" name:"Data"`
1055
1056		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1057		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1058	} `json:"Response"`
1059}
1060
1061func (r *DescribeDeviceDataResponse) ToJsonString() string {
1062    b, _ := json.Marshal(r)
1063    return string(b)
1064}
1065
1066// It is highly **NOT** recommended to use this function
1067// because it has no param check, nor strict type check
1068func (r *DescribeDeviceDataResponse) FromJsonString(s string) error {
1069	return json.Unmarshal([]byte(s), &r)
1070}
1071
1072type DescribeDeviceRequest struct {
1073	*tchttp.BaseRequest
1074
1075	// 产品ID
1076	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1077
1078	// 设备名
1079	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
1080
1081	// 设备ID，该字段有值将代替 ProductId/DeviceName
1082	DeviceId *string `json:"DeviceId,omitempty" name:"DeviceId"`
1083}
1084
1085func (r *DescribeDeviceRequest) ToJsonString() string {
1086    b, _ := json.Marshal(r)
1087    return string(b)
1088}
1089
1090// It is highly **NOT** recommended to use this function
1091// because it has no param check, nor strict type check
1092func (r *DescribeDeviceRequest) FromJsonString(s string) error {
1093	f := make(map[string]interface{})
1094	if err := json.Unmarshal([]byte(s), &f); err != nil {
1095		return err
1096	}
1097	delete(f, "ProductId")
1098	delete(f, "DeviceName")
1099	delete(f, "DeviceId")
1100	if len(f) > 0 {
1101		return errors.New("DescribeDeviceRequest has unknown keys!")
1102	}
1103	return json.Unmarshal([]byte(s), &r)
1104}
1105
1106type DescribeDeviceResponse struct {
1107	*tchttp.BaseResponse
1108	Response *struct {
1109
1110		// 设备信息
1111		Device *DeviceInfo `json:"Device,omitempty" name:"Device"`
1112
1113		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1114		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1115	} `json:"Response"`
1116}
1117
1118func (r *DescribeDeviceResponse) ToJsonString() string {
1119    b, _ := json.Marshal(r)
1120    return string(b)
1121}
1122
1123// It is highly **NOT** recommended to use this function
1124// because it has no param check, nor strict type check
1125func (r *DescribeDeviceResponse) FromJsonString(s string) error {
1126	return json.Unmarshal([]byte(s), &r)
1127}
1128
1129type DescribeFirmwareTaskRequest struct {
1130	*tchttp.BaseRequest
1131
1132	// 产品ID
1133	ProductID *string `json:"ProductID,omitempty" name:"ProductID"`
1134
1135	// 固件版本号
1136	FirmwareVersion *string `json:"FirmwareVersion,omitempty" name:"FirmwareVersion"`
1137
1138	// 固件任务ID
1139	TaskId *uint64 `json:"TaskId,omitempty" name:"TaskId"`
1140}
1141
1142func (r *DescribeFirmwareTaskRequest) ToJsonString() string {
1143    b, _ := json.Marshal(r)
1144    return string(b)
1145}
1146
1147// It is highly **NOT** recommended to use this function
1148// because it has no param check, nor strict type check
1149func (r *DescribeFirmwareTaskRequest) FromJsonString(s string) error {
1150	f := make(map[string]interface{})
1151	if err := json.Unmarshal([]byte(s), &f); err != nil {
1152		return err
1153	}
1154	delete(f, "ProductID")
1155	delete(f, "FirmwareVersion")
1156	delete(f, "TaskId")
1157	if len(f) > 0 {
1158		return errors.New("DescribeFirmwareTaskRequest has unknown keys!")
1159	}
1160	return json.Unmarshal([]byte(s), &r)
1161}
1162
1163type DescribeFirmwareTaskResponse struct {
1164	*tchttp.BaseResponse
1165	Response *struct {
1166
1167		// 固件任务ID
1168	// 注意：此字段可能返回 null，表示取不到有效值。
1169		TaskId *uint64 `json:"TaskId,omitempty" name:"TaskId"`
1170
1171		// 固件任务状态
1172	// 注意：此字段可能返回 null，表示取不到有效值。
1173		Status *int64 `json:"Status,omitempty" name:"Status"`
1174
1175		// 固件任务创建时间，单位：秒
1176	// 注意：此字段可能返回 null，表示取不到有效值。
1177		CreateTime *int64 `json:"CreateTime,omitempty" name:"CreateTime"`
1178
1179		// 固件任务升级类型
1180	// 注意：此字段可能返回 null，表示取不到有效值。
1181		Type *int64 `json:"Type,omitempty" name:"Type"`
1182
1183		// 产品名称
1184	// 注意：此字段可能返回 null，表示取不到有效值。
1185		ProductName *string `json:"ProductName,omitempty" name:"ProductName"`
1186
1187		// 固件任务升级模式。originalVersion（按版本号升级）、filename（提交文件升级）、devicenames（按设备名称升级）
1188	// 注意：此字段可能返回 null，表示取不到有效值。
1189		UpgradeMode *string `json:"UpgradeMode,omitempty" name:"UpgradeMode"`
1190
1191		// 产品ID
1192	// 注意：此字段可能返回 null，表示取不到有效值。
1193		ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1194
1195		// 原始固件版本号，在UpgradeMode是originalVersion升级模式下会返回
1196	// 注意：此字段可能返回 null，表示取不到有效值。
1197		OriginalVersion *string `json:"OriginalVersion,omitempty" name:"OriginalVersion"`
1198
1199		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1200		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1201	} `json:"Response"`
1202}
1203
1204func (r *DescribeFirmwareTaskResponse) ToJsonString() string {
1205    b, _ := json.Marshal(r)
1206    return string(b)
1207}
1208
1209// It is highly **NOT** recommended to use this function
1210// because it has no param check, nor strict type check
1211func (r *DescribeFirmwareTaskResponse) FromJsonString(s string) error {
1212	return json.Unmarshal([]byte(s), &r)
1213}
1214
1215type DescribeLoRaFrequencyRequest struct {
1216	*tchttp.BaseRequest
1217
1218	// 频点唯一ID
1219	FreqId *string `json:"FreqId,omitempty" name:"FreqId"`
1220}
1221
1222func (r *DescribeLoRaFrequencyRequest) ToJsonString() string {
1223    b, _ := json.Marshal(r)
1224    return string(b)
1225}
1226
1227// It is highly **NOT** recommended to use this function
1228// because it has no param check, nor strict type check
1229func (r *DescribeLoRaFrequencyRequest) FromJsonString(s string) error {
1230	f := make(map[string]interface{})
1231	if err := json.Unmarshal([]byte(s), &f); err != nil {
1232		return err
1233	}
1234	delete(f, "FreqId")
1235	if len(f) > 0 {
1236		return errors.New("DescribeLoRaFrequencyRequest has unknown keys!")
1237	}
1238	return json.Unmarshal([]byte(s), &r)
1239}
1240
1241type DescribeLoRaFrequencyResponse struct {
1242	*tchttp.BaseResponse
1243	Response *struct {
1244
1245		// 返回详情项
1246	// 注意：此字段可能返回 null，表示取不到有效值。
1247		Data *LoRaFrequencyEntry `json:"Data,omitempty" name:"Data"`
1248
1249		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1250		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1251	} `json:"Response"`
1252}
1253
1254func (r *DescribeLoRaFrequencyResponse) ToJsonString() string {
1255    b, _ := json.Marshal(r)
1256    return string(b)
1257}
1258
1259// It is highly **NOT** recommended to use this function
1260// because it has no param check, nor strict type check
1261func (r *DescribeLoRaFrequencyResponse) FromJsonString(s string) error {
1262	return json.Unmarshal([]byte(s), &r)
1263}
1264
1265type DescribeModelDefinitionRequest struct {
1266	*tchttp.BaseRequest
1267
1268	// 产品ID
1269	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1270}
1271
1272func (r *DescribeModelDefinitionRequest) ToJsonString() string {
1273    b, _ := json.Marshal(r)
1274    return string(b)
1275}
1276
1277// It is highly **NOT** recommended to use this function
1278// because it has no param check, nor strict type check
1279func (r *DescribeModelDefinitionRequest) FromJsonString(s string) error {
1280	f := make(map[string]interface{})
1281	if err := json.Unmarshal([]byte(s), &f); err != nil {
1282		return err
1283	}
1284	delete(f, "ProductId")
1285	if len(f) > 0 {
1286		return errors.New("DescribeModelDefinitionRequest has unknown keys!")
1287	}
1288	return json.Unmarshal([]byte(s), &r)
1289}
1290
1291type DescribeModelDefinitionResponse struct {
1292	*tchttp.BaseResponse
1293	Response *struct {
1294
1295		// 产品数据模板
1296		Model *ProductModelDefinition `json:"Model,omitempty" name:"Model"`
1297
1298		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1299		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1300	} `json:"Response"`
1301}
1302
1303func (r *DescribeModelDefinitionResponse) ToJsonString() string {
1304    b, _ := json.Marshal(r)
1305    return string(b)
1306}
1307
1308// It is highly **NOT** recommended to use this function
1309// because it has no param check, nor strict type check
1310func (r *DescribeModelDefinitionResponse) FromJsonString(s string) error {
1311	return json.Unmarshal([]byte(s), &r)
1312}
1313
1314type DescribeProjectRequest struct {
1315	*tchttp.BaseRequest
1316
1317	// 项目ID
1318	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
1319}
1320
1321func (r *DescribeProjectRequest) ToJsonString() string {
1322    b, _ := json.Marshal(r)
1323    return string(b)
1324}
1325
1326// It is highly **NOT** recommended to use this function
1327// because it has no param check, nor strict type check
1328func (r *DescribeProjectRequest) FromJsonString(s string) error {
1329	f := make(map[string]interface{})
1330	if err := json.Unmarshal([]byte(s), &f); err != nil {
1331		return err
1332	}
1333	delete(f, "ProjectId")
1334	if len(f) > 0 {
1335		return errors.New("DescribeProjectRequest has unknown keys!")
1336	}
1337	return json.Unmarshal([]byte(s), &r)
1338}
1339
1340type DescribeProjectResponse struct {
1341	*tchttp.BaseResponse
1342	Response *struct {
1343
1344		// 返回信息
1345		Project *ProjectEntryEx `json:"Project,omitempty" name:"Project"`
1346
1347		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1348		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1349	} `json:"Response"`
1350}
1351
1352func (r *DescribeProjectResponse) ToJsonString() string {
1353    b, _ := json.Marshal(r)
1354    return string(b)
1355}
1356
1357// It is highly **NOT** recommended to use this function
1358// because it has no param check, nor strict type check
1359func (r *DescribeProjectResponse) FromJsonString(s string) error {
1360	return json.Unmarshal([]byte(s), &r)
1361}
1362
1363type DescribeStudioProductRequest struct {
1364	*tchttp.BaseRequest
1365
1366	// 产品ID
1367	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1368}
1369
1370func (r *DescribeStudioProductRequest) ToJsonString() string {
1371    b, _ := json.Marshal(r)
1372    return string(b)
1373}
1374
1375// It is highly **NOT** recommended to use this function
1376// because it has no param check, nor strict type check
1377func (r *DescribeStudioProductRequest) FromJsonString(s string) error {
1378	f := make(map[string]interface{})
1379	if err := json.Unmarshal([]byte(s), &f); err != nil {
1380		return err
1381	}
1382	delete(f, "ProductId")
1383	if len(f) > 0 {
1384		return errors.New("DescribeStudioProductRequest has unknown keys!")
1385	}
1386	return json.Unmarshal([]byte(s), &r)
1387}
1388
1389type DescribeStudioProductResponse struct {
1390	*tchttp.BaseResponse
1391	Response *struct {
1392
1393		// 产品详情
1394		Product *ProductEntry `json:"Product,omitempty" name:"Product"`
1395
1396		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1397		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1398	} `json:"Response"`
1399}
1400
1401func (r *DescribeStudioProductResponse) ToJsonString() string {
1402    b, _ := json.Marshal(r)
1403    return string(b)
1404}
1405
1406// It is highly **NOT** recommended to use this function
1407// because it has no param check, nor strict type check
1408func (r *DescribeStudioProductResponse) FromJsonString(s string) error {
1409	return json.Unmarshal([]byte(s), &r)
1410}
1411
1412type DescribeTopicRuleRequest struct {
1413	*tchttp.BaseRequest
1414
1415	// 规则名称。
1416	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
1417}
1418
1419func (r *DescribeTopicRuleRequest) ToJsonString() string {
1420    b, _ := json.Marshal(r)
1421    return string(b)
1422}
1423
1424// It is highly **NOT** recommended to use this function
1425// because it has no param check, nor strict type check
1426func (r *DescribeTopicRuleRequest) FromJsonString(s string) error {
1427	f := make(map[string]interface{})
1428	if err := json.Unmarshal([]byte(s), &f); err != nil {
1429		return err
1430	}
1431	delete(f, "RuleName")
1432	if len(f) > 0 {
1433		return errors.New("DescribeTopicRuleRequest has unknown keys!")
1434	}
1435	return json.Unmarshal([]byte(s), &r)
1436}
1437
1438type DescribeTopicRuleResponse struct {
1439	*tchttp.BaseResponse
1440	Response *struct {
1441
1442		// 规则描述。
1443	// 注意：此字段可能返回 null，表示取不到有效值。
1444		Rule *TopicRule `json:"Rule,omitempty" name:"Rule"`
1445
1446		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1447		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1448	} `json:"Response"`
1449}
1450
1451func (r *DescribeTopicRuleResponse) ToJsonString() string {
1452    b, _ := json.Marshal(r)
1453    return string(b)
1454}
1455
1456// It is highly **NOT** recommended to use this function
1457// because it has no param check, nor strict type check
1458func (r *DescribeTopicRuleResponse) FromJsonString(s string) error {
1459	return json.Unmarshal([]byte(s), &r)
1460}
1461
1462type DeviceData struct {
1463
1464	// 设备证书，用于 TLS 建立链接时校验客户端身份。采用非对称加密时返回该参数。
1465	// 注意：此字段可能返回 null，表示取不到有效值。
1466	DeviceCert *string `json:"DeviceCert,omitempty" name:"DeviceCert"`
1467
1468	// 设备名称。
1469	// 注意：此字段可能返回 null，表示取不到有效值。
1470	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
1471
1472	// 设备私钥，用于 TLS 建立链接时校验客户端身份，腾讯云后台不保存，请妥善保管。采用非对称加密时返回该参数。
1473	// 注意：此字段可能返回 null，表示取不到有效值。
1474	DevicePrivateKey *string `json:"DevicePrivateKey,omitempty" name:"DevicePrivateKey"`
1475
1476	// 对称加密密钥，base64编码。采用对称加密时返回该参数。
1477	// 注意：此字段可能返回 null，表示取不到有效值。
1478	DevicePsk *string `json:"DevicePsk,omitempty" name:"DevicePsk"`
1479}
1480
1481type DeviceDataHistoryItem struct {
1482
1483	// 时间点，毫秒时间戳
1484	Time *string `json:"Time,omitempty" name:"Time"`
1485
1486	// 字段取值
1487	Value *string `json:"Value,omitempty" name:"Value"`
1488}
1489
1490type DeviceInfo struct {
1491
1492	// 设备名
1493	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
1494
1495	// 0: 离线, 1: 在线, 2: 获取失败, 3 未激活
1496	Status *int64 `json:"Status,omitempty" name:"Status"`
1497
1498	// 设备密钥，密钥加密的设备返回
1499	DevicePsk *string `json:"DevicePsk,omitempty" name:"DevicePsk"`
1500
1501	// 首次上线时间
1502	// 注意：此字段可能返回 null，表示取不到有效值。
1503	// 注意：此字段可能返回 null，表示取不到有效值。
1504	FirstOnlineTime *int64 `json:"FirstOnlineTime,omitempty" name:"FirstOnlineTime"`
1505
1506	// 最后一次上线时间
1507	// 注意：此字段可能返回 null，表示取不到有效值。
1508	LoginTime *int64 `json:"LoginTime,omitempty" name:"LoginTime"`
1509
1510	// 设备创建时间
1511	// 注意：此字段可能返回 null，表示取不到有效值。
1512	CreateTime *int64 `json:"CreateTime,omitempty" name:"CreateTime"`
1513
1514	// 设备固件版本
1515	// 注意：此字段可能返回 null，表示取不到有效值。
1516	Version *string `json:"Version,omitempty" name:"Version"`
1517
1518	// 设备证书
1519	// 注意：此字段可能返回 null，表示取不到有效值。
1520	DeviceCert *string `json:"DeviceCert,omitempty" name:"DeviceCert"`
1521
1522	// 日志级别
1523	// 注意：此字段可能返回 null，表示取不到有效值。
1524	LogLevel *int64 `json:"LogLevel,omitempty" name:"LogLevel"`
1525
1526	// LoRaWAN 设备地址
1527	// 注意：此字段可能返回 null，表示取不到有效值。
1528	DevAddr *string `json:"DevAddr,omitempty" name:"DevAddr"`
1529
1530	// LoRaWAN 应用密钥
1531	// 注意：此字段可能返回 null，表示取不到有效值。
1532	AppKey *string `json:"AppKey,omitempty" name:"AppKey"`
1533
1534	// LoRaWAN 设备唯一标识
1535	// 注意：此字段可能返回 null，表示取不到有效值。
1536	DevEUI *string `json:"DevEUI,omitempty" name:"DevEUI"`
1537
1538	// LoRaWAN 应用会话密钥
1539	// 注意：此字段可能返回 null，表示取不到有效值。
1540	AppSKey *string `json:"AppSKey,omitempty" name:"AppSKey"`
1541
1542	// LoRaWAN 网络会话密钥
1543	// 注意：此字段可能返回 null，表示取不到有效值。
1544	NwkSKey *string `json:"NwkSKey,omitempty" name:"NwkSKey"`
1545}
1546
1547type DisableTopicRuleRequest struct {
1548	*tchttp.BaseRequest
1549
1550	// 规则名称
1551	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
1552}
1553
1554func (r *DisableTopicRuleRequest) ToJsonString() string {
1555    b, _ := json.Marshal(r)
1556    return string(b)
1557}
1558
1559// It is highly **NOT** recommended to use this function
1560// because it has no param check, nor strict type check
1561func (r *DisableTopicRuleRequest) FromJsonString(s string) error {
1562	f := make(map[string]interface{})
1563	if err := json.Unmarshal([]byte(s), &f); err != nil {
1564		return err
1565	}
1566	delete(f, "RuleName")
1567	if len(f) > 0 {
1568		return errors.New("DisableTopicRuleRequest has unknown keys!")
1569	}
1570	return json.Unmarshal([]byte(s), &r)
1571}
1572
1573type DisableTopicRuleResponse struct {
1574	*tchttp.BaseResponse
1575	Response *struct {
1576
1577		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1578		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1579	} `json:"Response"`
1580}
1581
1582func (r *DisableTopicRuleResponse) ToJsonString() string {
1583    b, _ := json.Marshal(r)
1584    return string(b)
1585}
1586
1587// It is highly **NOT** recommended to use this function
1588// because it has no param check, nor strict type check
1589func (r *DisableTopicRuleResponse) FromJsonString(s string) error {
1590	return json.Unmarshal([]byte(s), &r)
1591}
1592
1593type EnableTopicRuleRequest struct {
1594	*tchttp.BaseRequest
1595
1596	// 规则名称
1597	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
1598}
1599
1600func (r *EnableTopicRuleRequest) ToJsonString() string {
1601    b, _ := json.Marshal(r)
1602    return string(b)
1603}
1604
1605// It is highly **NOT** recommended to use this function
1606// because it has no param check, nor strict type check
1607func (r *EnableTopicRuleRequest) FromJsonString(s string) error {
1608	f := make(map[string]interface{})
1609	if err := json.Unmarshal([]byte(s), &f); err != nil {
1610		return err
1611	}
1612	delete(f, "RuleName")
1613	if len(f) > 0 {
1614		return errors.New("EnableTopicRuleRequest has unknown keys!")
1615	}
1616	return json.Unmarshal([]byte(s), &r)
1617}
1618
1619type EnableTopicRuleResponse struct {
1620	*tchttp.BaseResponse
1621	Response *struct {
1622
1623		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1624		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1625	} `json:"Response"`
1626}
1627
1628func (r *EnableTopicRuleResponse) ToJsonString() string {
1629    b, _ := json.Marshal(r)
1630    return string(b)
1631}
1632
1633// It is highly **NOT** recommended to use this function
1634// because it has no param check, nor strict type check
1635func (r *EnableTopicRuleResponse) FromJsonString(s string) error {
1636	return json.Unmarshal([]byte(s), &r)
1637}
1638
1639type EventHistoryItem struct {
1640
1641	// 事件的时间戳
1642	// 注意：此字段可能返回 null，表示取不到有效值。
1643	TimeStamp *int64 `json:"TimeStamp,omitempty" name:"TimeStamp"`
1644
1645	// 事件的产品ID
1646	// 注意：此字段可能返回 null，表示取不到有效值。
1647	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1648
1649	// 事件的设备名称
1650	// 注意：此字段可能返回 null，表示取不到有效值。
1651	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
1652
1653	// 事件的标识符ID
1654	// 注意：此字段可能返回 null，表示取不到有效值。
1655	EventId *string `json:"EventId,omitempty" name:"EventId"`
1656
1657	// 事件的类型
1658	// 注意：此字段可能返回 null，表示取不到有效值。
1659	Type *string `json:"Type,omitempty" name:"Type"`
1660
1661	// 事件的数据
1662	// 注意：此字段可能返回 null，表示取不到有效值。
1663	Data *string `json:"Data,omitempty" name:"Data"`
1664}
1665
1666type FirmwareInfo struct {
1667
1668	// 固件版本
1669	Version *string `json:"Version,omitempty" name:"Version"`
1670
1671	// 固件MD5值
1672	Md5sum *string `json:"Md5sum,omitempty" name:"Md5sum"`
1673
1674	// 固件创建时间
1675	CreateTime *uint64 `json:"CreateTime,omitempty" name:"CreateTime"`
1676
1677	// 产品名称
1678	// 注意：此字段可能返回 null，表示取不到有效值。
1679	ProductName *string `json:"ProductName,omitempty" name:"ProductName"`
1680
1681	// 固件名称
1682	// 注意：此字段可能返回 null，表示取不到有效值。
1683	Name *string `json:"Name,omitempty" name:"Name"`
1684
1685	// 固件描述
1686	// 注意：此字段可能返回 null，表示取不到有效值。
1687	Description *string `json:"Description,omitempty" name:"Description"`
1688
1689	// 产品ID
1690	// 注意：此字段可能返回 null，表示取不到有效值。
1691	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1692}
1693
1694type GetCOSURLRequest struct {
1695	*tchttp.BaseRequest
1696
1697	// 产品ID
1698	ProductID *string `json:"ProductID,omitempty" name:"ProductID"`
1699
1700	// 固件版本
1701	FirmwareVersion *string `json:"FirmwareVersion,omitempty" name:"FirmwareVersion"`
1702
1703	// 文件大小
1704	FileSize *uint64 `json:"FileSize,omitempty" name:"FileSize"`
1705}
1706
1707func (r *GetCOSURLRequest) ToJsonString() string {
1708    b, _ := json.Marshal(r)
1709    return string(b)
1710}
1711
1712// It is highly **NOT** recommended to use this function
1713// because it has no param check, nor strict type check
1714func (r *GetCOSURLRequest) FromJsonString(s string) error {
1715	f := make(map[string]interface{})
1716	if err := json.Unmarshal([]byte(s), &f); err != nil {
1717		return err
1718	}
1719	delete(f, "ProductID")
1720	delete(f, "FirmwareVersion")
1721	delete(f, "FileSize")
1722	if len(f) > 0 {
1723		return errors.New("GetCOSURLRequest has unknown keys!")
1724	}
1725	return json.Unmarshal([]byte(s), &r)
1726}
1727
1728type GetCOSURLResponse struct {
1729	*tchttp.BaseResponse
1730	Response *struct {
1731
1732		// 固件URL
1733		Url *string `json:"Url,omitempty" name:"Url"`
1734
1735		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1736		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1737	} `json:"Response"`
1738}
1739
1740func (r *GetCOSURLResponse) ToJsonString() string {
1741    b, _ := json.Marshal(r)
1742    return string(b)
1743}
1744
1745// It is highly **NOT** recommended to use this function
1746// because it has no param check, nor strict type check
1747func (r *GetCOSURLResponse) FromJsonString(s string) error {
1748	return json.Unmarshal([]byte(s), &r)
1749}
1750
1751type GetDeviceListRequest struct {
1752	*tchttp.BaseRequest
1753
1754	// 需要查看设备列表的产品 ID
1755	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
1756
1757	// 分页偏移
1758	Offset *int64 `json:"Offset,omitempty" name:"Offset"`
1759
1760	// 分页的大小，数值范围 10-100
1761	Limit *int64 `json:"Limit,omitempty" name:"Limit"`
1762
1763	// 设备固件版本号，若不带此参数会返回所有固件版本的设备。传"None-FirmwareVersion"查询无版本号的设备
1764	FirmwareVersion *string `json:"FirmwareVersion,omitempty" name:"FirmwareVersion"`
1765
1766	// 需要过滤的设备名称
1767	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
1768}
1769
1770func (r *GetDeviceListRequest) ToJsonString() string {
1771    b, _ := json.Marshal(r)
1772    return string(b)
1773}
1774
1775// It is highly **NOT** recommended to use this function
1776// because it has no param check, nor strict type check
1777func (r *GetDeviceListRequest) FromJsonString(s string) error {
1778	f := make(map[string]interface{})
1779	if err := json.Unmarshal([]byte(s), &f); err != nil {
1780		return err
1781	}
1782	delete(f, "ProductId")
1783	delete(f, "Offset")
1784	delete(f, "Limit")
1785	delete(f, "FirmwareVersion")
1786	delete(f, "DeviceName")
1787	if len(f) > 0 {
1788		return errors.New("GetDeviceListRequest has unknown keys!")
1789	}
1790	return json.Unmarshal([]byte(s), &r)
1791}
1792
1793type GetDeviceListResponse struct {
1794	*tchttp.BaseResponse
1795	Response *struct {
1796
1797		// 返回的设备列表, 注意列表设备的 DevicePsk 为空, 要获取设备的 DevicePsk 请使用 DescribeDevice
1798	// 注意：此字段可能返回 null，表示取不到有效值。
1799		Devices []*DeviceInfo `json:"Devices,omitempty" name:"Devices" list`
1800
1801		// 产品下的设备总数
1802	// 注意：此字段可能返回 null，表示取不到有效值。
1803		Total *int64 `json:"Total,omitempty" name:"Total"`
1804
1805		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1806		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1807	} `json:"Response"`
1808}
1809
1810func (r *GetDeviceListResponse) ToJsonString() string {
1811    b, _ := json.Marshal(r)
1812    return string(b)
1813}
1814
1815// It is highly **NOT** recommended to use this function
1816// because it has no param check, nor strict type check
1817func (r *GetDeviceListResponse) FromJsonString(s string) error {
1818	return json.Unmarshal([]byte(s), &r)
1819}
1820
1821type GetLoRaGatewayListRequest struct {
1822	*tchttp.BaseRequest
1823
1824	// 是否是社区网关
1825	IsCommunity *bool `json:"IsCommunity,omitempty" name:"IsCommunity"`
1826
1827	// 偏移量
1828	Offset *uint64 `json:"Offset,omitempty" name:"Offset"`
1829
1830	// 限制个数
1831	Limit *uint64 `json:"Limit,omitempty" name:"Limit"`
1832}
1833
1834func (r *GetLoRaGatewayListRequest) ToJsonString() string {
1835    b, _ := json.Marshal(r)
1836    return string(b)
1837}
1838
1839// It is highly **NOT** recommended to use this function
1840// because it has no param check, nor strict type check
1841func (r *GetLoRaGatewayListRequest) FromJsonString(s string) error {
1842	f := make(map[string]interface{})
1843	if err := json.Unmarshal([]byte(s), &f); err != nil {
1844		return err
1845	}
1846	delete(f, "IsCommunity")
1847	delete(f, "Offset")
1848	delete(f, "Limit")
1849	if len(f) > 0 {
1850		return errors.New("GetLoRaGatewayListRequest has unknown keys!")
1851	}
1852	return json.Unmarshal([]byte(s), &r)
1853}
1854
1855type GetLoRaGatewayListResponse struct {
1856	*tchttp.BaseResponse
1857	Response *struct {
1858
1859		// 返回总数
1860		Total *uint64 `json:"Total,omitempty" name:"Total"`
1861
1862		// 返回详情项
1863	// 注意：此字段可能返回 null，表示取不到有效值。
1864		Gateways []*LoRaGatewayItem `json:"Gateways,omitempty" name:"Gateways" list`
1865
1866		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1867		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1868	} `json:"Response"`
1869}
1870
1871func (r *GetLoRaGatewayListResponse) ToJsonString() string {
1872    b, _ := json.Marshal(r)
1873    return string(b)
1874}
1875
1876// It is highly **NOT** recommended to use this function
1877// because it has no param check, nor strict type check
1878func (r *GetLoRaGatewayListResponse) FromJsonString(s string) error {
1879	return json.Unmarshal([]byte(s), &r)
1880}
1881
1882type GetProjectListRequest struct {
1883	*tchttp.BaseRequest
1884
1885	// 偏移量
1886	Offset *int64 `json:"Offset,omitempty" name:"Offset"`
1887
1888	// 个数限制
1889	Limit *int64 `json:"Limit,omitempty" name:"Limit"`
1890
1891	// 实例ID
1892	InstanceId *string `json:"InstanceId,omitempty" name:"InstanceId"`
1893}
1894
1895func (r *GetProjectListRequest) ToJsonString() string {
1896    b, _ := json.Marshal(r)
1897    return string(b)
1898}
1899
1900// It is highly **NOT** recommended to use this function
1901// because it has no param check, nor strict type check
1902func (r *GetProjectListRequest) FromJsonString(s string) error {
1903	f := make(map[string]interface{})
1904	if err := json.Unmarshal([]byte(s), &f); err != nil {
1905		return err
1906	}
1907	delete(f, "Offset")
1908	delete(f, "Limit")
1909	delete(f, "InstanceId")
1910	if len(f) > 0 {
1911		return errors.New("GetProjectListRequest has unknown keys!")
1912	}
1913	return json.Unmarshal([]byte(s), &r)
1914}
1915
1916type GetProjectListResponse struct {
1917	*tchttp.BaseResponse
1918	Response *struct {
1919
1920		// 项目列表
1921	// 注意：此字段可能返回 null，表示取不到有效值。
1922		Projects []*ProjectEntryEx `json:"Projects,omitempty" name:"Projects" list`
1923
1924		// 列表项个数
1925	// 注意：此字段可能返回 null，表示取不到有效值。
1926		Total *int64 `json:"Total,omitempty" name:"Total"`
1927
1928		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1929		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1930	} `json:"Response"`
1931}
1932
1933func (r *GetProjectListResponse) ToJsonString() string {
1934    b, _ := json.Marshal(r)
1935    return string(b)
1936}
1937
1938// It is highly **NOT** recommended to use this function
1939// because it has no param check, nor strict type check
1940func (r *GetProjectListResponse) FromJsonString(s string) error {
1941	return json.Unmarshal([]byte(s), &r)
1942}
1943
1944type GetStudioProductListRequest struct {
1945	*tchttp.BaseRequest
1946
1947	// 项目ID
1948	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
1949
1950	// 产品DevStatus
1951	DevStatus *string `json:"DevStatus,omitempty" name:"DevStatus"`
1952
1953	// Offset
1954	Offset *uint64 `json:"Offset,omitempty" name:"Offset"`
1955
1956	// Limit
1957	Limit *uint64 `json:"Limit,omitempty" name:"Limit"`
1958}
1959
1960func (r *GetStudioProductListRequest) ToJsonString() string {
1961    b, _ := json.Marshal(r)
1962    return string(b)
1963}
1964
1965// It is highly **NOT** recommended to use this function
1966// because it has no param check, nor strict type check
1967func (r *GetStudioProductListRequest) FromJsonString(s string) error {
1968	f := make(map[string]interface{})
1969	if err := json.Unmarshal([]byte(s), &f); err != nil {
1970		return err
1971	}
1972	delete(f, "ProjectId")
1973	delete(f, "DevStatus")
1974	delete(f, "Offset")
1975	delete(f, "Limit")
1976	if len(f) > 0 {
1977		return errors.New("GetStudioProductListRequest has unknown keys!")
1978	}
1979	return json.Unmarshal([]byte(s), &r)
1980}
1981
1982type GetStudioProductListResponse struct {
1983	*tchttp.BaseResponse
1984	Response *struct {
1985
1986		// 产品列表
1987		Products []*ProductEntry `json:"Products,omitempty" name:"Products" list`
1988
1989		// 产品数量
1990		Total *int64 `json:"Total,omitempty" name:"Total"`
1991
1992		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1993		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
1994	} `json:"Response"`
1995}
1996
1997func (r *GetStudioProductListResponse) ToJsonString() string {
1998    b, _ := json.Marshal(r)
1999    return string(b)
2000}
2001
2002// It is highly **NOT** recommended to use this function
2003// because it has no param check, nor strict type check
2004func (r *GetStudioProductListResponse) FromJsonString(s string) error {
2005	return json.Unmarshal([]byte(s), &r)
2006}
2007
2008type GetTopicRuleListRequest struct {
2009	*tchttp.BaseRequest
2010
2011	// 请求的页数
2012	PageNum *int64 `json:"PageNum,omitempty" name:"PageNum"`
2013
2014	// 分页的大小
2015	PageSize *int64 `json:"PageSize,omitempty" name:"PageSize"`
2016}
2017
2018func (r *GetTopicRuleListRequest) ToJsonString() string {
2019    b, _ := json.Marshal(r)
2020    return string(b)
2021}
2022
2023// It is highly **NOT** recommended to use this function
2024// because it has no param check, nor strict type check
2025func (r *GetTopicRuleListRequest) FromJsonString(s string) error {
2026	f := make(map[string]interface{})
2027	if err := json.Unmarshal([]byte(s), &f); err != nil {
2028		return err
2029	}
2030	delete(f, "PageNum")
2031	delete(f, "PageSize")
2032	if len(f) > 0 {
2033		return errors.New("GetTopicRuleListRequest has unknown keys!")
2034	}
2035	return json.Unmarshal([]byte(s), &r)
2036}
2037
2038type GetTopicRuleListResponse struct {
2039	*tchttp.BaseResponse
2040	Response *struct {
2041
2042		// 规则总数量
2043		TotalCnt *int64 `json:"TotalCnt,omitempty" name:"TotalCnt"`
2044
2045		// 规则列表
2046		Rules []*TopicRuleInfo `json:"Rules,omitempty" name:"Rules" list`
2047
2048		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2049		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2050	} `json:"Response"`
2051}
2052
2053func (r *GetTopicRuleListResponse) ToJsonString() string {
2054    b, _ := json.Marshal(r)
2055    return string(b)
2056}
2057
2058// It is highly **NOT** recommended to use this function
2059// because it has no param check, nor strict type check
2060func (r *GetTopicRuleListResponse) FromJsonString(s string) error {
2061	return json.Unmarshal([]byte(s), &r)
2062}
2063
2064type ListEventHistoryRequest struct {
2065	*tchttp.BaseRequest
2066
2067	// 产品ID
2068	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2069
2070	// 设备名称
2071	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
2072
2073	// 搜索的事件类型：alert 表示告警，fault 表示故障，info 表示信息，为空则表示查询上述所有类型事件
2074	Type *string `json:"Type,omitempty" name:"Type"`
2075
2076	// 起始时间（Unix 时间戳，秒级）, 为0 表示 当前时间 - 24h
2077	StartTime *int64 `json:"StartTime,omitempty" name:"StartTime"`
2078
2079	// 结束时间（Unix 时间戳，秒级）, 为0 表示当前时间
2080	EndTime *uint64 `json:"EndTime,omitempty" name:"EndTime"`
2081
2082	// 搜索上下文, 用作查询游标
2083	Context *string `json:"Context,omitempty" name:"Context"`
2084
2085	// 单次获取的历史数据项目的最大数量, 缺省10
2086	Size *int64 `json:"Size,omitempty" name:"Size"`
2087
2088	// 事件标识符，可以用来指定查询特定的事件，如果不指定，则查询所有事件。
2089	EventId *string `json:"EventId,omitempty" name:"EventId"`
2090}
2091
2092func (r *ListEventHistoryRequest) ToJsonString() string {
2093    b, _ := json.Marshal(r)
2094    return string(b)
2095}
2096
2097// It is highly **NOT** recommended to use this function
2098// because it has no param check, nor strict type check
2099func (r *ListEventHistoryRequest) FromJsonString(s string) error {
2100	f := make(map[string]interface{})
2101	if err := json.Unmarshal([]byte(s), &f); err != nil {
2102		return err
2103	}
2104	delete(f, "ProductId")
2105	delete(f, "DeviceName")
2106	delete(f, "Type")
2107	delete(f, "StartTime")
2108	delete(f, "EndTime")
2109	delete(f, "Context")
2110	delete(f, "Size")
2111	delete(f, "EventId")
2112	if len(f) > 0 {
2113		return errors.New("ListEventHistoryRequest has unknown keys!")
2114	}
2115	return json.Unmarshal([]byte(s), &r)
2116}
2117
2118type ListEventHistoryResponse struct {
2119	*tchttp.BaseResponse
2120	Response *struct {
2121
2122		// 搜索上下文, 用作查询游标
2123	// 注意：此字段可能返回 null，表示取不到有效值。
2124		Context *string `json:"Context,omitempty" name:"Context"`
2125
2126		// 搜索结果数量
2127	// 注意：此字段可能返回 null，表示取不到有效值。
2128		Total *int64 `json:"Total,omitempty" name:"Total"`
2129
2130		// 搜索结果是否已经结束
2131	// 注意：此字段可能返回 null，表示取不到有效值。
2132		Listover *bool `json:"Listover,omitempty" name:"Listover"`
2133
2134		// 搜集结果集
2135	// 注意：此字段可能返回 null，表示取不到有效值。
2136		EventHistory []*EventHistoryItem `json:"EventHistory,omitempty" name:"EventHistory" list`
2137
2138		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2139		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2140	} `json:"Response"`
2141}
2142
2143func (r *ListEventHistoryResponse) ToJsonString() string {
2144    b, _ := json.Marshal(r)
2145    return string(b)
2146}
2147
2148// It is highly **NOT** recommended to use this function
2149// because it has no param check, nor strict type check
2150func (r *ListEventHistoryResponse) FromJsonString(s string) error {
2151	return json.Unmarshal([]byte(s), &r)
2152}
2153
2154type ListFirmwaresRequest struct {
2155	*tchttp.BaseRequest
2156
2157	// 获取的页数
2158	PageNum *uint64 `json:"PageNum,omitempty" name:"PageNum"`
2159
2160	// 分页的大小
2161	PageSize *uint64 `json:"PageSize,omitempty" name:"PageSize"`
2162
2163	// 产品ID
2164	ProductID *string `json:"ProductID,omitempty" name:"ProductID"`
2165
2166	// 搜索过滤条件
2167	Filters []*SearchKeyword `json:"Filters,omitempty" name:"Filters" list`
2168}
2169
2170func (r *ListFirmwaresRequest) ToJsonString() string {
2171    b, _ := json.Marshal(r)
2172    return string(b)
2173}
2174
2175// It is highly **NOT** recommended to use this function
2176// because it has no param check, nor strict type check
2177func (r *ListFirmwaresRequest) FromJsonString(s string) error {
2178	f := make(map[string]interface{})
2179	if err := json.Unmarshal([]byte(s), &f); err != nil {
2180		return err
2181	}
2182	delete(f, "PageNum")
2183	delete(f, "PageSize")
2184	delete(f, "ProductID")
2185	delete(f, "Filters")
2186	if len(f) > 0 {
2187		return errors.New("ListFirmwaresRequest has unknown keys!")
2188	}
2189	return json.Unmarshal([]byte(s), &r)
2190}
2191
2192type ListFirmwaresResponse struct {
2193	*tchttp.BaseResponse
2194	Response *struct {
2195
2196		// 固件总数
2197		TotalCount *uint64 `json:"TotalCount,omitempty" name:"TotalCount"`
2198
2199		// 固件列表
2200		Firmwares []*FirmwareInfo `json:"Firmwares,omitempty" name:"Firmwares" list`
2201
2202		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2203		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2204	} `json:"Response"`
2205}
2206
2207func (r *ListFirmwaresResponse) ToJsonString() string {
2208    b, _ := json.Marshal(r)
2209    return string(b)
2210}
2211
2212// It is highly **NOT** recommended to use this function
2213// because it has no param check, nor strict type check
2214func (r *ListFirmwaresResponse) FromJsonString(s string) error {
2215	return json.Unmarshal([]byte(s), &r)
2216}
2217
2218type LoRaFrequencyEntry struct {
2219
2220	// 频点唯一ID
2221	FreqId *string `json:"FreqId,omitempty" name:"FreqId"`
2222
2223	// 频点名称
2224	FreqName *string `json:"FreqName,omitempty" name:"FreqName"`
2225
2226	// 频点描述
2227	Description *string `json:"Description,omitempty" name:"Description"`
2228
2229	// 数据上行信道
2230	ChannelsDataUp []*uint64 `json:"ChannelsDataUp,omitempty" name:"ChannelsDataUp" list`
2231
2232	// 数据下行信道RX1
2233	ChannelsDataRX1 []*uint64 `json:"ChannelsDataRX1,omitempty" name:"ChannelsDataRX1" list`
2234
2235	// 数据下行信道RX2
2236	ChannelsDataRX2 []*uint64 `json:"ChannelsDataRX2,omitempty" name:"ChannelsDataRX2" list`
2237
2238	// 入网上行信道
2239	ChannelsJoinUp []*uint64 `json:"ChannelsJoinUp,omitempty" name:"ChannelsJoinUp" list`
2240
2241	// 入网下行RX1信道
2242	ChannelsJoinRX1 []*uint64 `json:"ChannelsJoinRX1,omitempty" name:"ChannelsJoinRX1" list`
2243
2244	// 入网下行RX2信道
2245	ChannelsJoinRX2 []*uint64 `json:"ChannelsJoinRX2,omitempty" name:"ChannelsJoinRX2" list`
2246
2247	// 创建时间
2248	CreateTime *int64 `json:"CreateTime,omitempty" name:"CreateTime"`
2249}
2250
2251type LoRaGatewayItem struct {
2252
2253	// LoRa 网关Id
2254	GatewayId *string `json:"GatewayId,omitempty" name:"GatewayId"`
2255
2256	// 是否是公开网关
2257	IsPublic *bool `json:"IsPublic,omitempty" name:"IsPublic"`
2258
2259	// 网关描述
2260	Description *string `json:"Description,omitempty" name:"Description"`
2261
2262	// 网关名称
2263	Name *string `json:"Name,omitempty" name:"Name"`
2264
2265	// 网关位置信息
2266	Position *string `json:"Position,omitempty" name:"Position"`
2267
2268	// 网关位置详情
2269	PositionDetails *string `json:"PositionDetails,omitempty" name:"PositionDetails"`
2270
2271	// LoRa 网关位置坐标
2272	Location *LoRaGatewayLocation `json:"Location,omitempty" name:"Location"`
2273
2274	// 最后更新时间
2275	UpdatedAt *string `json:"UpdatedAt,omitempty" name:"UpdatedAt"`
2276
2277	// 创建时间
2278	CreatedAt *string `json:"CreatedAt,omitempty" name:"CreatedAt"`
2279
2280	// 最后上报时间
2281	LastSeenAt *string `json:"LastSeenAt,omitempty" name:"LastSeenAt"`
2282
2283	// 频点ID
2284	FrequencyId *string `json:"FrequencyId,omitempty" name:"FrequencyId"`
2285}
2286
2287type LoRaGatewayLocation struct {
2288
2289	// 准确度
2290	Accuracy *float64 `json:"Accuracy,omitempty" name:"Accuracy"`
2291
2292	// 海拔
2293	Altitude *float64 `json:"Altitude,omitempty" name:"Altitude"`
2294
2295	// 纬度
2296	Latitude *float64 `json:"Latitude,omitempty" name:"Latitude"`
2297
2298	// 精度
2299	Longitude *float64 `json:"Longitude,omitempty" name:"Longitude"`
2300}
2301
2302type ModifyLoRaFrequencyRequest struct {
2303	*tchttp.BaseRequest
2304
2305	// 频点唯一ID
2306	FreqId *string `json:"FreqId,omitempty" name:"FreqId"`
2307
2308	// 频点名称
2309	FreqName *string `json:"FreqName,omitempty" name:"FreqName"`
2310
2311	// 频点描述
2312	Description *string `json:"Description,omitempty" name:"Description"`
2313
2314	// 数据上行信道
2315	ChannelsDataUp []*uint64 `json:"ChannelsDataUp,omitempty" name:"ChannelsDataUp" list`
2316
2317	// 数据下行信道RX1
2318	ChannelsDataRX1 []*uint64 `json:"ChannelsDataRX1,omitempty" name:"ChannelsDataRX1" list`
2319
2320	// 数据下行信道RX2
2321	ChannelsDataRX2 []*uint64 `json:"ChannelsDataRX2,omitempty" name:"ChannelsDataRX2" list`
2322
2323	// 入网上行信道
2324	ChannelsJoinUp []*uint64 `json:"ChannelsJoinUp,omitempty" name:"ChannelsJoinUp" list`
2325
2326	// 入网下行信道RX1
2327	ChannelsJoinRX1 []*uint64 `json:"ChannelsJoinRX1,omitempty" name:"ChannelsJoinRX1" list`
2328
2329	// 入网下行信道RX2
2330	ChannelsJoinRX2 []*uint64 `json:"ChannelsJoinRX2,omitempty" name:"ChannelsJoinRX2" list`
2331}
2332
2333func (r *ModifyLoRaFrequencyRequest) ToJsonString() string {
2334    b, _ := json.Marshal(r)
2335    return string(b)
2336}
2337
2338// It is highly **NOT** recommended to use this function
2339// because it has no param check, nor strict type check
2340func (r *ModifyLoRaFrequencyRequest) FromJsonString(s string) error {
2341	f := make(map[string]interface{})
2342	if err := json.Unmarshal([]byte(s), &f); err != nil {
2343		return err
2344	}
2345	delete(f, "FreqId")
2346	delete(f, "FreqName")
2347	delete(f, "Description")
2348	delete(f, "ChannelsDataUp")
2349	delete(f, "ChannelsDataRX1")
2350	delete(f, "ChannelsDataRX2")
2351	delete(f, "ChannelsJoinUp")
2352	delete(f, "ChannelsJoinRX1")
2353	delete(f, "ChannelsJoinRX2")
2354	if len(f) > 0 {
2355		return errors.New("ModifyLoRaFrequencyRequest has unknown keys!")
2356	}
2357	return json.Unmarshal([]byte(s), &r)
2358}
2359
2360type ModifyLoRaFrequencyResponse struct {
2361	*tchttp.BaseResponse
2362	Response *struct {
2363
2364		// 频点信息
2365		Data *LoRaFrequencyEntry `json:"Data,omitempty" name:"Data"`
2366
2367		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2368		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2369	} `json:"Response"`
2370}
2371
2372func (r *ModifyLoRaFrequencyResponse) ToJsonString() string {
2373    b, _ := json.Marshal(r)
2374    return string(b)
2375}
2376
2377// It is highly **NOT** recommended to use this function
2378// because it has no param check, nor strict type check
2379func (r *ModifyLoRaFrequencyResponse) FromJsonString(s string) error {
2380	return json.Unmarshal([]byte(s), &r)
2381}
2382
2383type ModifyLoRaGatewayRequest struct {
2384	*tchttp.BaseRequest
2385
2386	// 描述信息
2387	Description *string `json:"Description,omitempty" name:"Description"`
2388
2389	// LoRa网关Id
2390	GatewayId *string `json:"GatewayId,omitempty" name:"GatewayId"`
2391
2392	// LoRa网关位置坐标
2393	Location *LoRaGatewayLocation `json:"Location,omitempty" name:"Location"`
2394
2395	// LoRa网关名称
2396	Name *string `json:"Name,omitempty" name:"Name"`
2397
2398	// 是否公开可见
2399	IsPublic *bool `json:"IsPublic,omitempty" name:"IsPublic"`
2400
2401	// 位置信息
2402	Position *string `json:"Position,omitempty" name:"Position"`
2403
2404	// 位置详情
2405	PositionDetails *string `json:"PositionDetails,omitempty" name:"PositionDetails"`
2406
2407	// 频点ID
2408	FrequencyId *string `json:"FrequencyId,omitempty" name:"FrequencyId"`
2409}
2410
2411func (r *ModifyLoRaGatewayRequest) ToJsonString() string {
2412    b, _ := json.Marshal(r)
2413    return string(b)
2414}
2415
2416// It is highly **NOT** recommended to use this function
2417// because it has no param check, nor strict type check
2418func (r *ModifyLoRaGatewayRequest) FromJsonString(s string) error {
2419	f := make(map[string]interface{})
2420	if err := json.Unmarshal([]byte(s), &f); err != nil {
2421		return err
2422	}
2423	delete(f, "Description")
2424	delete(f, "GatewayId")
2425	delete(f, "Location")
2426	delete(f, "Name")
2427	delete(f, "IsPublic")
2428	delete(f, "Position")
2429	delete(f, "PositionDetails")
2430	delete(f, "FrequencyId")
2431	if len(f) > 0 {
2432		return errors.New("ModifyLoRaGatewayRequest has unknown keys!")
2433	}
2434	return json.Unmarshal([]byte(s), &r)
2435}
2436
2437type ModifyLoRaGatewayResponse struct {
2438	*tchttp.BaseResponse
2439	Response *struct {
2440
2441		// 返回网关数据
2442		Gateway *LoRaGatewayItem `json:"Gateway,omitempty" name:"Gateway"`
2443
2444		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2445		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2446	} `json:"Response"`
2447}
2448
2449func (r *ModifyLoRaGatewayResponse) ToJsonString() string {
2450    b, _ := json.Marshal(r)
2451    return string(b)
2452}
2453
2454// It is highly **NOT** recommended to use this function
2455// because it has no param check, nor strict type check
2456func (r *ModifyLoRaGatewayResponse) FromJsonString(s string) error {
2457	return json.Unmarshal([]byte(s), &r)
2458}
2459
2460type ModifyModelDefinitionRequest struct {
2461	*tchttp.BaseRequest
2462
2463	// 产品ID
2464	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2465
2466	// 数据模板定义
2467	ModelSchema *string `json:"ModelSchema,omitempty" name:"ModelSchema"`
2468}
2469
2470func (r *ModifyModelDefinitionRequest) ToJsonString() string {
2471    b, _ := json.Marshal(r)
2472    return string(b)
2473}
2474
2475// It is highly **NOT** recommended to use this function
2476// because it has no param check, nor strict type check
2477func (r *ModifyModelDefinitionRequest) FromJsonString(s string) error {
2478	f := make(map[string]interface{})
2479	if err := json.Unmarshal([]byte(s), &f); err != nil {
2480		return err
2481	}
2482	delete(f, "ProductId")
2483	delete(f, "ModelSchema")
2484	if len(f) > 0 {
2485		return errors.New("ModifyModelDefinitionRequest has unknown keys!")
2486	}
2487	return json.Unmarshal([]byte(s), &r)
2488}
2489
2490type ModifyModelDefinitionResponse struct {
2491	*tchttp.BaseResponse
2492	Response *struct {
2493
2494		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2495		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2496	} `json:"Response"`
2497}
2498
2499func (r *ModifyModelDefinitionResponse) ToJsonString() string {
2500    b, _ := json.Marshal(r)
2501    return string(b)
2502}
2503
2504// It is highly **NOT** recommended to use this function
2505// because it has no param check, nor strict type check
2506func (r *ModifyModelDefinitionResponse) FromJsonString(s string) error {
2507	return json.Unmarshal([]byte(s), &r)
2508}
2509
2510type ModifyProjectRequest struct {
2511	*tchttp.BaseRequest
2512
2513	// 项目ID
2514	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
2515
2516	// 项目名称
2517	ProjectName *string `json:"ProjectName,omitempty" name:"ProjectName"`
2518
2519	// 项目描述
2520	ProjectDesc *string `json:"ProjectDesc,omitempty" name:"ProjectDesc"`
2521}
2522
2523func (r *ModifyProjectRequest) ToJsonString() string {
2524    b, _ := json.Marshal(r)
2525    return string(b)
2526}
2527
2528// It is highly **NOT** recommended to use this function
2529// because it has no param check, nor strict type check
2530func (r *ModifyProjectRequest) FromJsonString(s string) error {
2531	f := make(map[string]interface{})
2532	if err := json.Unmarshal([]byte(s), &f); err != nil {
2533		return err
2534	}
2535	delete(f, "ProjectId")
2536	delete(f, "ProjectName")
2537	delete(f, "ProjectDesc")
2538	if len(f) > 0 {
2539		return errors.New("ModifyProjectRequest has unknown keys!")
2540	}
2541	return json.Unmarshal([]byte(s), &r)
2542}
2543
2544type ModifyProjectResponse struct {
2545	*tchttp.BaseResponse
2546	Response *struct {
2547
2548		// 项目详情
2549		Project *ProjectEntry `json:"Project,omitempty" name:"Project"`
2550
2551		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2552		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2553	} `json:"Response"`
2554}
2555
2556func (r *ModifyProjectResponse) ToJsonString() string {
2557    b, _ := json.Marshal(r)
2558    return string(b)
2559}
2560
2561// It is highly **NOT** recommended to use this function
2562// because it has no param check, nor strict type check
2563func (r *ModifyProjectResponse) FromJsonString(s string) error {
2564	return json.Unmarshal([]byte(s), &r)
2565}
2566
2567type ModifyStudioProductRequest struct {
2568	*tchttp.BaseRequest
2569
2570	// 产品ID
2571	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2572
2573	// 产品名称
2574	ProductName *string `json:"ProductName,omitempty" name:"ProductName"`
2575
2576	// 产品描述
2577	ProductDesc *string `json:"ProductDesc,omitempty" name:"ProductDesc"`
2578
2579	// 模型ID
2580	ModuleId *int64 `json:"ModuleId,omitempty" name:"ModuleId"`
2581
2582	// 是否打开二进制转Json功能, 取值为字符串 true/false
2583	EnableProductScript *string `json:"EnableProductScript,omitempty" name:"EnableProductScript"`
2584}
2585
2586func (r *ModifyStudioProductRequest) ToJsonString() string {
2587    b, _ := json.Marshal(r)
2588    return string(b)
2589}
2590
2591// It is highly **NOT** recommended to use this function
2592// because it has no param check, nor strict type check
2593func (r *ModifyStudioProductRequest) FromJsonString(s string) error {
2594	f := make(map[string]interface{})
2595	if err := json.Unmarshal([]byte(s), &f); err != nil {
2596		return err
2597	}
2598	delete(f, "ProductId")
2599	delete(f, "ProductName")
2600	delete(f, "ProductDesc")
2601	delete(f, "ModuleId")
2602	delete(f, "EnableProductScript")
2603	if len(f) > 0 {
2604		return errors.New("ModifyStudioProductRequest has unknown keys!")
2605	}
2606	return json.Unmarshal([]byte(s), &r)
2607}
2608
2609type ModifyStudioProductResponse struct {
2610	*tchttp.BaseResponse
2611	Response *struct {
2612
2613		// 产品描述
2614		Product *ProductEntry `json:"Product,omitempty" name:"Product"`
2615
2616		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2617		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2618	} `json:"Response"`
2619}
2620
2621func (r *ModifyStudioProductResponse) ToJsonString() string {
2622    b, _ := json.Marshal(r)
2623    return string(b)
2624}
2625
2626// It is highly **NOT** recommended to use this function
2627// because it has no param check, nor strict type check
2628func (r *ModifyStudioProductResponse) FromJsonString(s string) error {
2629	return json.Unmarshal([]byte(s), &r)
2630}
2631
2632type ModifyTopicRuleRequest struct {
2633	*tchttp.BaseRequest
2634
2635	// 规则名称
2636	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
2637
2638	// 替换的规则包体
2639	TopicRulePayload *TopicRulePayload `json:"TopicRulePayload,omitempty" name:"TopicRulePayload"`
2640}
2641
2642func (r *ModifyTopicRuleRequest) ToJsonString() string {
2643    b, _ := json.Marshal(r)
2644    return string(b)
2645}
2646
2647// It is highly **NOT** recommended to use this function
2648// because it has no param check, nor strict type check
2649func (r *ModifyTopicRuleRequest) FromJsonString(s string) error {
2650	f := make(map[string]interface{})
2651	if err := json.Unmarshal([]byte(s), &f); err != nil {
2652		return err
2653	}
2654	delete(f, "RuleName")
2655	delete(f, "TopicRulePayload")
2656	if len(f) > 0 {
2657		return errors.New("ModifyTopicRuleRequest has unknown keys!")
2658	}
2659	return json.Unmarshal([]byte(s), &r)
2660}
2661
2662type ModifyTopicRuleResponse struct {
2663	*tchttp.BaseResponse
2664	Response *struct {
2665
2666		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2667		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2668	} `json:"Response"`
2669}
2670
2671func (r *ModifyTopicRuleResponse) ToJsonString() string {
2672    b, _ := json.Marshal(r)
2673    return string(b)
2674}
2675
2676// It is highly **NOT** recommended to use this function
2677// because it has no param check, nor strict type check
2678func (r *ModifyTopicRuleResponse) FromJsonString(s string) error {
2679	return json.Unmarshal([]byte(s), &r)
2680}
2681
2682type ProductEntry struct {
2683
2684	// 产品ID
2685	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2686
2687	// 产品名称
2688	ProductName *string `json:"ProductName,omitempty" name:"ProductName"`
2689
2690	// 产品分组模板ID
2691	CategoryId *int64 `json:"CategoryId,omitempty" name:"CategoryId"`
2692
2693	// 加密类型
2694	EncryptionType *string `json:"EncryptionType,omitempty" name:"EncryptionType"`
2695
2696	// 连接类型
2697	NetType *string `json:"NetType,omitempty" name:"NetType"`
2698
2699	// 数据协议
2700	DataProtocol *int64 `json:"DataProtocol,omitempty" name:"DataProtocol"`
2701
2702	// 产品描述
2703	ProductDesc *string `json:"ProductDesc,omitempty" name:"ProductDesc"`
2704
2705	// 状态
2706	DevStatus *string `json:"DevStatus,omitempty" name:"DevStatus"`
2707
2708	// 创建时间
2709	CreateTime *uint64 `json:"CreateTime,omitempty" name:"CreateTime"`
2710
2711	// 更新时间
2712	UpdateTime *uint64 `json:"UpdateTime,omitempty" name:"UpdateTime"`
2713
2714	// 区域
2715	Region *string `json:"Region,omitempty" name:"Region"`
2716
2717	// 产品类型
2718	ProductType *int64 `json:"ProductType,omitempty" name:"ProductType"`
2719
2720	// 项目ID
2721	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
2722
2723	// 产品ModuleId
2724	ModuleId *int64 `json:"ModuleId,omitempty" name:"ModuleId"`
2725
2726	// 是否使用脚本进行二进制转json功能 可以取值 true / false
2727	// 注意：此字段可能返回 null，表示取不到有效值。
2728	EnableProductScript *string `json:"EnableProductScript,omitempty" name:"EnableProductScript"`
2729}
2730
2731type ProductModelDefinition struct {
2732
2733	// 产品ID
2734	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2735
2736	// 模型定义
2737	ModelDefine *string `json:"ModelDefine,omitempty" name:"ModelDefine"`
2738
2739	// 更新时间，秒级时间戳
2740	UpdateTime *int64 `json:"UpdateTime,omitempty" name:"UpdateTime"`
2741
2742	// 创建时间，秒级时间戳
2743	CreateTime *int64 `json:"CreateTime,omitempty" name:"CreateTime"`
2744
2745	// 产品所属分类的模型快照（产品创建时刻的）
2746	// 注意：此字段可能返回 null，表示取不到有效值。
2747	CategoryModel *string `json:"CategoryModel,omitempty" name:"CategoryModel"`
2748
2749	// 产品的连接类型的模型
2750	// 注意：此字段可能返回 null，表示取不到有效值。
2751	NetTypeModel *string `json:"NetTypeModel,omitempty" name:"NetTypeModel"`
2752}
2753
2754type ProjectEntry struct {
2755
2756	// 项目ID
2757	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
2758
2759	// 项目名称
2760	ProjectName *string `json:"ProjectName,omitempty" name:"ProjectName"`
2761
2762	// 项目描述
2763	ProjectDesc *string `json:"ProjectDesc,omitempty" name:"ProjectDesc"`
2764
2765	// 创建时间，unix时间戳
2766	CreateTime *uint64 `json:"CreateTime,omitempty" name:"CreateTime"`
2767
2768	// 更新时间，unix时间戳
2769	UpdateTime *uint64 `json:"UpdateTime,omitempty" name:"UpdateTime"`
2770}
2771
2772type ProjectEntryEx struct {
2773
2774	// 项目ID
2775	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
2776
2777	// 项目名称
2778	ProjectName *string `json:"ProjectName,omitempty" name:"ProjectName"`
2779
2780	// 项目描述
2781	ProjectDesc *string `json:"ProjectDesc,omitempty" name:"ProjectDesc"`
2782
2783	// 项目创建时间，unix时间戳
2784	CreateTime *uint64 `json:"CreateTime,omitempty" name:"CreateTime"`
2785
2786	// 项目更新时间，unix时间戳
2787	UpdateTime *uint64 `json:"UpdateTime,omitempty" name:"UpdateTime"`
2788
2789	// 产品数量
2790	ProductCount *uint64 `json:"ProductCount,omitempty" name:"ProductCount"`
2791
2792	// NativeApp数量
2793	NativeAppCount *uint64 `json:"NativeAppCount,omitempty" name:"NativeAppCount"`
2794
2795	// WebApp数量
2796	WebAppCount *uint64 `json:"WebAppCount,omitempty" name:"WebAppCount"`
2797
2798	// 实例ID
2799	// 注意：此字段可能返回 null，表示取不到有效值。
2800	InstanceId *string `json:"InstanceId,omitempty" name:"InstanceId"`
2801}
2802
2803type PublishMessageRequest struct {
2804	*tchttp.BaseRequest
2805
2806	// 产品ID
2807	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2808
2809	// 设备名称
2810	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
2811
2812	// 消息发往的主题
2813	Topic *string `json:"Topic,omitempty" name:"Topic"`
2814
2815	// 云端下发到设备的控制报文
2816	Payload *string `json:"Payload,omitempty" name:"Payload"`
2817
2818	// 消息服务质量等级，取值为0或1
2819	Qos *uint64 `json:"Qos,omitempty" name:"Qos"`
2820
2821	// Payload的内容编码格式，取值为base64或空。base64表示云端将接收到的base64编码后的报文再转换成二进制报文下发至设备，为空表示不作转换，透传下发至设备
2822	PayloadEncoding *string `json:"PayloadEncoding,omitempty" name:"PayloadEncoding"`
2823}
2824
2825func (r *PublishMessageRequest) ToJsonString() string {
2826    b, _ := json.Marshal(r)
2827    return string(b)
2828}
2829
2830// It is highly **NOT** recommended to use this function
2831// because it has no param check, nor strict type check
2832func (r *PublishMessageRequest) FromJsonString(s string) error {
2833	f := make(map[string]interface{})
2834	if err := json.Unmarshal([]byte(s), &f); err != nil {
2835		return err
2836	}
2837	delete(f, "ProductId")
2838	delete(f, "DeviceName")
2839	delete(f, "Topic")
2840	delete(f, "Payload")
2841	delete(f, "Qos")
2842	delete(f, "PayloadEncoding")
2843	if len(f) > 0 {
2844		return errors.New("PublishMessageRequest has unknown keys!")
2845	}
2846	return json.Unmarshal([]byte(s), &r)
2847}
2848
2849type PublishMessageResponse struct {
2850	*tchttp.BaseResponse
2851	Response *struct {
2852
2853		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2854		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2855	} `json:"Response"`
2856}
2857
2858func (r *PublishMessageResponse) ToJsonString() string {
2859    b, _ := json.Marshal(r)
2860    return string(b)
2861}
2862
2863// It is highly **NOT** recommended to use this function
2864// because it has no param check, nor strict type check
2865func (r *PublishMessageResponse) FromJsonString(s string) error {
2866	return json.Unmarshal([]byte(s), &r)
2867}
2868
2869type ReleaseStudioProductRequest struct {
2870	*tchttp.BaseRequest
2871
2872	// 产品ID
2873	ProductId *string `json:"ProductId,omitempty" name:"ProductId"`
2874
2875	// 产品DevStatus
2876	DevStatus *string `json:"DevStatus,omitempty" name:"DevStatus"`
2877}
2878
2879func (r *ReleaseStudioProductRequest) ToJsonString() string {
2880    b, _ := json.Marshal(r)
2881    return string(b)
2882}
2883
2884// It is highly **NOT** recommended to use this function
2885// because it has no param check, nor strict type check
2886func (r *ReleaseStudioProductRequest) FromJsonString(s string) error {
2887	f := make(map[string]interface{})
2888	if err := json.Unmarshal([]byte(s), &f); err != nil {
2889		return err
2890	}
2891	delete(f, "ProductId")
2892	delete(f, "DevStatus")
2893	if len(f) > 0 {
2894		return errors.New("ReleaseStudioProductRequest has unknown keys!")
2895	}
2896	return json.Unmarshal([]byte(s), &r)
2897}
2898
2899type ReleaseStudioProductResponse struct {
2900	*tchttp.BaseResponse
2901	Response *struct {
2902
2903		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2904		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2905	} `json:"Response"`
2906}
2907
2908func (r *ReleaseStudioProductResponse) ToJsonString() string {
2909    b, _ := json.Marshal(r)
2910    return string(b)
2911}
2912
2913// It is highly **NOT** recommended to use this function
2914// because it has no param check, nor strict type check
2915func (r *ReleaseStudioProductResponse) FromJsonString(s string) error {
2916	return json.Unmarshal([]byte(s), &r)
2917}
2918
2919type SearchKeyword struct {
2920
2921	// 搜索条件的Key
2922	Key *string `json:"Key,omitempty" name:"Key"`
2923
2924	// 搜索条件的值
2925	Value *string `json:"Value,omitempty" name:"Value"`
2926}
2927
2928type SearchStudioProductRequest struct {
2929	*tchttp.BaseRequest
2930
2931	// 项目ID
2932	ProjectId *string `json:"ProjectId,omitempty" name:"ProjectId"`
2933
2934	// 产品名称
2935	ProductName *string `json:"ProductName,omitempty" name:"ProductName"`
2936
2937	// 列表Limit
2938	Limit *uint64 `json:"Limit,omitempty" name:"Limit"`
2939
2940	// 列表Offset
2941	Offset *uint64 `json:"Offset,omitempty" name:"Offset"`
2942
2943	// 产品Status
2944	DevStatus *string `json:"DevStatus,omitempty" name:"DevStatus"`
2945}
2946
2947func (r *SearchStudioProductRequest) ToJsonString() string {
2948    b, _ := json.Marshal(r)
2949    return string(b)
2950}
2951
2952// It is highly **NOT** recommended to use this function
2953// because it has no param check, nor strict type check
2954func (r *SearchStudioProductRequest) FromJsonString(s string) error {
2955	f := make(map[string]interface{})
2956	if err := json.Unmarshal([]byte(s), &f); err != nil {
2957		return err
2958	}
2959	delete(f, "ProjectId")
2960	delete(f, "ProductName")
2961	delete(f, "Limit")
2962	delete(f, "Offset")
2963	delete(f, "DevStatus")
2964	if len(f) > 0 {
2965		return errors.New("SearchStudioProductRequest has unknown keys!")
2966	}
2967	return json.Unmarshal([]byte(s), &r)
2968}
2969
2970type SearchStudioProductResponse struct {
2971	*tchttp.BaseResponse
2972	Response *struct {
2973
2974		// 产品列表
2975		Products []*ProductEntry `json:"Products,omitempty" name:"Products" list`
2976
2977		// 产品数量
2978		Total *int64 `json:"Total,omitempty" name:"Total"`
2979
2980		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2981		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
2982	} `json:"Response"`
2983}
2984
2985func (r *SearchStudioProductResponse) ToJsonString() string {
2986    b, _ := json.Marshal(r)
2987    return string(b)
2988}
2989
2990// It is highly **NOT** recommended to use this function
2991// because it has no param check, nor strict type check
2992func (r *SearchStudioProductResponse) FromJsonString(s string) error {
2993	return json.Unmarshal([]byte(s), &r)
2994}
2995
2996type SearchTopicRuleRequest struct {
2997	*tchttp.BaseRequest
2998
2999	// 规则名
3000	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
3001}
3002
3003func (r *SearchTopicRuleRequest) ToJsonString() string {
3004    b, _ := json.Marshal(r)
3005    return string(b)
3006}
3007
3008// It is highly **NOT** recommended to use this function
3009// because it has no param check, nor strict type check
3010func (r *SearchTopicRuleRequest) FromJsonString(s string) error {
3011	f := make(map[string]interface{})
3012	if err := json.Unmarshal([]byte(s), &f); err != nil {
3013		return err
3014	}
3015	delete(f, "RuleName")
3016	if len(f) > 0 {
3017		return errors.New("SearchTopicRuleRequest has unknown keys!")
3018	}
3019	return json.Unmarshal([]byte(s), &r)
3020}
3021
3022type SearchTopicRuleResponse struct {
3023	*tchttp.BaseResponse
3024	Response *struct {
3025
3026		// 搜索到的规则总数
3027		TotalCnt *int64 `json:"TotalCnt,omitempty" name:"TotalCnt"`
3028
3029		// 规则信息列表
3030		Rules []*TopicRuleInfo `json:"Rules,omitempty" name:"Rules" list`
3031
3032		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3033		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
3034	} `json:"Response"`
3035}
3036
3037func (r *SearchTopicRuleResponse) ToJsonString() string {
3038    b, _ := json.Marshal(r)
3039    return string(b)
3040}
3041
3042// It is highly **NOT** recommended to use this function
3043// because it has no param check, nor strict type check
3044func (r *SearchTopicRuleResponse) FromJsonString(s string) error {
3045	return json.Unmarshal([]byte(s), &r)
3046}
3047
3048type TopicRule struct {
3049
3050	// 规则名称。
3051	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
3052
3053	// 规则的SQL语句，如： SELECT * FROM 'pid/dname/event'，然后对其进行base64编码，得：U0VMRUNUICogRlJPTSAncGlkL2RuYW1lL2V2ZW50Jw==
3054	Sql *string `json:"Sql,omitempty" name:"Sql"`
3055
3056	// 规则描述。
3057	// 注意：此字段可能返回 null，表示取不到有效值。
3058	Description *string `json:"Description,omitempty" name:"Description"`
3059
3060	// 行为的JSON字符串。
3061	// 注意：此字段可能返回 null，表示取不到有效值。
3062	Actions *string `json:"Actions,omitempty" name:"Actions"`
3063
3064	// 是否禁用规则
3065	// 注意：此字段可能返回 null，表示取不到有效值。
3066	RuleDisabled *bool `json:"RuleDisabled,omitempty" name:"RuleDisabled"`
3067}
3068
3069type TopicRuleInfo struct {
3070
3071	// 规则名称
3072	RuleName *string `json:"RuleName,omitempty" name:"RuleName"`
3073
3074	// 规则描述
3075	Description *string `json:"Description,omitempty" name:"Description"`
3076
3077	// 创建时间
3078	CreatedAt *int64 `json:"CreatedAt,omitempty" name:"CreatedAt"`
3079
3080	// 规则是否禁用
3081	RuleDisabled *bool `json:"RuleDisabled,omitempty" name:"RuleDisabled"`
3082}
3083
3084type TopicRulePayload struct {
3085
3086	// 规则的SQL语句，如： SELECT * FROM 'pid/dname/event'，然后对其进行base64编码，得：U0VMRUNUICogRlJPTSAncGlkL2RuYW1lL2V2ZW50Jw==
3087	Sql *string `json:"Sql,omitempty" name:"Sql"`
3088
3089	// 行为的JSON字符串，大部分种类举例如下：
3090	// [
3091	// {
3092	// "republish": {
3093	// "topic": "TEST/test"
3094	// }
3095	// },
3096	// {
3097	// "forward": {
3098	// "api": "http://test.com:8080"
3099	// }
3100	// },
3101	// {
3102	// "ckafka": {
3103	// "instance": {
3104	// "id": "ckafka-test",
3105	// "name": ""
3106	// },
3107	// "topic": {
3108	// "id": "topic-test",
3109	// "name": "test"
3110	// },
3111	// "region": "gz"
3112	// }
3113	// },
3114	// {
3115	// "cmqqueue": {
3116	// "queuename": "queue-test-TEST",
3117	// "region": "gz"
3118	// }
3119	// },
3120	// {
3121	// "mysql": {
3122	// "instanceid": "cdb-test",
3123	// "region": "gz",
3124	// "username": "test",
3125	// "userpwd": "*****",
3126	// "dbname": "d_mqtt",
3127	// "tablename": "t_test",
3128	// "fieldpairs": [
3129	// {
3130	// "field": "test",
3131	// "value": "test"
3132	// }
3133	// ],
3134	// "devicetype": "CUSTOM"
3135	// }
3136	// }
3137	// ]
3138	Actions *string `json:"Actions,omitempty" name:"Actions"`
3139
3140	// 规则描述
3141	Description *string `json:"Description,omitempty" name:"Description"`
3142
3143	// 是否禁用规则
3144	RuleDisabled *bool `json:"RuleDisabled,omitempty" name:"RuleDisabled"`
3145}
3146
3147type UpdateFirmwareRequest struct {
3148	*tchttp.BaseRequest
3149
3150	// 产品ID
3151	ProductID *string `json:"ProductID,omitempty" name:"ProductID"`
3152
3153	// 设备名
3154	DeviceName *string `json:"DeviceName,omitempty" name:"DeviceName"`
3155
3156	// 固件新的版本号
3157	FirmwareVersion *string `json:"FirmwareVersion,omitempty" name:"FirmwareVersion"`
3158
3159	// 固件原版本号
3160	FirmwareOriVersion *string `json:"FirmwareOriVersion,omitempty" name:"FirmwareOriVersion"`
3161
3162	// 固件升级方式；0 静默升级 1 用户确认升级   不填默认静默升级
3163	UpgradeMethod *uint64 `json:"UpgradeMethod,omitempty" name:"UpgradeMethod"`
3164}
3165
3166func (r *UpdateFirmwareRequest) ToJsonString() string {
3167    b, _ := json.Marshal(r)
3168    return string(b)
3169}
3170
3171// It is highly **NOT** recommended to use this function
3172// because it has no param check, nor strict type check
3173func (r *UpdateFirmwareRequest) FromJsonString(s string) error {
3174	f := make(map[string]interface{})
3175	if err := json.Unmarshal([]byte(s), &f); err != nil {
3176		return err
3177	}
3178	delete(f, "ProductID")
3179	delete(f, "DeviceName")
3180	delete(f, "FirmwareVersion")
3181	delete(f, "FirmwareOriVersion")
3182	delete(f, "UpgradeMethod")
3183	if len(f) > 0 {
3184		return errors.New("UpdateFirmwareRequest has unknown keys!")
3185	}
3186	return json.Unmarshal([]byte(s), &r)
3187}
3188
3189type UpdateFirmwareResponse struct {
3190	*tchttp.BaseResponse
3191	Response *struct {
3192
3193		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3194		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
3195	} `json:"Response"`
3196}
3197
3198func (r *UpdateFirmwareResponse) ToJsonString() string {
3199    b, _ := json.Marshal(r)
3200    return string(b)
3201}
3202
3203// It is highly **NOT** recommended to use this function
3204// because it has no param check, nor strict type check
3205func (r *UpdateFirmwareResponse) FromJsonString(s string) error {
3206	return json.Unmarshal([]byte(s), &r)
3207}
3208
3209type UploadFirmwareRequest struct {
3210	*tchttp.BaseRequest
3211
3212	// 产品ID
3213	ProductID *string `json:"ProductID,omitempty" name:"ProductID"`
3214
3215	// 固件版本号
3216	FirmwareVersion *string `json:"FirmwareVersion,omitempty" name:"FirmwareVersion"`
3217
3218	// 固件的MD5值
3219	Md5sum *string `json:"Md5sum,omitempty" name:"Md5sum"`
3220
3221	// 固件的大小
3222	FileSize *uint64 `json:"FileSize,omitempty" name:"FileSize"`
3223
3224	// 固件名称
3225	FirmwareName *string `json:"FirmwareName,omitempty" name:"FirmwareName"`
3226
3227	// 固件描述
3228	FirmwareDescription *string `json:"FirmwareDescription,omitempty" name:"FirmwareDescription"`
3229}
3230
3231func (r *UploadFirmwareRequest) ToJsonString() string {
3232    b, _ := json.Marshal(r)
3233    return string(b)
3234}
3235
3236// It is highly **NOT** recommended to use this function
3237// because it has no param check, nor strict type check
3238func (r *UploadFirmwareRequest) FromJsonString(s string) error {
3239	f := make(map[string]interface{})
3240	if err := json.Unmarshal([]byte(s), &f); err != nil {
3241		return err
3242	}
3243	delete(f, "ProductID")
3244	delete(f, "FirmwareVersion")
3245	delete(f, "Md5sum")
3246	delete(f, "FileSize")
3247	delete(f, "FirmwareName")
3248	delete(f, "FirmwareDescription")
3249	if len(f) > 0 {
3250		return errors.New("UploadFirmwareRequest has unknown keys!")
3251	}
3252	return json.Unmarshal([]byte(s), &r)
3253}
3254
3255type UploadFirmwareResponse struct {
3256	*tchttp.BaseResponse
3257	Response *struct {
3258
3259		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3260		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
3261	} `json:"Response"`
3262}
3263
3264func (r *UploadFirmwareResponse) ToJsonString() string {
3265    b, _ := json.Marshal(r)
3266    return string(b)
3267}
3268
3269// It is highly **NOT** recommended to use this function
3270// because it has no param check, nor strict type check
3271func (r *UploadFirmwareResponse) FromJsonString(s string) error {
3272	return json.Unmarshal([]byte(s), &r)
3273}
3274