"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ListMaintainInfoResponseBody = exports.ListMaintainInfoRequest = exports.ListMaintainInfoHeaders = exports.ListInspectInfoResponse = exports.ListInspectInfoResponseBody = exports.ListInspectInfoRequest = exports.ListInspectInfoHeaders = exports.ListActivateDevicesResponse = exports.ListActivateDevicesResponseBody = exports.ListActivateDevicesRequest = exports.ListActivateDevicesHeaders = exports.GetWholeDeviceGroupResponse = exports.GetWholeDeviceGroupResponseBody = exports.GetWholeDeviceGroupHeaders = exports.GetDeviceGroupInfoResponse = exports.GetDeviceGroupInfoResponseBody = exports.GetDeviceGroupInfoRequest = exports.GetDeviceGroupInfoHeaders = exports.EditDeviceAdminResponse = exports.EditDeviceAdminResponseBody = exports.EditDeviceAdminRequest = exports.EditDeviceAdminHeaders = exports.DissolveGroupResponse = exports.DissolveGroupResponseBody = exports.DissolveGroupRequest = exports.DissolveGroupHeaders = exports.DeviceDingResponse = exports.DeviceDingResponseBody = exports.DeviceDingRequest = exports.DeviceDingHeaders = exports.CreateDeviceChatRoomResponse = exports.CreateDeviceChatRoomResponseBody = exports.CreateDeviceChatRoomRequest = exports.CreateDeviceChatRoomHeaders = exports.CreateDepartmentResponse = exports.CreateDepartmentResponseBody = exports.CreateDepartmentRequest = exports.CreateDepartmentHeaders = exports.CreateChatRoomResponse = exports.CreateChatRoomResponseBody = exports.CreateChatRoomRequest = exports.CreateChatRoomHeaders = exports.ConnectorEventPushResponse = exports.ConnectorEventPushResponseBody = exports.ConnectorEventPushRequest = exports.ConnectorEventPushHeaders = exports.BatchRegisterDeviceResponse = exports.BatchRegisterDeviceResponseBody = exports.BatchRegisterDeviceRequest = exports.BatchRegisterDeviceHeaders = void 0;
exports.BatchRegisterDeviceRequestDeviceList = exports.UploadEventResponse = exports.UploadEventResponseBody = exports.UploadEventRequest = exports.UploadEventHeaders = exports.UpdateCardResponse = exports.UpdateCardResponseBody = exports.UpdateCardRequest = exports.UpdateCardHeaders = exports.UninstallDeviceRobotResponse = exports.UninstallDeviceRobotResponseBody = exports.UninstallDeviceRobotRequest = exports.UninstallDeviceRobotHeaders = exports.SendMsgResponse = exports.SendMsgResponseBody = exports.SendMsgRequest = exports.SendMsgHeaders = exports.SendCardResponse = exports.SendCardResponseBody = exports.SendCardRequest = exports.SendCardHeaders = exports.RemoveUserFromGroupResponse = exports.RemoveUserFromGroupResponseBody = exports.RemoveUserFromGroupRequest = exports.RemoveUserFromGroupHeaders = exports.RemoveDeviceFromGroupResponse = exports.RemoveDeviceFromGroupResponseBody = exports.RemoveDeviceFromGroupRequest = exports.RemoveDeviceFromGroupHeaders = exports.RegisterDeviceResponse = exports.RegisterDeviceResponseBody = exports.RegisterDeviceRequest = exports.RegisterDeviceHeaders = exports.RegisterAndActivateDeviceBatchResponse = exports.RegisterAndActivateDeviceBatchResponseBody = exports.RegisterAndActivateDeviceBatchRequest = exports.RegisterAndActivateDeviceBatchHeaders = exports.RegisterAndActivateDeviceResponse = exports.RegisterAndActivateDeviceResponseBody = exports.RegisterAndActivateDeviceRequest = exports.RegisterAndActivateDeviceHeaders = exports.PullUserToGroupResponse = exports.PullUserToGroupResponseBody = exports.PullUserToGroupRequest = exports.PullUserToGroupHeaders = exports.PullDeviceToGroupResponse = exports.PullDeviceToGroupResponseBody = exports.PullDeviceToGroupRequest = exports.PullDeviceToGroupHeaders = exports.ListMaintainInfoResponse = void 0;
exports.UpdateCardRequestTips = exports.RegisterAndActivateDeviceBatchResponseBodySuccessItems = exports.RegisterAndActivateDeviceBatchResponseBodySuccessItemsResult = exports.RegisterAndActivateDeviceBatchResponseBodyFailItems = exports.RegisterAndActivateDeviceBatchResponseBodyFailItemsResult = exports.RegisterAndActivateDeviceBatchRequestRegisterAndActivateVOS = exports.RegisterAndActivateDeviceResponseBodyResult = exports.ListMaintainInfoResponseBodyResult = exports.ListInspectInfoResponseBodyResult = exports.ListActivateDevicesResponseBodyResult = exports.GetDeviceGroupInfoResponseBodyResult = exports.GetDeviceGroupInfoResponseBodyResultDevices = exports.CreateDeviceChatRoomResponseBodyResult = void 0;
// This file is auto-generated, don't edit it
/**
 */
const tea_util_1 = __importStar(require("@alicloud/tea-util")), $Util = tea_util_1;
const gateway_dingtalk_1 = __importDefault(require("@alicloud/gateway-dingtalk"));
const openapi_client_1 = __importStar(require("@alicloud/openapi-client")), $OpenApi = openapi_client_1;
const openapi_util_1 = __importDefault(require("@alicloud/openapi-util"));
const $tea = __importStar(require("@alicloud/tea-typescript"));
class BatchRegisterDeviceHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.BatchRegisterDeviceHeaders = BatchRegisterDeviceHeaders;
class BatchRegisterDeviceRequest extends $tea.Model {
    static names() {
        return {
            deviceList: 'deviceList',
            userId: 'userId',
        };
    }
    static types() {
        return {
            deviceList: { 'type': 'array', 'itemType': BatchRegisterDeviceRequestDeviceList },
            userId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.BatchRegisterDeviceRequest = BatchRegisterDeviceRequest;
class BatchRegisterDeviceResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
        };
    }
    static types() {
        return {
            result: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.BatchRegisterDeviceResponseBody = BatchRegisterDeviceResponseBody;
class BatchRegisterDeviceResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: BatchRegisterDeviceResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.BatchRegisterDeviceResponse = BatchRegisterDeviceResponse;
class ConnectorEventPushHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ConnectorEventPushHeaders = ConnectorEventPushHeaders;
class ConnectorEventPushRequest extends $tea.Model {
    static names() {
        return {
            deviceTypeUuid: 'deviceTypeUuid',
            eventName: 'eventName',
            input: 'input',
        };
    }
    static types() {
        return {
            deviceTypeUuid: 'string',
            eventName: 'string',
            input: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ConnectorEventPushRequest = ConnectorEventPushRequest;
class ConnectorEventPushResponseBody extends $tea.Model {
    static names() {
        return {
            success: 'success',
        };
    }
    static types() {
        return {
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ConnectorEventPushResponseBody = ConnectorEventPushResponseBody;
class ConnectorEventPushResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: ConnectorEventPushResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ConnectorEventPushResponse = ConnectorEventPushResponse;
class CreateChatRoomHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateChatRoomHeaders = CreateChatRoomHeaders;
class CreateChatRoomRequest extends $tea.Model {
    static names() {
        return {
            chatGroupName: 'chatGroupName',
            deviceCodes: 'deviceCodes',
            deviceTypeId: 'deviceTypeId',
            ownerUserId: 'ownerUserId',
            roleList: 'roleList',
        };
    }
    static types() {
        return {
            chatGroupName: 'string',
            deviceCodes: { 'type': 'array', 'itemType': 'string' },
            deviceTypeId: 'string',
            ownerUserId: 'string',
            roleList: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateChatRoomRequest = CreateChatRoomRequest;
class CreateChatRoomResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateChatRoomResponseBody = CreateChatRoomResponseBody;
class CreateChatRoomResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: CreateChatRoomResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateChatRoomResponse = CreateChatRoomResponse;
class CreateDepartmentHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDepartmentHeaders = CreateDepartmentHeaders;
class CreateDepartmentRequest extends $tea.Model {
    static names() {
        return {
            authInfo: 'authInfo',
            authType: 'authType',
            bizExt: 'bizExt',
            departmentName: 'departmentName',
            departmentType: 'departmentType',
            description: 'description',
            systemUrl: 'systemUrl',
            userId: 'userId',
        };
    }
    static types() {
        return {
            authInfo: 'string',
            authType: 'string',
            bizExt: 'string',
            departmentName: 'string',
            departmentType: 'string',
            description: 'string',
            systemUrl: 'string',
            userId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDepartmentRequest = CreateDepartmentRequest;
class CreateDepartmentResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
        };
    }
    static types() {
        return {
            result: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDepartmentResponseBody = CreateDepartmentResponseBody;
class CreateDepartmentResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: CreateDepartmentResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDepartmentResponse = CreateDepartmentResponse;
class CreateDeviceChatRoomHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDeviceChatRoomHeaders = CreateDeviceChatRoomHeaders;
class CreateDeviceChatRoomRequest extends $tea.Model {
    static names() {
        return {
            chatType: 'chatType',
            deviceCodes: 'deviceCodes',
            deviceUuids: 'deviceUuids',
            ownerUserId: 'ownerUserId',
            title: 'title',
            userIds: 'userIds',
        };
    }
    static types() {
        return {
            chatType: 'string',
            deviceCodes: { 'type': 'array', 'itemType': 'string' },
            deviceUuids: { 'type': 'array', 'itemType': 'string' },
            ownerUserId: 'string',
            title: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDeviceChatRoomRequest = CreateDeviceChatRoomRequest;
class CreateDeviceChatRoomResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: CreateDeviceChatRoomResponseBodyResult,
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDeviceChatRoomResponseBody = CreateDeviceChatRoomResponseBody;
class CreateDeviceChatRoomResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: CreateDeviceChatRoomResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDeviceChatRoomResponse = CreateDeviceChatRoomResponse;
class DeviceDingHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DeviceDingHeaders = DeviceDingHeaders;
class DeviceDingRequest extends $tea.Model {
    static names() {
        return {
            deviceKey: 'deviceKey',
            paramsJson: 'paramsJson',
            receiverUserIdList: 'receiverUserIdList',
        };
    }
    static types() {
        return {
            deviceKey: 'string',
            paramsJson: 'string',
            receiverUserIdList: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DeviceDingRequest = DeviceDingRequest;
class DeviceDingResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
        };
    }
    static types() {
        return {
            result: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DeviceDingResponseBody = DeviceDingResponseBody;
class DeviceDingResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: DeviceDingResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DeviceDingResponse = DeviceDingResponse;
class DissolveGroupHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DissolveGroupHeaders = DissolveGroupHeaders;
class DissolveGroupRequest extends $tea.Model {
    static names() {
        return {
            openConversationId: 'openConversationId',
        };
    }
    static types() {
        return {
            openConversationId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DissolveGroupRequest = DissolveGroupRequest;
class DissolveGroupResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DissolveGroupResponseBody = DissolveGroupResponseBody;
class DissolveGroupResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: DissolveGroupResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.DissolveGroupResponse = DissolveGroupResponse;
class EditDeviceAdminHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.EditDeviceAdminHeaders = EditDeviceAdminHeaders;
class EditDeviceAdminRequest extends $tea.Model {
    static names() {
        return {
            deviceCode: 'deviceCode',
            roleUuid: 'roleUuid',
            userIds: 'userIds',
            uuid: 'uuid',
        };
    }
    static types() {
        return {
            deviceCode: 'string',
            roleUuid: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
            uuid: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.EditDeviceAdminRequest = EditDeviceAdminRequest;
class EditDeviceAdminResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.EditDeviceAdminResponseBody = EditDeviceAdminResponseBody;
class EditDeviceAdminResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: EditDeviceAdminResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.EditDeviceAdminResponse = EditDeviceAdminResponse;
class GetDeviceGroupInfoHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetDeviceGroupInfoHeaders = GetDeviceGroupInfoHeaders;
class GetDeviceGroupInfoRequest extends $tea.Model {
    static names() {
        return {
            openConversationId: 'openConversationId',
        };
    }
    static types() {
        return {
            openConversationId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetDeviceGroupInfoRequest = GetDeviceGroupInfoRequest;
class GetDeviceGroupInfoResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: GetDeviceGroupInfoResponseBodyResult,
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetDeviceGroupInfoResponseBody = GetDeviceGroupInfoResponseBody;
class GetDeviceGroupInfoResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: GetDeviceGroupInfoResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetDeviceGroupInfoResponse = GetDeviceGroupInfoResponse;
class GetWholeDeviceGroupHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetWholeDeviceGroupHeaders = GetWholeDeviceGroupHeaders;
class GetWholeDeviceGroupResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetWholeDeviceGroupResponseBody = GetWholeDeviceGroupResponseBody;
class GetWholeDeviceGroupResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: GetWholeDeviceGroupResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetWholeDeviceGroupResponse = GetWholeDeviceGroupResponse;
class ListActivateDevicesHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListActivateDevicesHeaders = ListActivateDevicesHeaders;
class ListActivateDevicesRequest extends $tea.Model {
    static names() {
        return {
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceTypeId: 'deviceTypeId',
            groupId: 'groupId',
            pageNumber: 'pageNumber',
            pageSize: 'pageSize',
        };
    }
    static types() {
        return {
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceTypeId: 'string',
            groupId: 'string',
            pageNumber: 'number',
            pageSize: 'number',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListActivateDevicesRequest = ListActivateDevicesRequest;
class ListActivateDevicesResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
            totalCount: 'totalCount',
        };
    }
    static types() {
        return {
            result: { 'type': 'array', 'itemType': ListActivateDevicesResponseBodyResult },
            success: 'boolean',
            totalCount: 'number',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListActivateDevicesResponseBody = ListActivateDevicesResponseBody;
class ListActivateDevicesResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: ListActivateDevicesResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListActivateDevicesResponse = ListActivateDevicesResponse;
class ListInspectInfoHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListInspectInfoHeaders = ListInspectInfoHeaders;
class ListInspectInfoRequest extends $tea.Model {
    static names() {
        return {
            deviceUuid: 'deviceUuid',
            pageNumber: 'pageNumber',
            pageSize: 'pageSize',
            type: 'type',
        };
    }
    static types() {
        return {
            deviceUuid: { 'type': 'array', 'itemType': 'string' },
            pageNumber: 'number',
            pageSize: 'number',
            type: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListInspectInfoRequest = ListInspectInfoRequest;
class ListInspectInfoResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
            totalCount: 'totalCount',
        };
    }
    static types() {
        return {
            result: { 'type': 'array', 'itemType': ListInspectInfoResponseBodyResult },
            success: 'boolean',
            totalCount: 'number',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListInspectInfoResponseBody = ListInspectInfoResponseBody;
class ListInspectInfoResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: ListInspectInfoResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListInspectInfoResponse = ListInspectInfoResponse;
class ListMaintainInfoHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListMaintainInfoHeaders = ListMaintainInfoHeaders;
class ListMaintainInfoRequest extends $tea.Model {
    static names() {
        return {
            deviceUuid: 'deviceUuid',
            pageNumber: 'pageNumber',
            pageSize: 'pageSize',
        };
    }
    static types() {
        return {
            deviceUuid: { 'type': 'array', 'itemType': 'string' },
            pageNumber: 'number',
            pageSize: 'number',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListMaintainInfoRequest = ListMaintainInfoRequest;
class ListMaintainInfoResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
            totalCount: 'totalCount',
        };
    }
    static types() {
        return {
            result: { 'type': 'array', 'itemType': ListMaintainInfoResponseBodyResult },
            success: 'boolean',
            totalCount: 'number',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListMaintainInfoResponseBody = ListMaintainInfoResponseBody;
class ListMaintainInfoResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: ListMaintainInfoResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListMaintainInfoResponse = ListMaintainInfoResponse;
class PullDeviceToGroupHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullDeviceToGroupHeaders = PullDeviceToGroupHeaders;
class PullDeviceToGroupRequest extends $tea.Model {
    static names() {
        return {
            deviceCodes: 'deviceCodes',
            deviceUuids: 'deviceUuids',
            openConversationId: 'openConversationId',
            operator: 'operator',
        };
    }
    static types() {
        return {
            deviceCodes: { 'type': 'array', 'itemType': 'string' },
            deviceUuids: { 'type': 'array', 'itemType': 'string' },
            openConversationId: 'string',
            operator: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullDeviceToGroupRequest = PullDeviceToGroupRequest;
class PullDeviceToGroupResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullDeviceToGroupResponseBody = PullDeviceToGroupResponseBody;
class PullDeviceToGroupResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: PullDeviceToGroupResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullDeviceToGroupResponse = PullDeviceToGroupResponse;
class PullUserToGroupHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullUserToGroupHeaders = PullUserToGroupHeaders;
class PullUserToGroupRequest extends $tea.Model {
    static names() {
        return {
            openConversationId: 'openConversationId',
            userIds: 'userIds',
        };
    }
    static types() {
        return {
            openConversationId: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullUserToGroupRequest = PullUserToGroupRequest;
class PullUserToGroupResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullUserToGroupResponseBody = PullUserToGroupResponseBody;
class PullUserToGroupResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: PullUserToGroupResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.PullUserToGroupResponse = PullUserToGroupResponse;
class RegisterAndActivateDeviceHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceHeaders = RegisterAndActivateDeviceHeaders;
class RegisterAndActivateDeviceRequest extends $tea.Model {
    static names() {
        return {
            deviceCallbackUrl: 'deviceCallbackUrl',
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceDetailUrl: 'deviceDetailUrl',
            deviceName: 'deviceName',
            introduction: 'introduction',
            roleUuid: 'roleUuid',
            typeUuid: 'typeUuid',
            userIds: 'userIds',
        };
    }
    static types() {
        return {
            deviceCallbackUrl: 'string',
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceDetailUrl: 'string',
            deviceName: 'string',
            introduction: 'string',
            roleUuid: 'string',
            typeUuid: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceRequest = RegisterAndActivateDeviceRequest;
class RegisterAndActivateDeviceResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: RegisterAndActivateDeviceResponseBodyResult,
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceResponseBody = RegisterAndActivateDeviceResponseBody;
class RegisterAndActivateDeviceResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: RegisterAndActivateDeviceResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceResponse = RegisterAndActivateDeviceResponse;
class RegisterAndActivateDeviceBatchHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchHeaders = RegisterAndActivateDeviceBatchHeaders;
class RegisterAndActivateDeviceBatchRequest extends $tea.Model {
    static names() {
        return {
            registerAndActivateVOS: 'registerAndActivateVOS',
        };
    }
    static types() {
        return {
            registerAndActivateVOS: { 'type': 'array', 'itemType': RegisterAndActivateDeviceBatchRequestRegisterAndActivateVOS },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchRequest = RegisterAndActivateDeviceBatchRequest;
class RegisterAndActivateDeviceBatchResponseBody extends $tea.Model {
    static names() {
        return {
            failItems: 'failItems',
            success: 'success',
            successItems: 'successItems',
        };
    }
    static types() {
        return {
            failItems: { 'type': 'array', 'itemType': RegisterAndActivateDeviceBatchResponseBodyFailItems },
            success: 'boolean',
            successItems: { 'type': 'array', 'itemType': RegisterAndActivateDeviceBatchResponseBodySuccessItems },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchResponseBody = RegisterAndActivateDeviceBatchResponseBody;
class RegisterAndActivateDeviceBatchResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: RegisterAndActivateDeviceBatchResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchResponse = RegisterAndActivateDeviceBatchResponse;
class RegisterDeviceHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterDeviceHeaders = RegisterDeviceHeaders;
class RegisterDeviceRequest extends $tea.Model {
    static names() {
        return {
            collaborators: 'collaborators',
            departmentId: 'departmentId',
            description: 'description',
            deviceKey: 'deviceKey',
            deviceName: 'deviceName',
            managers: 'managers',
            userId: 'userId',
        };
    }
    static types() {
        return {
            collaborators: 'string',
            departmentId: 'number',
            description: 'string',
            deviceKey: 'string',
            deviceName: 'string',
            managers: 'string',
            userId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterDeviceRequest = RegisterDeviceRequest;
class RegisterDeviceResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
        };
    }
    static types() {
        return {
            result: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterDeviceResponseBody = RegisterDeviceResponseBody;
class RegisterDeviceResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: RegisterDeviceResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterDeviceResponse = RegisterDeviceResponse;
class RemoveDeviceFromGroupHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveDeviceFromGroupHeaders = RemoveDeviceFromGroupHeaders;
class RemoveDeviceFromGroupRequest extends $tea.Model {
    static names() {
        return {
            deviceCodes: 'deviceCodes',
            deviceUuids: 'deviceUuids',
            openConversationId: 'openConversationId',
            operator: 'operator',
        };
    }
    static types() {
        return {
            deviceCodes: { 'type': 'array', 'itemType': 'string' },
            deviceUuids: { 'type': 'array', 'itemType': 'string' },
            openConversationId: 'string',
            operator: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveDeviceFromGroupRequest = RemoveDeviceFromGroupRequest;
class RemoveDeviceFromGroupResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveDeviceFromGroupResponseBody = RemoveDeviceFromGroupResponseBody;
class RemoveDeviceFromGroupResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: RemoveDeviceFromGroupResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveDeviceFromGroupResponse = RemoveDeviceFromGroupResponse;
class RemoveUserFromGroupHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveUserFromGroupHeaders = RemoveUserFromGroupHeaders;
class RemoveUserFromGroupRequest extends $tea.Model {
    static names() {
        return {
            openConversationId: 'openConversationId',
            userIds: 'userIds',
        };
    }
    static types() {
        return {
            openConversationId: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveUserFromGroupRequest = RemoveUserFromGroupRequest;
class RemoveUserFromGroupResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveUserFromGroupResponseBody = RemoveUserFromGroupResponseBody;
class RemoveUserFromGroupResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: RemoveUserFromGroupResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RemoveUserFromGroupResponse = RemoveUserFromGroupResponse;
class SendCardHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendCardHeaders = SendCardHeaders;
class SendCardRequest extends $tea.Model {
    static names() {
        return {
            bizId: 'bizId',
            cardData: 'cardData',
            deviceCode: 'deviceCode',
            deviceUuid: 'deviceUuid',
            openConversationId: 'openConversationId',
            partVisible: 'partVisible',
            receivers: 'receivers',
            templateId: 'templateId',
            topbox: 'topbox',
            userId: 'userId',
        };
    }
    static types() {
        return {
            bizId: 'string',
            cardData: 'string',
            deviceCode: 'string',
            deviceUuid: 'string',
            openConversationId: 'string',
            partVisible: 'boolean',
            receivers: { 'type': 'array', 'itemType': 'string' },
            templateId: 'string',
            topbox: 'boolean',
            userId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendCardRequest = SendCardRequest;
class SendCardResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendCardResponseBody = SendCardResponseBody;
class SendCardResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: SendCardResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendCardResponse = SendCardResponse;
class SendMsgHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendMsgHeaders = SendMsgHeaders;
class SendMsgRequest extends $tea.Model {
    static names() {
        return {
            content: 'content',
            deviceCode: 'deviceCode',
            deviceUuid: 'deviceUuid',
            openConversationId: 'openConversationId',
            userList: 'userList',
        };
    }
    static types() {
        return {
            content: 'string',
            deviceCode: 'string',
            deviceUuid: 'string',
            openConversationId: 'string',
            userList: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendMsgRequest = SendMsgRequest;
class SendMsgResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendMsgResponseBody = SendMsgResponseBody;
class SendMsgResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: SendMsgResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.SendMsgResponse = SendMsgResponse;
class UninstallDeviceRobotHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UninstallDeviceRobotHeaders = UninstallDeviceRobotHeaders;
class UninstallDeviceRobotRequest extends $tea.Model {
    static names() {
        return {
            deviceCode: 'deviceCode',
            uuid: 'uuid',
        };
    }
    static types() {
        return {
            deviceCode: 'string',
            uuid: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UninstallDeviceRobotRequest = UninstallDeviceRobotRequest;
class UninstallDeviceRobotResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UninstallDeviceRobotResponseBody = UninstallDeviceRobotResponseBody;
class UninstallDeviceRobotResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: UninstallDeviceRobotResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UninstallDeviceRobotResponse = UninstallDeviceRobotResponse;
class UpdateCardHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UpdateCardHeaders = UpdateCardHeaders;
class UpdateCardRequest extends $tea.Model {
    static names() {
        return {
            bizId: 'bizId',
            cardData: 'cardData',
            tips: 'tips',
        };
    }
    static types() {
        return {
            bizId: 'string',
            cardData: 'string',
            tips: UpdateCardRequestTips,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UpdateCardRequest = UpdateCardRequest;
class UpdateCardResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'boolean',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UpdateCardResponseBody = UpdateCardResponseBody;
class UpdateCardResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: UpdateCardResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UpdateCardResponse = UpdateCardResponse;
class UploadEventHeaders extends $tea.Model {
    static names() {
        return {
            commonHeaders: 'commonHeaders',
            xAcsDingtalkAccessToken: 'x-acs-dingtalk-access-token',
        };
    }
    static types() {
        return {
            commonHeaders: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            xAcsDingtalkAccessToken: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UploadEventHeaders = UploadEventHeaders;
class UploadEventRequest extends $tea.Model {
    static names() {
        return {
            content: 'content',
            coverUrl: 'coverUrl',
            deviceCode: 'deviceCode',
            deviceUuid: 'deviceUuid',
            eventTime: 'eventTime',
            eventType: 'eventType',
            level: 'level',
        };
    }
    static types() {
        return {
            content: 'string',
            coverUrl: 'string',
            deviceCode: 'string',
            deviceUuid: 'string',
            eventTime: 'string',
            eventType: 'string',
            level: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UploadEventRequest = UploadEventRequest;
class UploadEventResponseBody extends $tea.Model {
    static names() {
        return {
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            result: 'string',
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UploadEventResponseBody = UploadEventResponseBody;
class UploadEventResponse extends $tea.Model {
    static names() {
        return {
            headers: 'headers',
            statusCode: 'statusCode',
            body: 'body',
        };
    }
    static types() {
        return {
            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
            statusCode: 'number',
            body: UploadEventResponseBody,
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UploadEventResponse = UploadEventResponse;
class BatchRegisterDeviceRequestDeviceList extends $tea.Model {
    static names() {
        return {
            collaborators: 'collaborators',
            departmentId: 'departmentId',
            description: 'description',
            deviceKey: 'deviceKey',
            deviceName: 'deviceName',
            managers: 'managers',
        };
    }
    static types() {
        return {
            collaborators: 'string',
            departmentId: 'number',
            description: 'string',
            deviceKey: 'string',
            deviceName: 'string',
            managers: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.BatchRegisterDeviceRequestDeviceList = BatchRegisterDeviceRequestDeviceList;
class CreateDeviceChatRoomResponseBodyResult extends $tea.Model {
    static names() {
        return {
            chatId: 'chatId',
            encodedCid: 'encodedCid',
            openConversationId: 'openConversationId',
        };
    }
    static types() {
        return {
            chatId: 'string',
            encodedCid: 'string',
            openConversationId: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.CreateDeviceChatRoomResponseBodyResult = CreateDeviceChatRoomResponseBodyResult;
class GetDeviceGroupInfoResponseBodyResultDevices extends $tea.Model {
    static names() {
        return {
            deviceCode: 'deviceCode',
            deviceName: 'deviceName',
            deviceUuid: 'deviceUuid',
            uuid: 'uuid',
        };
    }
    static types() {
        return {
            deviceCode: 'string',
            deviceName: 'string',
            deviceUuid: 'string',
            uuid: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetDeviceGroupInfoResponseBodyResultDevices = GetDeviceGroupInfoResponseBodyResultDevices;
class GetDeviceGroupInfoResponseBodyResult extends $tea.Model {
    static names() {
        return {
            devices: 'devices',
            ownerUser: 'ownerUser',
            subAdminUsers: 'subAdminUsers',
            title: 'title',
            users: 'users',
        };
    }
    static types() {
        return {
            devices: { 'type': 'array', 'itemType': GetDeviceGroupInfoResponseBodyResultDevices },
            ownerUser: 'string',
            subAdminUsers: { 'type': 'array', 'itemType': 'string' },
            title: 'string',
            users: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.GetDeviceGroupInfoResponseBodyResult = GetDeviceGroupInfoResponseBodyResult;
class ListActivateDevicesResponseBodyResult extends $tea.Model {
    static names() {
        return {
            bizExt: 'bizExt',
            deviceCallbackUrl: 'deviceCallbackUrl',
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceDetailUrl: 'deviceDetailUrl',
            deviceName: 'deviceName',
            groupUuid: 'groupUuid',
            icon: 'icon',
            introduction: 'introduction',
            typeUuid: 'typeUuid',
            uuid: 'uuid',
        };
    }
    static types() {
        return {
            bizExt: 'string',
            deviceCallbackUrl: 'string',
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceDetailUrl: 'string',
            deviceName: 'string',
            groupUuid: 'string',
            icon: 'string',
            introduction: 'string',
            typeUuid: 'string',
            uuid: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListActivateDevicesResponseBodyResult = ListActivateDevicesResponseBodyResult;
class ListInspectInfoResponseBodyResult extends $tea.Model {
    static names() {
        return {
            deviceCode: 'deviceCode',
            deviceName: 'deviceName',
            gmtCreate: 'gmtCreate',
            handleTime: 'handleTime',
            maintenanceStaff: 'maintenanceStaff',
            name: 'name',
            remark: 'remark',
            repairStatus: 'repairStatus',
            status: 'status',
            type: 'type',
        };
    }
    static types() {
        return {
            deviceCode: 'string',
            deviceName: 'string',
            gmtCreate: 'string',
            handleTime: 'string',
            maintenanceStaff: { 'type': 'array', 'itemType': 'string' },
            name: 'string',
            remark: 'string',
            repairStatus: 'number',
            status: 'number',
            type: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListInspectInfoResponseBodyResult = ListInspectInfoResponseBodyResult;
class ListMaintainInfoResponseBodyResult extends $tea.Model {
    static names() {
        return {
            deviceCode: 'deviceCode',
            deviceName: 'deviceName',
            gmtCreate: 'gmtCreate',
            handleTime: 'handleTime',
            maintenanceStaff: 'maintenanceStaff',
            processState: 'processState',
            remark: 'remark',
        };
    }
    static types() {
        return {
            deviceCode: 'string',
            deviceName: 'string',
            gmtCreate: 'string',
            handleTime: 'string',
            maintenanceStaff: { 'type': 'array', 'itemType': 'string' },
            processState: 'number',
            remark: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.ListMaintainInfoResponseBodyResult = ListMaintainInfoResponseBodyResult;
class RegisterAndActivateDeviceResponseBodyResult extends $tea.Model {
    static names() {
        return {
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceDetailUrl: 'deviceDetailUrl',
            deviceName: 'deviceName',
            deviceUuid: 'deviceUuid',
            introduction: 'introduction',
            roleUuid: 'roleUuid',
            typeUuid: 'typeUuid',
            userIds: 'userIds',
        };
    }
    static types() {
        return {
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceDetailUrl: 'string',
            deviceName: 'string',
            deviceUuid: 'string',
            introduction: 'string',
            roleUuid: 'string',
            typeUuid: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceResponseBodyResult = RegisterAndActivateDeviceResponseBodyResult;
class RegisterAndActivateDeviceBatchRequestRegisterAndActivateVOS extends $tea.Model {
    static names() {
        return {
            deviceCallbackUrl: 'deviceCallbackUrl',
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceDetailUrl: 'deviceDetailUrl',
            deviceName: 'deviceName',
            groupUuid: 'groupUuid',
            introduction: 'introduction',
            roleUuid: 'roleUuid',
            typeUuid: 'typeUuid',
            userIds: 'userIds',
        };
    }
    static types() {
        return {
            deviceCallbackUrl: 'string',
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceDetailUrl: 'string',
            deviceName: 'string',
            groupUuid: 'string',
            introduction: 'string',
            roleUuid: 'string',
            typeUuid: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchRequestRegisterAndActivateVOS = RegisterAndActivateDeviceBatchRequestRegisterAndActivateVOS;
class RegisterAndActivateDeviceBatchResponseBodyFailItemsResult extends $tea.Model {
    static names() {
        return {
            deviceCallbackUrl: 'deviceCallbackUrl',
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceDetailUrl: 'deviceDetailUrl',
            deviceName: 'deviceName',
            groupUuid: 'groupUuid',
            icon: 'icon',
            introduction: 'introduction',
            roleUuid: 'roleUuid',
            status: 'status',
            typeUuid: 'typeUuid',
            userIds: 'userIds',
            uuid: 'uuid',
        };
    }
    static types() {
        return {
            deviceCallbackUrl: 'string',
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceDetailUrl: 'string',
            deviceName: 'string',
            groupUuid: 'string',
            icon: 'string',
            introduction: 'string',
            roleUuid: 'string',
            status: 'number',
            typeUuid: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
            uuid: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchResponseBodyFailItemsResult = RegisterAndActivateDeviceBatchResponseBodyFailItemsResult;
class RegisterAndActivateDeviceBatchResponseBodyFailItems extends $tea.Model {
    static names() {
        return {
            errorCode: 'errorCode',
            errorMsg: 'errorMsg',
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            errorCode: 'string',
            errorMsg: 'string',
            result: RegisterAndActivateDeviceBatchResponseBodyFailItemsResult,
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchResponseBodyFailItems = RegisterAndActivateDeviceBatchResponseBodyFailItems;
class RegisterAndActivateDeviceBatchResponseBodySuccessItemsResult extends $tea.Model {
    static names() {
        return {
            deviceCallbackUrl: 'deviceCallbackUrl',
            deviceCategory: 'deviceCategory',
            deviceCode: 'deviceCode',
            deviceDetailUrl: 'deviceDetailUrl',
            deviceName: 'deviceName',
            groupUuid: 'groupUuid',
            icon: 'icon',
            introduction: 'introduction',
            roleUuid: 'roleUuid',
            status: 'status',
            typeUuid: 'typeUuid',
            userIds: 'userIds',
            uuid: 'uuid',
        };
    }
    static types() {
        return {
            deviceCallbackUrl: 'string',
            deviceCategory: 'number',
            deviceCode: 'string',
            deviceDetailUrl: 'string',
            deviceName: 'string',
            groupUuid: 'string',
            icon: 'string',
            introduction: 'string',
            roleUuid: 'string',
            status: 'number',
            typeUuid: 'string',
            userIds: { 'type': 'array', 'itemType': 'string' },
            uuid: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchResponseBodySuccessItemsResult = RegisterAndActivateDeviceBatchResponseBodySuccessItemsResult;
class RegisterAndActivateDeviceBatchResponseBodySuccessItems extends $tea.Model {
    static names() {
        return {
            errorCode: 'errorCode',
            errorMsg: 'errorMsg',
            result: 'result',
            success: 'success',
        };
    }
    static types() {
        return {
            errorCode: 'string',
            errorMsg: 'string',
            result: RegisterAndActivateDeviceBatchResponseBodySuccessItemsResult,
            success: 'boolean',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.RegisterAndActivateDeviceBatchResponseBodySuccessItems = RegisterAndActivateDeviceBatchResponseBodySuccessItems;
class UpdateCardRequestTips extends $tea.Model {
    static names() {
        return {
            cids: 'cids',
            content: 'content',
            sender: 'sender',
        };
    }
    static types() {
        return {
            cids: 'string',
            content: 'string',
            sender: 'string',
        };
    }
    constructor(map) {
        super(map);
    }
}
exports.UpdateCardRequestTips = UpdateCardRequestTips;
class Client extends openapi_client_1.default {
    constructor(config) {
        super(config);
        let gatewayClient = new gateway_dingtalk_1.default();
        this._spi = gatewayClient;
        this._endpointRule = "";
        if (tea_util_1.default.empty(this._endpoint)) {
            this._endpoint = "api.dingtalk.com";
        }
    }
    /**
     * 批量注册设备
     *
     * @param request - BatchRegisterDeviceRequest
     * @param headers - BatchRegisterDeviceHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns BatchRegisterDeviceResponse
     */
    async batchRegisterDeviceWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceList)) {
            body["deviceList"] = request.deviceList;
        }
        if (!tea_util_1.default.isUnset(request.userId)) {
            body["userId"] = request.userId;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "BatchRegisterDevice",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/devices/batch`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "json",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new BatchRegisterDeviceResponse({}));
    }
    /**
     * 批量注册设备
     *
     * @param request - BatchRegisterDeviceRequest
     * @returns BatchRegisterDeviceResponse
     */
    async batchRegisterDevice(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new BatchRegisterDeviceHeaders({});
        return await this.batchRegisterDeviceWithOptions(request, headers, runtime);
    }
    /**
     * 想设备上钉连接器推送设备事件
     *
     * @param request - ConnectorEventPushRequest
     * @param headers - ConnectorEventPushHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns ConnectorEventPushResponse
     */
    async connectorEventPushWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceTypeUuid)) {
            body["deviceTypeUuid"] = request.deviceTypeUuid;
        }
        if (!tea_util_1.default.isUnset(request.eventName)) {
            body["eventName"] = request.eventName;
        }
        if (!tea_util_1.default.isUnset(request.input)) {
            body["input"] = request.input;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "ConnectorEventPush",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/connectors/events/push`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new ConnectorEventPushResponse({}));
    }
    /**
     * 想设备上钉连接器推送设备事件
     *
     * @param request - ConnectorEventPushRequest
     * @returns ConnectorEventPushResponse
     */
    async connectorEventPush(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new ConnectorEventPushHeaders({});
        return await this.connectorEventPushWithOptions(request, headers, runtime);
    }
    /**
     * 创建设备群
     *
     * @param request - CreateChatRoomRequest
     * @param headers - CreateChatRoomHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns CreateChatRoomResponse
     */
    async createChatRoomWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.chatGroupName)) {
            body["chatGroupName"] = request.chatGroupName;
        }
        if (!tea_util_1.default.isUnset(request.deviceCodes)) {
            body["deviceCodes"] = request.deviceCodes;
        }
        if (!tea_util_1.default.isUnset(request.deviceTypeId)) {
            body["deviceTypeId"] = request.deviceTypeId;
        }
        if (!tea_util_1.default.isUnset(request.ownerUserId)) {
            body["ownerUserId"] = request.ownerUserId;
        }
        if (!tea_util_1.default.isUnset(request.roleList)) {
            body["roleList"] = request.roleList;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "CreateChatRoom",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRoom`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new CreateChatRoomResponse({}));
    }
    /**
     * 创建设备群
     *
     * @param request - CreateChatRoomRequest
     * @returns CreateChatRoomResponse
     */
    async createChatRoom(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new CreateChatRoomHeaders({});
        return await this.createChatRoomWithOptions(request, headers, runtime);
    }
    /**
     * 创建部门
     *
     * @param request - CreateDepartmentRequest
     * @param headers - CreateDepartmentHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns CreateDepartmentResponse
     */
    async createDepartmentWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.authInfo)) {
            body["authInfo"] = request.authInfo;
        }
        if (!tea_util_1.default.isUnset(request.authType)) {
            body["authType"] = request.authType;
        }
        if (!tea_util_1.default.isUnset(request.bizExt)) {
            body["bizExt"] = request.bizExt;
        }
        if (!tea_util_1.default.isUnset(request.departmentName)) {
            body["departmentName"] = request.departmentName;
        }
        if (!tea_util_1.default.isUnset(request.departmentType)) {
            body["departmentType"] = request.departmentType;
        }
        if (!tea_util_1.default.isUnset(request.description)) {
            body["description"] = request.description;
        }
        if (!tea_util_1.default.isUnset(request.systemUrl)) {
            body["systemUrl"] = request.systemUrl;
        }
        if (!tea_util_1.default.isUnset(request.userId)) {
            body["userId"] = request.userId;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "CreateDepartment",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/departments`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "json",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new CreateDepartmentResponse({}));
    }
    /**
     * 创建部门
     *
     * @param request - CreateDepartmentRequest
     * @returns CreateDepartmentResponse
     */
    async createDepartment(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new CreateDepartmentHeaders({});
        return await this.createDepartmentWithOptions(request, headers, runtime);
    }
    /**
     * 创建设备场景群
     *
     * @param request - CreateDeviceChatRoomRequest
     * @param headers - CreateDeviceChatRoomHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns CreateDeviceChatRoomResponse
     */
    async createDeviceChatRoomWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.chatType)) {
            body["chatType"] = request.chatType;
        }
        if (!tea_util_1.default.isUnset(request.deviceCodes)) {
            body["deviceCodes"] = request.deviceCodes;
        }
        if (!tea_util_1.default.isUnset(request.deviceUuids)) {
            body["deviceUuids"] = request.deviceUuids;
        }
        if (!tea_util_1.default.isUnset(request.ownerUserId)) {
            body["ownerUserId"] = request.ownerUserId;
        }
        if (!tea_util_1.default.isUnset(request.title)) {
            body["title"] = request.title;
        }
        if (!tea_util_1.default.isUnset(request.userIds)) {
            body["userIds"] = request.userIds;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "CreateDeviceChatRoom",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/groups`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new CreateDeviceChatRoomResponse({}));
    }
    /**
     * 创建设备场景群
     *
     * @param request - CreateDeviceChatRoomRequest
     * @returns CreateDeviceChatRoomResponse
     */
    async createDeviceChatRoom(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new CreateDeviceChatRoomHeaders({});
        return await this.createDeviceChatRoomWithOptions(request, headers, runtime);
    }
    /**
     * 设备账号向目标用户发送ding消息
     *
     * @param request - DeviceDingRequest
     * @param headers - DeviceDingHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns DeviceDingResponse
     */
    async deviceDingWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceKey)) {
            body["deviceKey"] = request.deviceKey;
        }
        if (!tea_util_1.default.isUnset(request.paramsJson)) {
            body["paramsJson"] = request.paramsJson;
        }
        if (!tea_util_1.default.isUnset(request.receiverUserIdList)) {
            body["receiverUserIdList"] = request.receiverUserIdList;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "DeviceDing",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/ding`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "json",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new DeviceDingResponse({}));
    }
    /**
     * 设备账号向目标用户发送ding消息
     *
     * @param request - DeviceDingRequest
     * @returns DeviceDingResponse
     */
    async deviceDing(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new DeviceDingHeaders({});
        return await this.deviceDingWithOptions(request, headers, runtime);
    }
    /**
     * 解散设备群
     *
     * @param request - DissolveGroupRequest
     * @param headers - DissolveGroupHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns DissolveGroupResponse
     */
    async dissolveGroupWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "DissolveGroup",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/groups/dissolve`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new DissolveGroupResponse({}));
    }
    /**
     * 解散设备群
     *
     * @param request - DissolveGroupRequest
     * @returns DissolveGroupResponse
     */
    async dissolveGroup(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new DissolveGroupHeaders({});
        return await this.dissolveGroupWithOptions(request, headers, runtime);
    }
    /**
     * 编辑设备管理员
     *
     * @param request - EditDeviceAdminRequest
     * @param headers - EditDeviceAdminHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns EditDeviceAdminResponse
     */
    async editDeviceAdminWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            body["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.roleUuid)) {
            body["roleUuid"] = request.roleUuid;
        }
        if (!tea_util_1.default.isUnset(request.userIds)) {
            body["userIds"] = request.userIds;
        }
        if (!tea_util_1.default.isUnset(request.uuid)) {
            body["uuid"] = request.uuid;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "EditDeviceAdmin",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/administrators/edit`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new EditDeviceAdminResponse({}));
    }
    /**
     * 编辑设备管理员
     *
     * @param request - EditDeviceAdminRequest
     * @returns EditDeviceAdminResponse
     */
    async editDeviceAdmin(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new EditDeviceAdminHeaders({});
        return await this.editDeviceAdminWithOptions(request, headers, runtime);
    }
    /**
     * 获取设备群信息
     *
     * @param request - GetDeviceGroupInfoRequest
     * @param headers - GetDeviceGroupInfoHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns GetDeviceGroupInfoResponse
     */
    async getDeviceGroupInfoWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "GetDeviceGroupInfo",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/groupInfos/query`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new GetDeviceGroupInfoResponse({}));
    }
    /**
     * 获取设备群信息
     *
     * @param request - GetDeviceGroupInfoRequest
     * @returns GetDeviceGroupInfoResponse
     */
    async getDeviceGroupInfo(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new GetDeviceGroupInfoHeaders({});
        return await this.getDeviceGroupInfoWithOptions(request, headers, runtime);
    }
    /**
     * 获取设备全员群标识
     *
     * @param headers - GetWholeDeviceGroupHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns GetWholeDeviceGroupResponse
     */
    async getWholeDeviceGroupWithOptions(headers, runtime) {
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
        });
        let params = new $OpenApi.Params({
            action: "GetWholeDeviceGroup",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/wholeGroupId`,
            method: "GET",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new GetWholeDeviceGroupResponse({}));
    }
    /**
     * 获取设备全员群标识
     * @returns GetWholeDeviceGroupResponse
     */
    async getWholeDeviceGroup() {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new GetWholeDeviceGroupHeaders({});
        return await this.getWholeDeviceGroupWithOptions(headers, runtime);
    }
    /**
     * 查询激活的设备信息
     *
     * @param request - ListActivateDevicesRequest
     * @param headers - ListActivateDevicesHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns ListActivateDevicesResponse
     */
    async listActivateDevicesWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let query = {};
        if (!tea_util_1.default.isUnset(request.deviceCategory)) {
            query["deviceCategory"] = request.deviceCategory;
        }
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            query["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.deviceTypeId)) {
            query["deviceTypeId"] = request.deviceTypeId;
        }
        if (!tea_util_1.default.isUnset(request.groupId)) {
            query["groupId"] = request.groupId;
        }
        if (!tea_util_1.default.isUnset(request.pageNumber)) {
            query["pageNumber"] = request.pageNumber;
        }
        if (!tea_util_1.default.isUnset(request.pageSize)) {
            query["pageSize"] = request.pageSize;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            query: openapi_util_1.default.query(query),
        });
        let params = new $OpenApi.Params({
            action: "ListActivateDevices",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/activations/infos`,
            method: "GET",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new ListActivateDevicesResponse({}));
    }
    /**
     * 查询激活的设备信息
     *
     * @param request - ListActivateDevicesRequest
     * @returns ListActivateDevicesResponse
     */
    async listActivateDevices(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new ListActivateDevicesHeaders({});
        return await this.listActivateDevicesWithOptions(request, headers, runtime);
    }
    /**
     * 获取巡检、保养记录
     *
     * @param request - ListInspectInfoRequest
     * @param headers - ListInspectInfoHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns ListInspectInfoResponse
     */
    async listInspectInfoWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceUuid)) {
            body["deviceUuid"] = request.deviceUuid;
        }
        if (!tea_util_1.default.isUnset(request.pageNumber)) {
            body["pageNumber"] = request.pageNumber;
        }
        if (!tea_util_1.default.isUnset(request.pageSize)) {
            body["pageSize"] = request.pageSize;
        }
        if (!tea_util_1.default.isUnset(request.type)) {
            body["type"] = request.type;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "ListInspectInfo",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/inspectInfos/query`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new ListInspectInfoResponse({}));
    }
    /**
     * 获取巡检、保养记录
     *
     * @param request - ListInspectInfoRequest
     * @returns ListInspectInfoResponse
     */
    async listInspectInfo(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new ListInspectInfoHeaders({});
        return await this.listInspectInfoWithOptions(request, headers, runtime);
    }
    /**
     * 获取报修信息
     *
     * @param request - ListMaintainInfoRequest
     * @param headers - ListMaintainInfoHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns ListMaintainInfoResponse
     */
    async listMaintainInfoWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceUuid)) {
            body["deviceUuid"] = request.deviceUuid;
        }
        if (!tea_util_1.default.isUnset(request.pageNumber)) {
            body["pageNumber"] = request.pageNumber;
        }
        if (!tea_util_1.default.isUnset(request.pageSize)) {
            body["pageSize"] = request.pageSize;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "ListMaintainInfo",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/maintainInfos/query`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new ListMaintainInfoResponse({}));
    }
    /**
     * 获取报修信息
     *
     * @param request - ListMaintainInfoRequest
     * @returns ListMaintainInfoResponse
     */
    async listMaintainInfo(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new ListMaintainInfoHeaders({});
        return await this.listMaintainInfoWithOptions(request, headers, runtime);
    }
    /**
     * 拉设备进群
     *
     * @param request - PullDeviceToGroupRequest
     * @param headers - PullDeviceToGroupHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns PullDeviceToGroupResponse
     */
    async pullDeviceToGroupWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceCodes)) {
            body["deviceCodes"] = request.deviceCodes;
        }
        if (!tea_util_1.default.isUnset(request.deviceUuids)) {
            body["deviceUuids"] = request.deviceUuids;
        }
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        if (!tea_util_1.default.isUnset(request.operator)) {
            body["operator"] = request.operator;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "PullDeviceToGroup",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/devices`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new PullDeviceToGroupResponse({}));
    }
    /**
     * 拉设备进群
     *
     * @param request - PullDeviceToGroupRequest
     * @returns PullDeviceToGroupResponse
     */
    async pullDeviceToGroup(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new PullDeviceToGroupHeaders({});
        return await this.pullDeviceToGroupWithOptions(request, headers, runtime);
    }
    /**
     * 拉设用户进群
     *
     * @param request - PullUserToGroupRequest
     * @param headers - PullUserToGroupHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns PullUserToGroupResponse
     */
    async pullUserToGroupWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        if (!tea_util_1.default.isUnset(request.userIds)) {
            body["userIds"] = request.userIds;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "PullUserToGroup",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/users`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new PullUserToGroupResponse({}));
    }
    /**
     * 拉设用户进群
     *
     * @param request - PullUserToGroupRequest
     * @returns PullUserToGroupResponse
     */
    async pullUserToGroup(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new PullUserToGroupHeaders({});
        return await this.pullUserToGroupWithOptions(request, headers, runtime);
    }
    /**
     * 注册与激活设备
     *
     * @param request - RegisterAndActivateDeviceRequest
     * @param headers - RegisterAndActivateDeviceHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns RegisterAndActivateDeviceResponse
     */
    async registerAndActivateDeviceWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceCallbackUrl)) {
            body["deviceCallbackUrl"] = request.deviceCallbackUrl;
        }
        if (!tea_util_1.default.isUnset(request.deviceCategory)) {
            body["deviceCategory"] = request.deviceCategory;
        }
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            body["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.deviceDetailUrl)) {
            body["deviceDetailUrl"] = request.deviceDetailUrl;
        }
        if (!tea_util_1.default.isUnset(request.deviceName)) {
            body["deviceName"] = request.deviceName;
        }
        if (!tea_util_1.default.isUnset(request.introduction)) {
            body["introduction"] = request.introduction;
        }
        if (!tea_util_1.default.isUnset(request.roleUuid)) {
            body["roleUuid"] = request.roleUuid;
        }
        if (!tea_util_1.default.isUnset(request.typeUuid)) {
            body["typeUuid"] = request.typeUuid;
        }
        if (!tea_util_1.default.isUnset(request.userIds)) {
            body["userIds"] = request.userIds;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "RegisterAndActivateDevice",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/registerAndActivate`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new RegisterAndActivateDeviceResponse({}));
    }
    /**
     * 注册与激活设备
     *
     * @param request - RegisterAndActivateDeviceRequest
     * @returns RegisterAndActivateDeviceResponse
     */
    async registerAndActivateDevice(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new RegisterAndActivateDeviceHeaders({});
        return await this.registerAndActivateDeviceWithOptions(request, headers, runtime);
    }
    /**
     * 批量注册与激活设备
     *
     * @param request - RegisterAndActivateDeviceBatchRequest
     * @param headers - RegisterAndActivateDeviceBatchHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns RegisterAndActivateDeviceBatchResponse
     */
    async registerAndActivateDeviceBatchWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.registerAndActivateVOS)) {
            body["registerAndActivateVOS"] = request.registerAndActivateVOS;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "RegisterAndActivateDeviceBatch",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/registrationActivations/batch`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new RegisterAndActivateDeviceBatchResponse({}));
    }
    /**
     * 批量注册与激活设备
     *
     * @param request - RegisterAndActivateDeviceBatchRequest
     * @returns RegisterAndActivateDeviceBatchResponse
     */
    async registerAndActivateDeviceBatch(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new RegisterAndActivateDeviceBatchHeaders({});
        return await this.registerAndActivateDeviceBatchWithOptions(request, headers, runtime);
    }
    /**
     * 注册设备并为其创建机器人
     *
     * @param request - RegisterDeviceRequest
     * @param headers - RegisterDeviceHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns RegisterDeviceResponse
     */
    async registerDeviceWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.collaborators)) {
            body["collaborators"] = request.collaborators;
        }
        if (!tea_util_1.default.isUnset(request.departmentId)) {
            body["departmentId"] = request.departmentId;
        }
        if (!tea_util_1.default.isUnset(request.description)) {
            body["description"] = request.description;
        }
        if (!tea_util_1.default.isUnset(request.deviceKey)) {
            body["deviceKey"] = request.deviceKey;
        }
        if (!tea_util_1.default.isUnset(request.deviceName)) {
            body["deviceName"] = request.deviceName;
        }
        if (!tea_util_1.default.isUnset(request.managers)) {
            body["managers"] = request.managers;
        }
        if (!tea_util_1.default.isUnset(request.userId)) {
            body["userId"] = request.userId;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "RegisterDevice",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/devices`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "json",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new RegisterDeviceResponse({}));
    }
    /**
     * 注册设备并为其创建机器人
     *
     * @param request - RegisterDeviceRequest
     * @returns RegisterDeviceResponse
     */
    async registerDevice(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new RegisterDeviceHeaders({});
        return await this.registerDeviceWithOptions(request, headers, runtime);
    }
    /**
     * 移设备出群
     *
     * @param request - RemoveDeviceFromGroupRequest
     * @param headers - RemoveDeviceFromGroupHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns RemoveDeviceFromGroupResponse
     */
    async removeDeviceFromGroupWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceCodes)) {
            body["deviceCodes"] = request.deviceCodes;
        }
        if (!tea_util_1.default.isUnset(request.deviceUuids)) {
            body["deviceUuids"] = request.deviceUuids;
        }
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        if (!tea_util_1.default.isUnset(request.operator)) {
            body["operator"] = request.operator;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "RemoveDeviceFromGroup",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/devices/remove`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new RemoveDeviceFromGroupResponse({}));
    }
    /**
     * 移设备出群
     *
     * @param request - RemoveDeviceFromGroupRequest
     * @returns RemoveDeviceFromGroupResponse
     */
    async removeDeviceFromGroup(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new RemoveDeviceFromGroupHeaders({});
        return await this.removeDeviceFromGroupWithOptions(request, headers, runtime);
    }
    /**
     * 移用户出设备群
     *
     * @param request - RemoveUserFromGroupRequest
     * @param headers - RemoveUserFromGroupHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns RemoveUserFromGroupResponse
     */
    async removeUserFromGroupWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        if (!tea_util_1.default.isUnset(request.userIds)) {
            body["userIds"] = request.userIds;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "RemoveUserFromGroup",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/chatRooms/users/remove`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new RemoveUserFromGroupResponse({}));
    }
    /**
     * 移用户出设备群
     *
     * @param request - RemoveUserFromGroupRequest
     * @returns RemoveUserFromGroupResponse
     */
    async removeUserFromGroup(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new RemoveUserFromGroupHeaders({});
        return await this.removeUserFromGroupWithOptions(request, headers, runtime);
    }
    /**
     * 发送卡片
     *
     * @param request - SendCardRequest
     * @param headers - SendCardHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns SendCardResponse
     */
    async sendCardWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.bizId)) {
            body["bizId"] = request.bizId;
        }
        if (!tea_util_1.default.isUnset(request.cardData)) {
            body["cardData"] = request.cardData;
        }
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            body["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.deviceUuid)) {
            body["deviceUuid"] = request.deviceUuid;
        }
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        if (!tea_util_1.default.isUnset(request.partVisible)) {
            body["partVisible"] = request.partVisible;
        }
        if (!tea_util_1.default.isUnset(request.receivers)) {
            body["receivers"] = request.receivers;
        }
        if (!tea_util_1.default.isUnset(request.templateId)) {
            body["templateId"] = request.templateId;
        }
        if (!tea_util_1.default.isUnset(request.topbox)) {
            body["topbox"] = request.topbox;
        }
        if (!tea_util_1.default.isUnset(request.userId)) {
            body["userId"] = request.userId;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "SendCard",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/cards/send`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new SendCardResponse({}));
    }
    /**
     * 发送卡片
     *
     * @param request - SendCardRequest
     * @returns SendCardResponse
     */
    async sendCard(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new SendCardHeaders({});
        return await this.sendCardWithOptions(request, headers, runtime);
    }
    /**
     * 发送普通消息
     *
     * @param request - SendMsgRequest
     * @param headers - SendMsgHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns SendMsgResponse
     */
    async sendMsgWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.content)) {
            body["content"] = request.content;
        }
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            body["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.deviceUuid)) {
            body["deviceUuid"] = request.deviceUuid;
        }
        if (!tea_util_1.default.isUnset(request.openConversationId)) {
            body["openConversationId"] = request.openConversationId;
        }
        if (!tea_util_1.default.isUnset(request.userList)) {
            body["userList"] = request.userList;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "SendMsg",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/messages/send`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new SendMsgResponse({}));
    }
    /**
     * 发送普通消息
     *
     * @param request - SendMsgRequest
     * @returns SendMsgResponse
     */
    async sendMsg(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new SendMsgHeaders({});
        return await this.sendMsgWithOptions(request, headers, runtime);
    }
    /**
     * 卸载设备
     *
     * @param request - UninstallDeviceRobotRequest
     * @param headers - UninstallDeviceRobotHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns UninstallDeviceRobotResponse
     */
    async uninstallDeviceRobotWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            body["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.uuid)) {
            body["uuid"] = request.uuid;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "UninstallDeviceRobot",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/devices/uninstall`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new UninstallDeviceRobotResponse({}));
    }
    /**
     * 卸载设备
     *
     * @param request - UninstallDeviceRobotRequest
     * @returns UninstallDeviceRobotResponse
     */
    async uninstallDeviceRobot(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new UninstallDeviceRobotHeaders({});
        return await this.uninstallDeviceRobotWithOptions(request, headers, runtime);
    }
    /**
     * 更新卡片
     *
     * @param request - UpdateCardRequest
     * @param headers - UpdateCardHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns UpdateCardResponse
     */
    async updateCardWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.bizId)) {
            body["bizId"] = request.bizId;
        }
        if (!tea_util_1.default.isUnset(request.cardData)) {
            body["cardData"] = request.cardData;
        }
        if (!tea_util_1.default.isUnset(request.tips)) {
            body["tips"] = request.tips;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "UpdateCard",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/customers/cards`,
            method: "PUT",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new UpdateCardResponse({}));
    }
    /**
     * 更新卡片
     *
     * @param request - UpdateCardRequest
     * @returns UpdateCardResponse
     */
    async updateCard(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new UpdateCardHeaders({});
        return await this.updateCardWithOptions(request, headers, runtime);
    }
    /**
     * 设备事件上报
     *
     * @param request - UploadEventRequest
     * @param headers - UploadEventHeaders
     * @param runtime - runtime options for this request RuntimeOptions
     * @returns UploadEventResponse
     */
    async uploadEventWithOptions(request, headers, runtime) {
        tea_util_1.default.validateModel(request);
        let body = {};
        if (!tea_util_1.default.isUnset(request.content)) {
            body["content"] = request.content;
        }
        if (!tea_util_1.default.isUnset(request.coverUrl)) {
            body["coverUrl"] = request.coverUrl;
        }
        if (!tea_util_1.default.isUnset(request.deviceCode)) {
            body["deviceCode"] = request.deviceCode;
        }
        if (!tea_util_1.default.isUnset(request.deviceUuid)) {
            body["deviceUuid"] = request.deviceUuid;
        }
        if (!tea_util_1.default.isUnset(request.eventTime)) {
            body["eventTime"] = request.eventTime;
        }
        if (!tea_util_1.default.isUnset(request.eventType)) {
            body["eventType"] = request.eventType;
        }
        if (!tea_util_1.default.isUnset(request.level)) {
            body["level"] = request.level;
        }
        let realHeaders = {};
        if (!tea_util_1.default.isUnset(headers.commonHeaders)) {
            realHeaders = headers.commonHeaders;
        }
        if (!tea_util_1.default.isUnset(headers.xAcsDingtalkAccessToken)) {
            realHeaders["x-acs-dingtalk-access-token"] = tea_util_1.default.toJSONString(headers.xAcsDingtalkAccessToken);
        }
        let req = new $OpenApi.OpenApiRequest({
            headers: realHeaders,
            body: openapi_util_1.default.parseToMap(body),
        });
        let params = new $OpenApi.Params({
            action: "UploadEvent",
            version: "devicemng_1.0",
            protocol: "HTTP",
            pathname: `/v1.0/devicemng/suppliers/events/upload`,
            method: "POST",
            authType: "AK",
            style: "ROA",
            reqBodyType: "none",
            bodyType: "json",
        });
        return $tea.cast(await this.execute(params, req, runtime), new UploadEventResponse({}));
    }
    /**
     * 设备事件上报
     *
     * @param request - UploadEventRequest
     * @returns UploadEventResponse
     */
    async uploadEvent(request) {
        let runtime = new $Util.RuntimeOptions({});
        let headers = new UploadEventHeaders({});
        return await this.uploadEventWithOptions(request, headers, runtime);
    }
}
exports.default = Client;
//# sourceMappingURL=client.js.map