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