# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
from typing import List, Dict, Any


class AttachStreamRequestStreams(TeaModel):
    def __init__(
        self,
        stream_name: str = None,
        stream_url: str = None,
    ):
        self.stream_name = stream_name
        self.stream_url = stream_url

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.stream_name is not None:
            result['StreamName'] = self.stream_name
        if self.stream_url is not None:
            result['StreamURL'] = self.stream_url
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StreamName') is not None:
            self.stream_name = m.get('StreamName')
        if m.get('StreamURL') is not None:
            self.stream_url = m.get('StreamURL')
        return self


class AttachStreamRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        region_id: str = None,
        instance_id: str = None,
        streams: List[AttachStreamRequestStreams] = None,
    ):
        self.job_group_id = job_group_id
        self.region_id = region_id
        self.instance_id = instance_id
        self.streams = streams

    def validate(self):
        if self.streams:
            for k in self.streams:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        result['Streams'] = []
        if self.streams is not None:
            for k in self.streams:
                result['Streams'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        self.streams = []
        if m.get('Streams') is not None:
            for k in m.get('Streams'):
                temp_model = AttachStreamRequestStreams()
                self.streams.append(temp_model.from_map(k))
        return self


class AttachStreamResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class AttachStreamResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: AttachStreamResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = AttachStreamResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class BatchModifyCameraStatusRequest(TeaModel):
    def __init__(
        self,
        stream_status: str = None,
        camera_ids: str = None,
        work_group_id: str = None,
        region_id: str = None,
    ):
        self.stream_status = stream_status
        self.camera_ids = camera_ids
        self.work_group_id = work_group_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.stream_status is not None:
            result['StreamStatus'] = self.stream_status
        if self.camera_ids is not None:
            result['CameraIds'] = self.camera_ids
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StreamStatus') is not None:
            self.stream_status = m.get('StreamStatus')
        if m.get('CameraIds') is not None:
            self.camera_ids = m.get('CameraIds')
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class BatchModifyCameraStatusResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class BatchModifyCameraStatusResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: BatchModifyCameraStatusResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = BatchModifyCameraStatusResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateAlgoLibRequest(TeaModel):
    def __init__(
        self,
        algo_lib_name: str = None,
        algo_lib_version: str = None,
        capacity: int = None,
        oss_endpoint: str = None,
        oss_access_key_id: str = None,
        oss_bucket: str = None,
        oss_path: str = None,
        json_text: str = None,
        capability_names: str = None,
        oss_access_key_secret: str = None,
        text: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.algo_lib_name = algo_lib_name
        self.algo_lib_version = algo_lib_version
        self.capacity = capacity
        self.oss_endpoint = oss_endpoint
        self.oss_access_key_id = oss_access_key_id
        self.oss_bucket = oss_bucket
        self.oss_path = oss_path
        self.json_text = json_text
        self.capability_names = capability_names
        self.oss_access_key_secret = oss_access_key_secret
        self.text = text
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.algo_lib_name is not None:
            result['AlgoLibName'] = self.algo_lib_name
        if self.algo_lib_version is not None:
            result['AlgoLibVersion'] = self.algo_lib_version
        if self.capacity is not None:
            result['Capacity'] = self.capacity
        if self.oss_endpoint is not None:
            result['OssEndpoint'] = self.oss_endpoint
        if self.oss_access_key_id is not None:
            result['OssAccessKeyId'] = self.oss_access_key_id
        if self.oss_bucket is not None:
            result['OssBucket'] = self.oss_bucket
        if self.oss_path is not None:
            result['OssPath'] = self.oss_path
        if self.json_text is not None:
            result['JsonText'] = self.json_text
        if self.capability_names is not None:
            result['CapabilityNames'] = self.capability_names
        if self.oss_access_key_secret is not None:
            result['OssAccessKeySecret'] = self.oss_access_key_secret
        if self.text is not None:
            result['Text'] = self.text
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('AlgoLibName') is not None:
            self.algo_lib_name = m.get('AlgoLibName')
        if m.get('AlgoLibVersion') is not None:
            self.algo_lib_version = m.get('AlgoLibVersion')
        if m.get('Capacity') is not None:
            self.capacity = m.get('Capacity')
        if m.get('OssEndpoint') is not None:
            self.oss_endpoint = m.get('OssEndpoint')
        if m.get('OssAccessKeyId') is not None:
            self.oss_access_key_id = m.get('OssAccessKeyId')
        if m.get('OssBucket') is not None:
            self.oss_bucket = m.get('OssBucket')
        if m.get('OssPath') is not None:
            self.oss_path = m.get('OssPath')
        if m.get('JsonText') is not None:
            self.json_text = m.get('JsonText')
        if m.get('CapabilityNames') is not None:
            self.capability_names = m.get('CapabilityNames')
        if m.get('OssAccessKeySecret') is not None:
            self.oss_access_key_secret = m.get('OssAccessKeySecret')
        if m.get('Text') is not None:
            self.text = m.get('Text')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class CreateAlgoLibResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        algo_lib_id: str = None,
    ):
        self.request_id = request_id
        self.algo_lib_id = algo_lib_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        return self


class CreateAlgoLibResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateAlgoLibResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateAlgoLibResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateCameraRequest(TeaModel):
    def __init__(
        self,
        camera_name: str = None,
        work_group_id: str = None,
        camera_id: str = None,
        location_info: str = None,
        invite_uri: str = None,
        oss_path: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.camera_name = camera_name
        self.work_group_id = work_group_id
        self.camera_id = camera_id
        self.location_info = location_info
        self.invite_uri = invite_uri
        self.oss_path = oss_path
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_name is not None:
            result['CameraName'] = self.camera_name
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.location_info is not None:
            result['LocationInfo'] = self.location_info
        if self.invite_uri is not None:
            result['InviteUri'] = self.invite_uri
        if self.oss_path is not None:
            result['OssPath'] = self.oss_path
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraName') is not None:
            self.camera_name = m.get('CameraName')
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('LocationInfo') is not None:
            self.location_info = m.get('LocationInfo')
        if m.get('InviteUri') is not None:
            self.invite_uri = m.get('InviteUri')
        if m.get('OssPath') is not None:
            self.oss_path = m.get('OssPath')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class CreateCameraResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        camera_id: str = None,
    ):
        self.request_id = request_id
        self.camera_id = camera_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        return self


class CreateCameraResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateCameraResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateCameraResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateCapabilityRequest(TeaModel):
    def __init__(
        self,
        capability_name: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.capability_name = capability_name
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.capability_name is not None:
            result['CapabilityName'] = self.capability_name
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CapabilityName') is not None:
            self.capability_name = m.get('CapabilityName')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class CreateCapabilityResponseBody(TeaModel):
    def __init__(
        self,
        capability_id: str = None,
        request_id: str = None,
    ):
        self.capability_id = capability_id
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.capability_id is not None:
            result['CapabilityId'] = self.capability_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CapabilityId') is not None:
            self.capability_id = m.get('CapabilityId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateCapabilityResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateCapabilityResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateCapabilityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateInstanceRequest(TeaModel):
    def __init__(
        self,
        instance_name: str = None,
        description: str = None,
        instance_capacity: int = None,
        status: str = None,
        region_id: str = None,
    ):
        self.instance_name = instance_name
        self.description = description
        self.instance_capacity = instance_capacity
        self.status = status
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.instance_name is not None:
            result['InstanceName'] = self.instance_name
        if self.description is not None:
            result['Description'] = self.description
        if self.instance_capacity is not None:
            result['InstanceCapacity'] = self.instance_capacity
        if self.status is not None:
            result['Status'] = self.status
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('InstanceName') is not None:
            self.instance_name = m.get('InstanceName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('InstanceCapacity') is not None:
            self.instance_capacity = m.get('InstanceCapacity')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class CreateInstanceResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        instance_id: str = None,
    ):
        self.request_id = request_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class CreateInstanceResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateInstanceResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateJobGroupRequestJobGroupParams(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class CreateJobGroupRequest(TeaModel):
    def __init__(
        self,
        job_group_name: str = None,
        resource_profile_id: str = None,
        algo_lib_id: str = None,
        planed_job_count: int = None,
        stream_per_job: int = None,
        job_count: int = None,
        instance_id: str = None,
        region_id: str = None,
        job_group_params: List[CreateJobGroupRequestJobGroupParams] = None,
    ):
        self.job_group_name = job_group_name
        self.resource_profile_id = resource_profile_id
        self.algo_lib_id = algo_lib_id
        self.planed_job_count = planed_job_count
        self.stream_per_job = stream_per_job
        self.job_count = job_count
        self.instance_id = instance_id
        self.region_id = region_id
        self.job_group_params = job_group_params

    def validate(self):
        if self.job_group_params:
            for k in self.job_group_params:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.job_group_name is not None:
            result['JobGroupName'] = self.job_group_name
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.planed_job_count is not None:
            result['PlanedJobCount'] = self.planed_job_count
        if self.stream_per_job is not None:
            result['StreamPerJob'] = self.stream_per_job
        if self.job_count is not None:
            result['JobCount'] = self.job_count
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        result['JobGroupParams'] = []
        if self.job_group_params is not None:
            for k in self.job_group_params:
                result['JobGroupParams'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupName') is not None:
            self.job_group_name = m.get('JobGroupName')
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('PlanedJobCount') is not None:
            self.planed_job_count = m.get('PlanedJobCount')
        if m.get('StreamPerJob') is not None:
            self.stream_per_job = m.get('StreamPerJob')
        if m.get('JobCount') is not None:
            self.job_count = m.get('JobCount')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        self.job_group_params = []
        if m.get('JobGroupParams') is not None:
            for k in m.get('JobGroupParams'):
                temp_model = CreateJobGroupRequestJobGroupParams()
                self.job_group_params.append(temp_model.from_map(k))
        return self


class CreateJobGroupResponseBody(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        request_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateJobGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateJobGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateJobGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateResourceProfileRequestResourceProfileParams(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class CreateResourceProfileRequest(TeaModel):
    def __init__(
        self,
        resource_profile_name: str = None,
        instance_id: str = None,
        region_id: str = None,
        resource_profile_params: List[CreateResourceProfileRequestResourceProfileParams] = None,
    ):
        self.resource_profile_name = resource_profile_name
        self.instance_id = instance_id
        self.region_id = region_id
        self.resource_profile_params = resource_profile_params

    def validate(self):
        if self.resource_profile_params:
            for k in self.resource_profile_params:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.resource_profile_name is not None:
            result['ResourceProfileName'] = self.resource_profile_name
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        result['ResourceProfileParams'] = []
        if self.resource_profile_params is not None:
            for k in self.resource_profile_params:
                result['ResourceProfileParams'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('ResourceProfileName') is not None:
            self.resource_profile_name = m.get('ResourceProfileName')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        self.resource_profile_params = []
        if m.get('ResourceProfileParams') is not None:
            for k in m.get('ResourceProfileParams'):
                temp_model = CreateResourceProfileRequestResourceProfileParams()
                self.resource_profile_params.append(temp_model.from_map(k))
        return self


class CreateResourceProfileResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        resource_profile_id: str = None,
    ):
        self.request_id = request_id
        self.resource_profile_id = resource_profile_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        return self


class CreateResourceProfileResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateResourceProfileResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateResourceProfileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateWorkGroupRequest(TeaModel):
    def __init__(
        self,
        work_group_name: str = None,
        protocol: str = None,
        theory_cut_status: str = None,
        description: str = None,
        job_num: int = None,
        topic_num: int = None,
        topic_prefix: str = None,
        account: str = None,
        password: str = None,
        ip: str = None,
        port: int = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.work_group_name = work_group_name
        self.protocol = protocol
        self.theory_cut_status = theory_cut_status
        self.description = description
        self.job_num = job_num
        self.topic_num = topic_num
        self.topic_prefix = topic_prefix
        self.account = account
        self.password = password
        self.ip = ip
        self.port = port
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.work_group_name is not None:
            result['WorkGroupName'] = self.work_group_name
        if self.protocol is not None:
            result['Protocol'] = self.protocol
        if self.theory_cut_status is not None:
            result['TheoryCutStatus'] = self.theory_cut_status
        if self.description is not None:
            result['Description'] = self.description
        if self.job_num is not None:
            result['JobNum'] = self.job_num
        if self.topic_num is not None:
            result['TopicNum'] = self.topic_num
        if self.topic_prefix is not None:
            result['TopicPrefix'] = self.topic_prefix
        if self.account is not None:
            result['Account'] = self.account
        if self.password is not None:
            result['Password'] = self.password
        if self.ip is not None:
            result['Ip'] = self.ip
        if self.port is not None:
            result['Port'] = self.port
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('WorkGroupName') is not None:
            self.work_group_name = m.get('WorkGroupName')
        if m.get('Protocol') is not None:
            self.protocol = m.get('Protocol')
        if m.get('TheoryCutStatus') is not None:
            self.theory_cut_status = m.get('TheoryCutStatus')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('JobNum') is not None:
            self.job_num = m.get('JobNum')
        if m.get('TopicNum') is not None:
            self.topic_num = m.get('TopicNum')
        if m.get('TopicPrefix') is not None:
            self.topic_prefix = m.get('TopicPrefix')
        if m.get('Account') is not None:
            self.account = m.get('Account')
        if m.get('Password') is not None:
            self.password = m.get('Password')
        if m.get('Ip') is not None:
            self.ip = m.get('Ip')
        if m.get('Port') is not None:
            self.port = m.get('Port')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class CreateWorkGroupResponseBody(TeaModel):
    def __init__(
        self,
        work_group_id: str = None,
        request_id: str = None,
    ):
        self.work_group_id = work_group_id
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateWorkGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: CreateWorkGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = CreateWorkGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteAlgoLibRequest(TeaModel):
    def __init__(
        self,
        algo_lib_id: str = None,
        region_id: str = None,
    ):
        self.algo_lib_id = algo_lib_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DeleteAlgoLibResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteAlgoLibResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteAlgoLibResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteAlgoLibResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteCameraRequest(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        region_id: str = None,
    ):
        self.camera_id = camera_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DeleteCameraResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteCameraResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteCameraResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteCameraResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteCapabilityRequest(TeaModel):
    def __init__(
        self,
        capability_id: str = None,
        region_id: str = None,
    ):
        self.capability_id = capability_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.capability_id is not None:
            result['CapabilityId'] = self.capability_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CapabilityId') is not None:
            self.capability_id = m.get('CapabilityId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DeleteCapabilityResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteCapabilityResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteCapabilityResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteCapabilityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteInstanceRequest(TeaModel):
    def __init__(
        self,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DeleteInstanceResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteInstanceResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteInstanceResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteJobGroupRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        region_id: str = None,
        instance_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.region_id = region_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class DeleteJobGroupResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteJobGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteJobGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteJobGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteResourceProfileRequest(TeaModel):
    def __init__(
        self,
        resource_profile_id: str = None,
        region_id: str = None,
    ):
        self.resource_profile_id = resource_profile_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DeleteResourceProfileResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteResourceProfileResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteResourceProfileResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteResourceProfileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteWorkGroupRequest(TeaModel):
    def __init__(
        self,
        work_group_id: str = None,
        region_id: str = None,
    ):
        self.work_group_id = work_group_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DeleteWorkGroupResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteWorkGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DeleteWorkGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DeleteWorkGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeAlgoLibsRequest(TeaModel):
    def __init__(
        self,
        algo_lib_name: str = None,
        capability_name: str = None,
        page_number: int = None,
        page_size: int = None,
        instance_id: str = None,
        algo_lib_id: str = None,
        region_id: str = None,
    ):
        self.algo_lib_name = algo_lib_name
        self.capability_name = capability_name
        self.page_number = page_number
        self.page_size = page_size
        self.instance_id = instance_id
        self.algo_lib_id = algo_lib_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.algo_lib_name is not None:
            result['AlgoLibName'] = self.algo_lib_name
        if self.capability_name is not None:
            result['CapabilityName'] = self.capability_name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('AlgoLibName') is not None:
            self.algo_lib_name = m.get('AlgoLibName')
        if m.get('CapabilityName') is not None:
            self.capability_name = m.get('CapabilityName')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeAlgoLibsResponseBodyAlgoLibsAlgoLib(TeaModel):
    def __init__(
        self,
        oss_access_key_id: str = None,
        capacity: str = None,
        algo_lib_id: str = None,
        json_text: str = None,
        algo_lib_version: str = None,
        algo_lib_name: str = None,
        text: str = None,
        oss_bucket: str = None,
        capability_names: str = None,
        oss_path: str = None,
        oss_endpoint: str = None,
        upload_time: str = None,
    ):
        self.oss_access_key_id = oss_access_key_id
        self.capacity = capacity
        self.algo_lib_id = algo_lib_id
        self.json_text = json_text
        self.algo_lib_version = algo_lib_version
        self.algo_lib_name = algo_lib_name
        self.text = text
        self.oss_bucket = oss_bucket
        self.capability_names = capability_names
        self.oss_path = oss_path
        self.oss_endpoint = oss_endpoint
        self.upload_time = upload_time

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.oss_access_key_id is not None:
            result['OssAccessKeyId'] = self.oss_access_key_id
        if self.capacity is not None:
            result['Capacity'] = self.capacity
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.json_text is not None:
            result['JsonText'] = self.json_text
        if self.algo_lib_version is not None:
            result['AlgoLibVersion'] = self.algo_lib_version
        if self.algo_lib_name is not None:
            result['AlgoLibName'] = self.algo_lib_name
        if self.text is not None:
            result['Text'] = self.text
        if self.oss_bucket is not None:
            result['OssBucket'] = self.oss_bucket
        if self.capability_names is not None:
            result['CapabilityNames'] = self.capability_names
        if self.oss_path is not None:
            result['OssPath'] = self.oss_path
        if self.oss_endpoint is not None:
            result['OssEndpoint'] = self.oss_endpoint
        if self.upload_time is not None:
            result['UploadTime'] = self.upload_time
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('OssAccessKeyId') is not None:
            self.oss_access_key_id = m.get('OssAccessKeyId')
        if m.get('Capacity') is not None:
            self.capacity = m.get('Capacity')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('JsonText') is not None:
            self.json_text = m.get('JsonText')
        if m.get('AlgoLibVersion') is not None:
            self.algo_lib_version = m.get('AlgoLibVersion')
        if m.get('AlgoLibName') is not None:
            self.algo_lib_name = m.get('AlgoLibName')
        if m.get('Text') is not None:
            self.text = m.get('Text')
        if m.get('OssBucket') is not None:
            self.oss_bucket = m.get('OssBucket')
        if m.get('CapabilityNames') is not None:
            self.capability_names = m.get('CapabilityNames')
        if m.get('OssPath') is not None:
            self.oss_path = m.get('OssPath')
        if m.get('OssEndpoint') is not None:
            self.oss_endpoint = m.get('OssEndpoint')
        if m.get('UploadTime') is not None:
            self.upload_time = m.get('UploadTime')
        return self


class DescribeAlgoLibsResponseBodyAlgoLibs(TeaModel):
    def __init__(
        self,
        algo_lib: List[DescribeAlgoLibsResponseBodyAlgoLibsAlgoLib] = None,
    ):
        self.algo_lib = algo_lib

    def validate(self):
        if self.algo_lib:
            for k in self.algo_lib:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['AlgoLib'] = []
        if self.algo_lib is not None:
            for k in self.algo_lib:
                result['AlgoLib'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.algo_lib = []
        if m.get('AlgoLib') is not None:
            for k in m.get('AlgoLib'):
                temp_model = DescribeAlgoLibsResponseBodyAlgoLibsAlgoLib()
                self.algo_lib.append(temp_model.from_map(k))
        return self


class DescribeAlgoLibsResponseBody(TeaModel):
    def __init__(
        self,
        algo_libs: DescribeAlgoLibsResponseBodyAlgoLibs = None,
        total_count: int = None,
        page_size: int = None,
        request_id: str = None,
        page_number: int = None,
    ):
        self.algo_libs = algo_libs
        self.total_count = total_count
        self.page_size = page_size
        self.request_id = request_id
        self.page_number = page_number

    def validate(self):
        if self.algo_libs:
            self.algo_libs.validate()

    def to_map(self):
        result = dict()
        if self.algo_libs is not None:
            result['AlgoLibs'] = self.algo_libs.to_map()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('AlgoLibs') is not None:
            temp_model = DescribeAlgoLibsResponseBodyAlgoLibs()
            self.algo_libs = temp_model.from_map(m['AlgoLibs'])
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        return self


class DescribeAlgoLibsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeAlgoLibsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeAlgoLibsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeCamerasRequest(TeaModel):
    def __init__(
        self,
        page_number: int = None,
        page_size: int = None,
        camera_id: str = None,
        camera_name: str = None,
        stream_status: str = None,
        work_group_id: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.page_number = page_number
        self.page_size = page_size
        self.camera_id = camera_id
        self.camera_name = camera_name
        self.stream_status = stream_status
        self.work_group_id = work_group_id
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.camera_name is not None:
            result['CameraName'] = self.camera_name
        if self.stream_status is not None:
            result['StreamStatus'] = self.stream_status
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('CameraName') is not None:
            self.camera_name = m.get('CameraName')
        if m.get('StreamStatus') is not None:
            self.stream_status = m.get('StreamStatus')
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeCamerasResponseBodyCamerasCamera(TeaModel):
    def __init__(
        self,
        stream_status: str = None,
        update_time: str = None,
        camera_id: str = None,
        conf: str = None,
        rtmp_path: str = None,
        invite_uri: str = None,
        camera_name: str = None,
        work_group_id: str = None,
        location: str = None,
    ):
        self.stream_status = stream_status
        self.update_time = update_time
        self.camera_id = camera_id
        self.conf = conf
        self.rtmp_path = rtmp_path
        self.invite_uri = invite_uri
        self.camera_name = camera_name
        self.work_group_id = work_group_id
        self.location = location

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.stream_status is not None:
            result['StreamStatus'] = self.stream_status
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.conf is not None:
            result['Conf'] = self.conf
        if self.rtmp_path is not None:
            result['RtmpPath'] = self.rtmp_path
        if self.invite_uri is not None:
            result['InviteUri'] = self.invite_uri
        if self.camera_name is not None:
            result['CameraName'] = self.camera_name
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.location is not None:
            result['Location'] = self.location
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StreamStatus') is not None:
            self.stream_status = m.get('StreamStatus')
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('Conf') is not None:
            self.conf = m.get('Conf')
        if m.get('RtmpPath') is not None:
            self.rtmp_path = m.get('RtmpPath')
        if m.get('InviteUri') is not None:
            self.invite_uri = m.get('InviteUri')
        if m.get('CameraName') is not None:
            self.camera_name = m.get('CameraName')
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        return self


class DescribeCamerasResponseBodyCameras(TeaModel):
    def __init__(
        self,
        camera: List[DescribeCamerasResponseBodyCamerasCamera] = None,
    ):
        self.camera = camera

    def validate(self):
        if self.camera:
            for k in self.camera:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['Camera'] = []
        if self.camera is not None:
            for k in self.camera:
                result['Camera'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.camera = []
        if m.get('Camera') is not None:
            for k in m.get('Camera'):
                temp_model = DescribeCamerasResponseBodyCamerasCamera()
                self.camera.append(temp_model.from_map(k))
        return self


class DescribeCamerasResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        request_id: str = None,
        page_size: int = None,
        page_number: int = None,
        cameras: DescribeCamerasResponseBodyCameras = None,
    ):
        self.total_count = total_count
        self.request_id = request_id
        self.page_size = page_size
        self.page_number = page_number
        self.cameras = cameras

    def validate(self):
        if self.cameras:
            self.cameras.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.cameras is not None:
            result['Cameras'] = self.cameras.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('Cameras') is not None:
            temp_model = DescribeCamerasResponseBodyCameras()
            self.cameras = temp_model.from_map(m['Cameras'])
        return self


class DescribeCamerasResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeCamerasResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeCamerasResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeCapabilitiesRequest(TeaModel):
    def __init__(
        self,
        page_number: int = None,
        page_size: int = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.page_number = page_number
        self.page_size = page_size
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeCapabilitiesResponseBodyCapabilitiesCapability(TeaModel):
    def __init__(
        self,
        capability_id: str = None,
        capability_name: str = None,
    ):
        self.capability_id = capability_id
        self.capability_name = capability_name

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.capability_id is not None:
            result['CapabilityId'] = self.capability_id
        if self.capability_name is not None:
            result['CapabilityName'] = self.capability_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CapabilityId') is not None:
            self.capability_id = m.get('CapabilityId')
        if m.get('CapabilityName') is not None:
            self.capability_name = m.get('CapabilityName')
        return self


class DescribeCapabilitiesResponseBodyCapabilities(TeaModel):
    def __init__(
        self,
        capability: List[DescribeCapabilitiesResponseBodyCapabilitiesCapability] = None,
    ):
        self.capability = capability

    def validate(self):
        if self.capability:
            for k in self.capability:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['Capability'] = []
        if self.capability is not None:
            for k in self.capability:
                result['Capability'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.capability = []
        if m.get('Capability') is not None:
            for k in m.get('Capability'):
                temp_model = DescribeCapabilitiesResponseBodyCapabilitiesCapability()
                self.capability.append(temp_model.from_map(k))
        return self


class DescribeCapabilitiesResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        page_size: int = None,
        request_id: str = None,
        page_number: int = None,
        capabilities: DescribeCapabilitiesResponseBodyCapabilities = None,
    ):
        self.total_count = total_count
        self.page_size = page_size
        self.request_id = request_id
        self.page_number = page_number
        self.capabilities = capabilities

    def validate(self):
        if self.capabilities:
            self.capabilities.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.capabilities is not None:
            result['Capabilities'] = self.capabilities.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('Capabilities') is not None:
            temp_model = DescribeCapabilitiesResponseBodyCapabilities()
            self.capabilities = temp_model.from_map(m['Capabilities'])
        return self


class DescribeCapabilitiesResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeCapabilitiesResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeCapabilitiesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeInstancesRequest(TeaModel):
    def __init__(
        self,
        instance_name: str = None,
        region_id: str = None,
        instance_ids: str = None,
        page_number: int = None,
        page_size: int = None,
    ):
        self.instance_name = instance_name
        self.region_id = region_id
        self.instance_ids = instance_ids
        self.page_number = page_number
        self.page_size = page_size

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.instance_name is not None:
            result['InstanceName'] = self.instance_name
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_ids is not None:
            result['InstanceIds'] = self.instance_ids
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('InstanceName') is not None:
            self.instance_name = m.get('InstanceName')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceIds') is not None:
            self.instance_ids = m.get('InstanceIds')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class DescribeInstancesResponseBodyInstancesInstance(TeaModel):
    def __init__(
        self,
        status: str = None,
        instance_capacity: int = None,
        description: str = None,
        create_time: str = None,
        instance_name: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.status = status
        self.instance_capacity = instance_capacity
        self.description = description
        self.create_time = create_time
        self.instance_name = instance_name
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.status is not None:
            result['Status'] = self.status
        if self.instance_capacity is not None:
            result['InstanceCapacity'] = self.instance_capacity
        if self.description is not None:
            result['Description'] = self.description
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.instance_name is not None:
            result['InstanceName'] = self.instance_name
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('InstanceCapacity') is not None:
            self.instance_capacity = m.get('InstanceCapacity')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('InstanceName') is not None:
            self.instance_name = m.get('InstanceName')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeInstancesResponseBodyInstances(TeaModel):
    def __init__(
        self,
        instance: List[DescribeInstancesResponseBodyInstancesInstance] = None,
    ):
        self.instance = instance

    def validate(self):
        if self.instance:
            for k in self.instance:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['Instance'] = []
        if self.instance is not None:
            for k in self.instance:
                result['Instance'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.instance = []
        if m.get('Instance') is not None:
            for k in m.get('Instance'):
                temp_model = DescribeInstancesResponseBodyInstancesInstance()
                self.instance.append(temp_model.from_map(k))
        return self


class DescribeInstancesResponseBody(TeaModel):
    def __init__(
        self,
        instances: DescribeInstancesResponseBodyInstances = None,
        total_count: int = None,
        request_id: str = None,
        page_size: int = None,
        page_number: int = None,
    ):
        self.instances = instances
        self.total_count = total_count
        self.request_id = request_id
        self.page_size = page_size
        self.page_number = page_number

    def validate(self):
        if self.instances:
            self.instances.validate()

    def to_map(self):
        result = dict()
        if self.instances is not None:
            result['Instances'] = self.instances.to_map()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Instances') is not None:
            temp_model = DescribeInstancesResponseBodyInstances()
            self.instances = temp_model.from_map(m['Instances'])
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        return self


class DescribeInstancesResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeInstancesResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeInstancesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeJobGroupsRequest(TeaModel):
    def __init__(
        self,
        page_number: int = None,
        page_size: int = None,
        instance_id: str = None,
        job_group_id: str = None,
        region_id: str = None,
    ):
        self.page_number = page_number
        self.page_size = page_size
        self.instance_id = instance_id
        self.job_group_id = job_group_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeJobGroupsResponseBodyJobGroupsJobGroupJobGroupParamsJobGroupParam(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class DescribeJobGroupsResponseBodyJobGroupsJobGroupJobGroupParams(TeaModel):
    def __init__(
        self,
        job_group_param: List[DescribeJobGroupsResponseBodyJobGroupsJobGroupJobGroupParamsJobGroupParam] = None,
    ):
        self.job_group_param = job_group_param

    def validate(self):
        if self.job_group_param:
            for k in self.job_group_param:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['JobGroupParam'] = []
        if self.job_group_param is not None:
            for k in self.job_group_param:
                result['JobGroupParam'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.job_group_param = []
        if m.get('JobGroupParam') is not None:
            for k in m.get('JobGroupParam'):
                temp_model = DescribeJobGroupsResponseBodyJobGroupsJobGroupJobGroupParamsJobGroupParam()
                self.job_group_param.append(temp_model.from_map(k))
        return self


class DescribeJobGroupsResponseBodyJobGroupsJobGroupComputeJobsComputeJob(TeaModel):
    def __init__(
        self,
        end_time: str = None,
        start_time: str = None,
        compute_job_name: str = None,
        compute_job_id: str = None,
        compute_job_status: str = None,
        duration: int = None,
    ):
        self.end_time = end_time
        self.start_time = start_time
        self.compute_job_name = compute_job_name
        self.compute_job_id = compute_job_id
        self.compute_job_status = compute_job_status
        self.duration = duration

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.compute_job_name is not None:
            result['ComputeJobName'] = self.compute_job_name
        if self.compute_job_id is not None:
            result['ComputeJobId'] = self.compute_job_id
        if self.compute_job_status is not None:
            result['ComputeJobStatus'] = self.compute_job_status
        if self.duration is not None:
            result['Duration'] = self.duration
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('ComputeJobName') is not None:
            self.compute_job_name = m.get('ComputeJobName')
        if m.get('ComputeJobId') is not None:
            self.compute_job_id = m.get('ComputeJobId')
        if m.get('ComputeJobStatus') is not None:
            self.compute_job_status = m.get('ComputeJobStatus')
        if m.get('Duration') is not None:
            self.duration = m.get('Duration')
        return self


class DescribeJobGroupsResponseBodyJobGroupsJobGroupComputeJobs(TeaModel):
    def __init__(
        self,
        compute_job: List[DescribeJobGroupsResponseBodyJobGroupsJobGroupComputeJobsComputeJob] = None,
    ):
        self.compute_job = compute_job

    def validate(self):
        if self.compute_job:
            for k in self.compute_job:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['ComputeJob'] = []
        if self.compute_job is not None:
            for k in self.compute_job:
                result['ComputeJob'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.compute_job = []
        if m.get('ComputeJob') is not None:
            for k in m.get('ComputeJob'):
                temp_model = DescribeJobGroupsResponseBodyJobGroupsJobGroupComputeJobsComputeJob()
                self.compute_job.append(temp_model.from_map(k))
        return self


class DescribeJobGroupsResponseBodyJobGroupsJobGroup(TeaModel):
    def __init__(
        self,
        status: str = None,
        job_group_id: str = None,
        algo_lib_id: str = None,
        job_count: int = None,
        job_group_name: str = None,
        job_group_params: DescribeJobGroupsResponseBodyJobGroupsJobGroupJobGroupParams = None,
        resource_profile_id: str = None,
        stream_per_job: int = None,
        planed_job_count: int = None,
        compute_jobs: DescribeJobGroupsResponseBodyJobGroupsJobGroupComputeJobs = None,
    ):
        self.status = status
        self.job_group_id = job_group_id
        self.algo_lib_id = algo_lib_id
        self.job_count = job_count
        self.job_group_name = job_group_name
        self.job_group_params = job_group_params
        self.resource_profile_id = resource_profile_id
        self.stream_per_job = stream_per_job
        self.planed_job_count = planed_job_count
        self.compute_jobs = compute_jobs

    def validate(self):
        if self.job_group_params:
            self.job_group_params.validate()
        if self.compute_jobs:
            self.compute_jobs.validate()

    def to_map(self):
        result = dict()
        if self.status is not None:
            result['Status'] = self.status
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.job_count is not None:
            result['JobCount'] = self.job_count
        if self.job_group_name is not None:
            result['JobGroupName'] = self.job_group_name
        if self.job_group_params is not None:
            result['JobGroupParams'] = self.job_group_params.to_map()
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.stream_per_job is not None:
            result['StreamPerJob'] = self.stream_per_job
        if self.planed_job_count is not None:
            result['PlanedJobCount'] = self.planed_job_count
        if self.compute_jobs is not None:
            result['ComputeJobs'] = self.compute_jobs.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('JobCount') is not None:
            self.job_count = m.get('JobCount')
        if m.get('JobGroupName') is not None:
            self.job_group_name = m.get('JobGroupName')
        if m.get('JobGroupParams') is not None:
            temp_model = DescribeJobGroupsResponseBodyJobGroupsJobGroupJobGroupParams()
            self.job_group_params = temp_model.from_map(m['JobGroupParams'])
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('StreamPerJob') is not None:
            self.stream_per_job = m.get('StreamPerJob')
        if m.get('PlanedJobCount') is not None:
            self.planed_job_count = m.get('PlanedJobCount')
        if m.get('ComputeJobs') is not None:
            temp_model = DescribeJobGroupsResponseBodyJobGroupsJobGroupComputeJobs()
            self.compute_jobs = temp_model.from_map(m['ComputeJobs'])
        return self


class DescribeJobGroupsResponseBodyJobGroups(TeaModel):
    def __init__(
        self,
        job_group: List[DescribeJobGroupsResponseBodyJobGroupsJobGroup] = None,
    ):
        self.job_group = job_group

    def validate(self):
        if self.job_group:
            for k in self.job_group:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['JobGroup'] = []
        if self.job_group is not None:
            for k in self.job_group:
                result['JobGroup'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.job_group = []
        if m.get('JobGroup') is not None:
            for k in m.get('JobGroup'):
                temp_model = DescribeJobGroupsResponseBodyJobGroupsJobGroup()
                self.job_group.append(temp_model.from_map(k))
        return self


class DescribeJobGroupsResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        request_id: str = None,
        page_size: int = None,
        page_number: int = None,
        job_groups: DescribeJobGroupsResponseBodyJobGroups = None,
    ):
        self.total_count = total_count
        self.request_id = request_id
        self.page_size = page_size
        self.page_number = page_number
        self.job_groups = job_groups

    def validate(self):
        if self.job_groups:
            self.job_groups.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.job_groups is not None:
            result['JobGroups'] = self.job_groups.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('JobGroups') is not None:
            temp_model = DescribeJobGroupsResponseBodyJobGroups()
            self.job_groups = temp_model.from_map(m['JobGroups'])
        return self


class DescribeJobGroupsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeJobGroupsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeJobGroupsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeProtocolsRequest(TeaModel):
    def __init__(
        self,
        region_id: str = None,
    ):
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeProtocolsResponseBody(TeaModel):
    def __init__(
        self,
        protocols: Dict[str, Any] = None,
        request_id: str = None,
    ):
        self.protocols = protocols
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DescribeProtocolsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeProtocolsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeProtocolsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeRegionsRequest(TeaModel):
    def __init__(
        self,
        accept_language: str = None,
    ):
        self.accept_language = accept_language

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.accept_language is not None:
            result['AcceptLanguage'] = self.accept_language
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('AcceptLanguage') is not None:
            self.accept_language = m.get('AcceptLanguage')
        return self


class DescribeRegionsResponseBodyRegionsRegion(TeaModel):
    def __init__(
        self,
        local_name: str = None,
        region_endpoint: str = None,
        region_id: str = None,
    ):
        self.local_name = local_name
        self.region_endpoint = region_endpoint
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.local_name is not None:
            result['LocalName'] = self.local_name
        if self.region_endpoint is not None:
            result['RegionEndpoint'] = self.region_endpoint
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('LocalName') is not None:
            self.local_name = m.get('LocalName')
        if m.get('RegionEndpoint') is not None:
            self.region_endpoint = m.get('RegionEndpoint')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeRegionsResponseBodyRegions(TeaModel):
    def __init__(
        self,
        region: List[DescribeRegionsResponseBodyRegionsRegion] = None,
    ):
        self.region = region

    def validate(self):
        if self.region:
            for k in self.region:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['Region'] = []
        if self.region is not None:
            for k in self.region:
                result['Region'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.region = []
        if m.get('Region') is not None:
            for k in m.get('Region'):
                temp_model = DescribeRegionsResponseBodyRegionsRegion()
                self.region.append(temp_model.from_map(k))
        return self


class DescribeRegionsResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        regions: DescribeRegionsResponseBodyRegions = None,
    ):
        self.request_id = request_id
        self.regions = regions

    def validate(self):
        if self.regions:
            self.regions.validate()

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.regions is not None:
            result['Regions'] = self.regions.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Regions') is not None:
            temp_model = DescribeRegionsResponseBodyRegions()
            self.regions = temp_model.from_map(m['Regions'])
        return self


class DescribeRegionsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeRegionsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeRegionsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeResourceProfilesRequest(TeaModel):
    def __init__(
        self,
        page_number: int = None,
        page_size: int = None,
        instance_id: str = None,
        resource_profile_id: str = None,
        region_id: str = None,
    ):
        self.page_number = page_number
        self.page_size = page_size
        self.instance_id = instance_id
        self.resource_profile_id = resource_profile_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeResourceProfilesResponseBodyResourceProfilesResourceProfileResourceProfileParamsResourceProfileParam(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class DescribeResourceProfilesResponseBodyResourceProfilesResourceProfileResourceProfileParams(TeaModel):
    def __init__(
        self,
        resource_profile_param: List[DescribeResourceProfilesResponseBodyResourceProfilesResourceProfileResourceProfileParamsResourceProfileParam] = None,
    ):
        self.resource_profile_param = resource_profile_param

    def validate(self):
        if self.resource_profile_param:
            for k in self.resource_profile_param:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['ResourceProfileParam'] = []
        if self.resource_profile_param is not None:
            for k in self.resource_profile_param:
                result['ResourceProfileParam'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.resource_profile_param = []
        if m.get('ResourceProfileParam') is not None:
            for k in m.get('ResourceProfileParam'):
                temp_model = DescribeResourceProfilesResponseBodyResourceProfilesResourceProfileResourceProfileParamsResourceProfileParam()
                self.resource_profile_param.append(temp_model.from_map(k))
        return self


class DescribeResourceProfilesResponseBodyResourceProfilesResourceProfile(TeaModel):
    def __init__(
        self,
        resource_profile_name: str = None,
        resource_profile_id: str = None,
        resource_profile_params: DescribeResourceProfilesResponseBodyResourceProfilesResourceProfileResourceProfileParams = None,
    ):
        self.resource_profile_name = resource_profile_name
        self.resource_profile_id = resource_profile_id
        self.resource_profile_params = resource_profile_params

    def validate(self):
        if self.resource_profile_params:
            self.resource_profile_params.validate()

    def to_map(self):
        result = dict()
        if self.resource_profile_name is not None:
            result['ResourceProfileName'] = self.resource_profile_name
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.resource_profile_params is not None:
            result['ResourceProfileParams'] = self.resource_profile_params.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('ResourceProfileName') is not None:
            self.resource_profile_name = m.get('ResourceProfileName')
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('ResourceProfileParams') is not None:
            temp_model = DescribeResourceProfilesResponseBodyResourceProfilesResourceProfileResourceProfileParams()
            self.resource_profile_params = temp_model.from_map(m['ResourceProfileParams'])
        return self


class DescribeResourceProfilesResponseBodyResourceProfiles(TeaModel):
    def __init__(
        self,
        resource_profile: List[DescribeResourceProfilesResponseBodyResourceProfilesResourceProfile] = None,
    ):
        self.resource_profile = resource_profile

    def validate(self):
        if self.resource_profile:
            for k in self.resource_profile:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['ResourceProfile'] = []
        if self.resource_profile is not None:
            for k in self.resource_profile:
                result['ResourceProfile'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.resource_profile = []
        if m.get('ResourceProfile') is not None:
            for k in m.get('ResourceProfile'):
                temp_model = DescribeResourceProfilesResponseBodyResourceProfilesResourceProfile()
                self.resource_profile.append(temp_model.from_map(k))
        return self


class DescribeResourceProfilesResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        request_id: str = None,
        page_size: int = None,
        page_number: int = None,
        resource_profiles: DescribeResourceProfilesResponseBodyResourceProfiles = None,
    ):
        self.total_count = total_count
        self.request_id = request_id
        self.page_size = page_size
        self.page_number = page_number
        self.resource_profiles = resource_profiles

    def validate(self):
        if self.resource_profiles:
            self.resource_profiles.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.resource_profiles is not None:
            result['ResourceProfiles'] = self.resource_profiles.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('ResourceProfiles') is not None:
            temp_model = DescribeResourceProfilesResponseBodyResourceProfiles()
            self.resource_profiles = temp_model.from_map(m['ResourceProfiles'])
        return self


class DescribeResourceProfilesResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeResourceProfilesResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeResourceProfilesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeStreamsRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        page_number: int = None,
        page_size: int = None,
        region_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.page_number = page_number
        self.page_size = page_size
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeStreamsResponseBodyStreamsStream(TeaModel):
    def __init__(
        self,
        job_group_id: int = None,
        stream_name: str = None,
        compute_job_id: str = None,
        obj_count: int = None,
        delay_ms: int = None,
        stream_url: str = None,
    ):
        self.job_group_id = job_group_id
        self.stream_name = stream_name
        self.compute_job_id = compute_job_id
        self.obj_count = obj_count
        self.delay_ms = delay_ms
        self.stream_url = stream_url

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.stream_name is not None:
            result['StreamName'] = self.stream_name
        if self.compute_job_id is not None:
            result['ComputeJobId'] = self.compute_job_id
        if self.obj_count is not None:
            result['ObjCount'] = self.obj_count
        if self.delay_ms is not None:
            result['DelayMS'] = self.delay_ms
        if self.stream_url is not None:
            result['StreamURL'] = self.stream_url
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('StreamName') is not None:
            self.stream_name = m.get('StreamName')
        if m.get('ComputeJobId') is not None:
            self.compute_job_id = m.get('ComputeJobId')
        if m.get('ObjCount') is not None:
            self.obj_count = m.get('ObjCount')
        if m.get('DelayMS') is not None:
            self.delay_ms = m.get('DelayMS')
        if m.get('StreamURL') is not None:
            self.stream_url = m.get('StreamURL')
        return self


class DescribeStreamsResponseBodyStreams(TeaModel):
    def __init__(
        self,
        stream: List[DescribeStreamsResponseBodyStreamsStream] = None,
    ):
        self.stream = stream

    def validate(self):
        if self.stream:
            for k in self.stream:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['Stream'] = []
        if self.stream is not None:
            for k in self.stream:
                result['Stream'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.stream = []
        if m.get('Stream') is not None:
            for k in m.get('Stream'):
                temp_model = DescribeStreamsResponseBodyStreamsStream()
                self.stream.append(temp_model.from_map(k))
        return self


class DescribeStreamsResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        page_size: int = None,
        request_id: str = None,
        page_number: int = None,
        streams: DescribeStreamsResponseBodyStreams = None,
    ):
        self.total_count = total_count
        self.page_size = page_size
        self.request_id = request_id
        self.page_number = page_number
        self.streams = streams

    def validate(self):
        if self.streams:
            self.streams.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.streams is not None:
            result['Streams'] = self.streams.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('Streams') is not None:
            temp_model = DescribeStreamsResponseBodyStreams()
            self.streams = temp_model.from_map(m['Streams'])
        return self


class DescribeStreamsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeStreamsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeStreamsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DescribeWorkGroupsRequest(TeaModel):
    def __init__(
        self,
        page_number: int = None,
        page_size: int = None,
        instance_id: str = None,
        work_group_id: str = None,
        region_id: str = None,
    ):
        self.page_number = page_number
        self.page_size = page_size
        self.instance_id = instance_id
        self.work_group_id = work_group_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class DescribeWorkGroupsResponseBodyWorkGroupsWorkGroup(TeaModel):
    def __init__(
        self,
        update_time: str = None,
        description: str = None,
        protocol: str = None,
        create_time: str = None,
        instance_id: str = None,
        theory_cut_status: str = None,
        work_group_id: str = None,
        work_group_name: str = None,
    ):
        self.update_time = update_time
        self.description = description
        self.protocol = protocol
        self.create_time = create_time
        self.instance_id = instance_id
        self.theory_cut_status = theory_cut_status
        self.work_group_id = work_group_id
        self.work_group_name = work_group_name

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        if self.description is not None:
            result['Description'] = self.description
        if self.protocol is not None:
            result['Protocol'] = self.protocol
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.theory_cut_status is not None:
            result['TheoryCutStatus'] = self.theory_cut_status
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.work_group_name is not None:
            result['WorkGroupName'] = self.work_group_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Protocol') is not None:
            self.protocol = m.get('Protocol')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('TheoryCutStatus') is not None:
            self.theory_cut_status = m.get('TheoryCutStatus')
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('WorkGroupName') is not None:
            self.work_group_name = m.get('WorkGroupName')
        return self


class DescribeWorkGroupsResponseBodyWorkGroups(TeaModel):
    def __init__(
        self,
        work_group: List[DescribeWorkGroupsResponseBodyWorkGroupsWorkGroup] = None,
    ):
        self.work_group = work_group

    def validate(self):
        if self.work_group:
            for k in self.work_group:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['WorkGroup'] = []
        if self.work_group is not None:
            for k in self.work_group:
                result['WorkGroup'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.work_group = []
        if m.get('WorkGroup') is not None:
            for k in m.get('WorkGroup'):
                temp_model = DescribeWorkGroupsResponseBodyWorkGroupsWorkGroup()
                self.work_group.append(temp_model.from_map(k))
        return self


class DescribeWorkGroupsResponseBody(TeaModel):
    def __init__(
        self,
        work_groups: DescribeWorkGroupsResponseBodyWorkGroups = None,
        total_count: int = None,
        request_id: str = None,
        page_size: int = None,
        page_number: int = None,
    ):
        self.work_groups = work_groups
        self.total_count = total_count
        self.request_id = request_id
        self.page_size = page_size
        self.page_number = page_number

    def validate(self):
        if self.work_groups:
            self.work_groups.validate()

    def to_map(self):
        result = dict()
        if self.work_groups is not None:
            result['WorkGroups'] = self.work_groups.to_map()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('WorkGroups') is not None:
            temp_model = DescribeWorkGroupsResponseBodyWorkGroups()
            self.work_groups = temp_model.from_map(m['WorkGroups'])
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        return self


class DescribeWorkGroupsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DescribeWorkGroupsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DescribeWorkGroupsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DetachStreamRequestStreams(TeaModel):
    def __init__(
        self,
        stream_name: str = None,
    ):
        self.stream_name = stream_name

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.stream_name is not None:
            result['StreamName'] = self.stream_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StreamName') is not None:
            self.stream_name = m.get('StreamName')
        return self


class DetachStreamRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        region_id: str = None,
        streams: List[DetachStreamRequestStreams] = None,
    ):
        self.job_group_id = job_group_id
        self.region_id = region_id
        self.streams = streams

    def validate(self):
        if self.streams:
            for k in self.streams:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        result['Streams'] = []
        if self.streams is not None:
            for k in self.streams:
                result['Streams'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        self.streams = []
        if m.get('Streams') is not None:
            for k in m.get('Streams'):
                temp_model = DetachStreamRequestStreams()
                self.streams.append(temp_model.from_map(k))
        return self


class DetachStreamResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DetachStreamResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: DetachStreamResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = DetachStreamResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetCameraConfForCameraRequest(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.camera_id = camera_id
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class GetCameraConfForCameraResponseBodyCameraConf(TeaModel):
    def __init__(
        self,
        context: str = None,
        camera_id: str = None,
        camera_name: str = None,
        id: str = None,
    ):
        self.context = context
        self.camera_id = camera_id
        self.camera_name = camera_name
        self.id = id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.context is not None:
            result['Context'] = self.context
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.camera_name is not None:
            result['CameraName'] = self.camera_name
        if self.id is not None:
            result['Id'] = self.id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Context') is not None:
            self.context = m.get('Context')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('CameraName') is not None:
            self.camera_name = m.get('CameraName')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        return self


class GetCameraConfForCameraResponseBody(TeaModel):
    def __init__(
        self,
        camera_conf: GetCameraConfForCameraResponseBodyCameraConf = None,
        request_id: str = None,
    ):
        self.camera_conf = camera_conf
        self.request_id = request_id

    def validate(self):
        if self.camera_conf:
            self.camera_conf.validate()

    def to_map(self):
        result = dict()
        if self.camera_conf is not None:
            result['CameraConf'] = self.camera_conf.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraConf') is not None:
            temp_model = GetCameraConfForCameraResponseBodyCameraConf()
            self.camera_conf = temp_model.from_map(m['CameraConf'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetCameraConfForCameraResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: GetCameraConfForCameraResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = GetCameraConfForCameraResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetComputeJobLogRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        job_id: str = None,
        job_log_name: str = None,
        size: int = None,
        region_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.job_id = job_id
        self.job_log_name = job_log_name
        self.size = size
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.job_id is not None:
            result['JobId'] = self.job_id
        if self.job_log_name is not None:
            result['JobLogName'] = self.job_log_name
        if self.size is not None:
            result['Size'] = self.size
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('JobId') is not None:
            self.job_id = m.get('JobId')
        if m.get('JobLogName') is not None:
            self.job_log_name = m.get('JobLogName')
        if m.get('Size') is not None:
            self.size = m.get('Size')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class GetComputeJobLogResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        job_log: str = None,
    ):
        self.request_id = request_id
        self.job_log = job_log

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.job_log is not None:
            result['JobLog'] = self.job_log
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('JobLog') is not None:
            self.job_log = m.get('JobLog')
        return self


class GetComputeJobLogResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: GetComputeJobLogResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = GetComputeJobLogResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetPlayUrlForCameraRequest(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.camera_id = camera_id
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class GetPlayUrlForCameraResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        play_url: str = None,
    ):
        self.request_id = request_id
        self.play_url = play_url

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.play_url is not None:
            result['PlayUrl'] = self.play_url
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PlayUrl') is not None:
            self.play_url = m.get('PlayUrl')
        return self


class GetPlayUrlForCameraResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: GetPlayUrlForCameraResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = GetPlayUrlForCameraResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListComputeJobLogsRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        compute_job_id: str = None,
        region_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.compute_job_id = compute_job_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.compute_job_id is not None:
            result['ComputeJobId'] = self.compute_job_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('ComputeJobId') is not None:
            self.compute_job_id = m.get('ComputeJobId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class ListComputeJobLogsResponseBodyJobLogs(TeaModel):
    def __init__(
        self,
        job_log: List[str] = None,
    ):
        self.job_log = job_log

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_log is not None:
            result['JobLog'] = self.job_log
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobLog') is not None:
            self.job_log = m.get('JobLog')
        return self


class ListComputeJobLogsResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        job_logs: ListComputeJobLogsResponseBodyJobLogs = None,
    ):
        self.request_id = request_id
        self.job_logs = job_logs

    def validate(self):
        if self.job_logs:
            self.job_logs.validate()

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.job_logs is not None:
            result['JobLogs'] = self.job_logs.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('JobLogs') is not None:
            temp_model = ListComputeJobLogsResponseBodyJobLogs()
            self.job_logs = temp_model.from_map(m['JobLogs'])
        return self


class ListComputeJobLogsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ListComputeJobLogsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ListComputeJobLogsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListParkingResultsRequest(TeaModel):
    def __init__(
        self,
        start_time: str = None,
        end_time: str = None,
        camera_ids: str = None,
        instance_id: str = None,
        region_id: str = None,
        vehicle_plate: str = None,
    ):
        self.start_time = start_time
        self.end_time = end_time
        self.camera_ids = camera_ids
        self.instance_id = instance_id
        self.region_id = region_id
        self.vehicle_plate = vehicle_plate

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.camera_ids is not None:
            result['CameraIds'] = self.camera_ids
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.vehicle_plate is not None:
            result['VehiclePlate'] = self.vehicle_plate
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('CameraIds') is not None:
            self.camera_ids = m.get('CameraIds')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('VehiclePlate') is not None:
            self.vehicle_plate = m.get('VehiclePlate')
        return self


class ListParkingResultsResponseBodyResults(TeaModel):
    def __init__(
        self,
        vehicle_type: str = None,
        camera_id: str = None,
        obj_right: int = None,
        obj_type: str = None,
        feature: str = None,
        obj_left: int = None,
        crop_image: str = None,
        obj_top: int = None,
        label: str = None,
        leave_time: str = None,
        obj_bottom: int = None,
        function_type: str = None,
        orig_image: str = None,
        time_stamp: str = None,
        vehicle_plate: str = None,
        entry_time: str = None,
        image_id: str = None,
    ):
        self.vehicle_type = vehicle_type
        self.camera_id = camera_id
        self.obj_right = obj_right
        self.obj_type = obj_type
        self.feature = feature
        self.obj_left = obj_left
        self.crop_image = crop_image
        self.obj_top = obj_top
        self.label = label
        self.leave_time = leave_time
        self.obj_bottom = obj_bottom
        self.function_type = function_type
        self.orig_image = orig_image
        self.time_stamp = time_stamp
        self.vehicle_plate = vehicle_plate
        self.entry_time = entry_time
        self.image_id = image_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.vehicle_type is not None:
            result['VehicleType'] = self.vehicle_type
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.obj_right is not None:
            result['ObjRight'] = self.obj_right
        if self.obj_type is not None:
            result['ObjType'] = self.obj_type
        if self.feature is not None:
            result['Feature'] = self.feature
        if self.obj_left is not None:
            result['ObjLeft'] = self.obj_left
        if self.crop_image is not None:
            result['CropImage'] = self.crop_image
        if self.obj_top is not None:
            result['ObjTop'] = self.obj_top
        if self.label is not None:
            result['Label'] = self.label
        if self.leave_time is not None:
            result['LeaveTime'] = self.leave_time
        if self.obj_bottom is not None:
            result['ObjBottom'] = self.obj_bottom
        if self.function_type is not None:
            result['FunctionType'] = self.function_type
        if self.orig_image is not None:
            result['OrigImage'] = self.orig_image
        if self.time_stamp is not None:
            result['TimeStamp'] = self.time_stamp
        if self.vehicle_plate is not None:
            result['VehiclePlate'] = self.vehicle_plate
        if self.entry_time is not None:
            result['EntryTime'] = self.entry_time
        if self.image_id is not None:
            result['ImageId'] = self.image_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('VehicleType') is not None:
            self.vehicle_type = m.get('VehicleType')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('ObjRight') is not None:
            self.obj_right = m.get('ObjRight')
        if m.get('ObjType') is not None:
            self.obj_type = m.get('ObjType')
        if m.get('Feature') is not None:
            self.feature = m.get('Feature')
        if m.get('ObjLeft') is not None:
            self.obj_left = m.get('ObjLeft')
        if m.get('CropImage') is not None:
            self.crop_image = m.get('CropImage')
        if m.get('ObjTop') is not None:
            self.obj_top = m.get('ObjTop')
        if m.get('Label') is not None:
            self.label = m.get('Label')
        if m.get('LeaveTime') is not None:
            self.leave_time = m.get('LeaveTime')
        if m.get('ObjBottom') is not None:
            self.obj_bottom = m.get('ObjBottom')
        if m.get('FunctionType') is not None:
            self.function_type = m.get('FunctionType')
        if m.get('OrigImage') is not None:
            self.orig_image = m.get('OrigImage')
        if m.get('TimeStamp') is not None:
            self.time_stamp = m.get('TimeStamp')
        if m.get('VehiclePlate') is not None:
            self.vehicle_plate = m.get('VehiclePlate')
        if m.get('EntryTime') is not None:
            self.entry_time = m.get('EntryTime')
        if m.get('ImageId') is not None:
            self.image_id = m.get('ImageId')
        return self


class ListParkingResultsResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        total_page: int = None,
        page_size: int = None,
        request_id: str = None,
        page_number: int = None,
        results: List[ListParkingResultsResponseBodyResults] = None,
    ):
        self.total_count = total_count
        self.total_page = total_page
        self.page_size = page_size
        self.request_id = request_id
        self.page_number = page_number
        self.results = results

    def validate(self):
        if self.results:
            for k in self.results:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.total_page is not None:
            result['TotalPage'] = self.total_page
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        result['Results'] = []
        if self.results is not None:
            for k in self.results:
                result['Results'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('TotalPage') is not None:
            self.total_page = m.get('TotalPage')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        self.results = []
        if m.get('Results') is not None:
            for k in m.get('Results'):
                temp_model = ListParkingResultsResponseBodyResults()
                self.results.append(temp_model.from_map(k))
        return self


class ListParkingResultsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ListParkingResultsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ListParkingResultsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListSafetyHelmetResultsRequest(TeaModel):
    def __init__(
        self,
        start_time: str = None,
        end_time: str = None,
        camera_ids: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.start_time = start_time
        self.end_time = end_time
        self.camera_ids = camera_ids
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.camera_ids is not None:
            result['CameraIds'] = self.camera_ids
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('CameraIds') is not None:
            self.camera_ids = m.get('CameraIds')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class ListSafetyHelmetResultsResponseBodyResults(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        obj_type: str = None,
        obj_right: int = None,
        feature: str = None,
        obj_left: int = None,
        crop_image: str = None,
        obj_top: int = None,
        label: str = None,
        leave_time: str = None,
        obj_bottom: int = None,
        time_stamp: str = None,
        orig_image: str = None,
        image_id: str = None,
        entry_time: str = None,
    ):
        self.camera_id = camera_id
        self.obj_type = obj_type
        self.obj_right = obj_right
        self.feature = feature
        self.obj_left = obj_left
        self.crop_image = crop_image
        self.obj_top = obj_top
        self.label = label
        self.leave_time = leave_time
        self.obj_bottom = obj_bottom
        self.time_stamp = time_stamp
        self.orig_image = orig_image
        self.image_id = image_id
        self.entry_time = entry_time

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.obj_type is not None:
            result['ObjType'] = self.obj_type
        if self.obj_right is not None:
            result['ObjRight'] = self.obj_right
        if self.feature is not None:
            result['Feature'] = self.feature
        if self.obj_left is not None:
            result['ObjLeft'] = self.obj_left
        if self.crop_image is not None:
            result['CropImage'] = self.crop_image
        if self.obj_top is not None:
            result['ObjTop'] = self.obj_top
        if self.label is not None:
            result['Label'] = self.label
        if self.leave_time is not None:
            result['LeaveTime'] = self.leave_time
        if self.obj_bottom is not None:
            result['ObjBottom'] = self.obj_bottom
        if self.time_stamp is not None:
            result['TimeStamp'] = self.time_stamp
        if self.orig_image is not None:
            result['OrigImage'] = self.orig_image
        if self.image_id is not None:
            result['ImageId'] = self.image_id
        if self.entry_time is not None:
            result['EntryTime'] = self.entry_time
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('ObjType') is not None:
            self.obj_type = m.get('ObjType')
        if m.get('ObjRight') is not None:
            self.obj_right = m.get('ObjRight')
        if m.get('Feature') is not None:
            self.feature = m.get('Feature')
        if m.get('ObjLeft') is not None:
            self.obj_left = m.get('ObjLeft')
        if m.get('CropImage') is not None:
            self.crop_image = m.get('CropImage')
        if m.get('ObjTop') is not None:
            self.obj_top = m.get('ObjTop')
        if m.get('Label') is not None:
            self.label = m.get('Label')
        if m.get('LeaveTime') is not None:
            self.leave_time = m.get('LeaveTime')
        if m.get('ObjBottom') is not None:
            self.obj_bottom = m.get('ObjBottom')
        if m.get('TimeStamp') is not None:
            self.time_stamp = m.get('TimeStamp')
        if m.get('OrigImage') is not None:
            self.orig_image = m.get('OrigImage')
        if m.get('ImageId') is not None:
            self.image_id = m.get('ImageId')
        if m.get('EntryTime') is not None:
            self.entry_time = m.get('EntryTime')
        return self


class ListSafetyHelmetResultsResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        total_page: int = None,
        request_id: str = None,
        page_number: int = None,
        results: List[ListSafetyHelmetResultsResponseBodyResults] = None,
        page_index: int = None,
    ):
        self.total_count = total_count
        self.total_page = total_page
        self.request_id = request_id
        self.page_number = page_number
        self.results = results
        self.page_index = page_index

    def validate(self):
        if self.results:
            for k in self.results:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.total_page is not None:
            result['TotalPage'] = self.total_page
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        result['Results'] = []
        if self.results is not None:
            for k in self.results:
                result['Results'].append(k.to_map() if k else None)
        if self.page_index is not None:
            result['PageIndex'] = self.page_index
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('TotalPage') is not None:
            self.total_page = m.get('TotalPage')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        self.results = []
        if m.get('Results') is not None:
            for k in m.get('Results'):
                temp_model = ListSafetyHelmetResultsResponseBodyResults()
                self.results.append(temp_model.from_map(k))
        if m.get('PageIndex') is not None:
            self.page_index = m.get('PageIndex')
        return self


class ListSafetyHelmetResultsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ListSafetyHelmetResultsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ListSafetyHelmetResultsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListStreamsForCamerasRequest(TeaModel):
    def __init__(
        self,
        camera_ids: str = None,
        region_id: str = None,
        instance_id: str = None,
    ):
        self.camera_ids = camera_ids
        self.region_id = region_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_ids is not None:
            result['CameraIds'] = self.camera_ids
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraIds') is not None:
            self.camera_ids = m.get('CameraIds')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class ListStreamsForCamerasResponseBodyStreams(TeaModel):
    def __init__(
        self,
        stream: List[str] = None,
    ):
        self.stream = stream

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.stream is not None:
            result['Stream'] = self.stream
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Stream') is not None:
            self.stream = m.get('Stream')
        return self


class ListStreamsForCamerasResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        streams: ListStreamsForCamerasResponseBodyStreams = None,
    ):
        self.request_id = request_id
        self.streams = streams

    def validate(self):
        if self.streams:
            self.streams.validate()

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.streams is not None:
            result['Streams'] = self.streams.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Streams') is not None:
            temp_model = ListStreamsForCamerasResponseBodyStreams()
            self.streams = temp_model.from_map(m['Streams'])
        return self


class ListStreamsForCamerasResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ListStreamsForCamerasResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ListStreamsForCamerasResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListVehicleEntryResultsRequest(TeaModel):
    def __init__(
        self,
        start_time: str = None,
        end_time: str = None,
        camera_ids: str = None,
        instance_id: str = None,
        region_id: str = None,
        vehicle_plate: str = None,
    ):
        self.start_time = start_time
        self.end_time = end_time
        self.camera_ids = camera_ids
        self.instance_id = instance_id
        self.region_id = region_id
        self.vehicle_plate = vehicle_plate

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.camera_ids is not None:
            result['CameraIds'] = self.camera_ids
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.vehicle_plate is not None:
            result['VehiclePlate'] = self.vehicle_plate
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('CameraIds') is not None:
            self.camera_ids = m.get('CameraIds')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('VehiclePlate') is not None:
            self.vehicle_plate = m.get('VehiclePlate')
        return self


class ListVehicleEntryResultsResponseBodyResults(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        obj_right: int = None,
        obj_type: str = None,
        feature: str = None,
        plate_left: int = None,
        obj_left: int = None,
        score: float = None,
        crop_image: str = None,
        obj_top: int = None,
        label: str = None,
        plate_bottom: int = None,
        leave_time: str = None,
        plate_top: int = None,
        obj_bottom: int = None,
        plate_right: int = None,
        orig_image: str = None,
        time_stamp: str = None,
        vehicle_plate: str = None,
        entry_time: str = None,
        image_id: str = None,
    ):
        self.camera_id = camera_id
        self.obj_right = obj_right
        self.obj_type = obj_type
        self.feature = feature
        self.plate_left = plate_left
        self.obj_left = obj_left
        self.score = score
        self.crop_image = crop_image
        self.obj_top = obj_top
        self.label = label
        self.plate_bottom = plate_bottom
        self.leave_time = leave_time
        self.plate_top = plate_top
        self.obj_bottom = obj_bottom
        self.plate_right = plate_right
        self.orig_image = orig_image
        self.time_stamp = time_stamp
        self.vehicle_plate = vehicle_plate
        self.entry_time = entry_time
        self.image_id = image_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.obj_right is not None:
            result['ObjRight'] = self.obj_right
        if self.obj_type is not None:
            result['ObjType'] = self.obj_type
        if self.feature is not None:
            result['Feature'] = self.feature
        if self.plate_left is not None:
            result['PlateLeft'] = self.plate_left
        if self.obj_left is not None:
            result['ObjLeft'] = self.obj_left
        if self.score is not None:
            result['Score'] = self.score
        if self.crop_image is not None:
            result['CropImage'] = self.crop_image
        if self.obj_top is not None:
            result['ObjTop'] = self.obj_top
        if self.label is not None:
            result['Label'] = self.label
        if self.plate_bottom is not None:
            result['PlateBottom'] = self.plate_bottom
        if self.leave_time is not None:
            result['LeaveTime'] = self.leave_time
        if self.plate_top is not None:
            result['PlateTop'] = self.plate_top
        if self.obj_bottom is not None:
            result['ObjBottom'] = self.obj_bottom
        if self.plate_right is not None:
            result['PlateRight'] = self.plate_right
        if self.orig_image is not None:
            result['OrigImage'] = self.orig_image
        if self.time_stamp is not None:
            result['TimeStamp'] = self.time_stamp
        if self.vehicle_plate is not None:
            result['VehiclePlate'] = self.vehicle_plate
        if self.entry_time is not None:
            result['EntryTime'] = self.entry_time
        if self.image_id is not None:
            result['ImageId'] = self.image_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('ObjRight') is not None:
            self.obj_right = m.get('ObjRight')
        if m.get('ObjType') is not None:
            self.obj_type = m.get('ObjType')
        if m.get('Feature') is not None:
            self.feature = m.get('Feature')
        if m.get('PlateLeft') is not None:
            self.plate_left = m.get('PlateLeft')
        if m.get('ObjLeft') is not None:
            self.obj_left = m.get('ObjLeft')
        if m.get('Score') is not None:
            self.score = m.get('Score')
        if m.get('CropImage') is not None:
            self.crop_image = m.get('CropImage')
        if m.get('ObjTop') is not None:
            self.obj_top = m.get('ObjTop')
        if m.get('Label') is not None:
            self.label = m.get('Label')
        if m.get('PlateBottom') is not None:
            self.plate_bottom = m.get('PlateBottom')
        if m.get('LeaveTime') is not None:
            self.leave_time = m.get('LeaveTime')
        if m.get('PlateTop') is not None:
            self.plate_top = m.get('PlateTop')
        if m.get('ObjBottom') is not None:
            self.obj_bottom = m.get('ObjBottom')
        if m.get('PlateRight') is not None:
            self.plate_right = m.get('PlateRight')
        if m.get('OrigImage') is not None:
            self.orig_image = m.get('OrigImage')
        if m.get('TimeStamp') is not None:
            self.time_stamp = m.get('TimeStamp')
        if m.get('VehiclePlate') is not None:
            self.vehicle_plate = m.get('VehiclePlate')
        if m.get('EntryTime') is not None:
            self.entry_time = m.get('EntryTime')
        if m.get('ImageId') is not None:
            self.image_id = m.get('ImageId')
        return self


class ListVehicleEntryResultsResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        total_page: int = None,
        page_size: int = None,
        request_id: str = None,
        page_number: int = None,
        results: List[ListVehicleEntryResultsResponseBodyResults] = None,
    ):
        self.total_count = total_count
        self.total_page = total_page
        self.page_size = page_size
        self.request_id = request_id
        self.page_number = page_number
        self.results = results

    def validate(self):
        if self.results:
            for k in self.results:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.total_page is not None:
            result['TotalPage'] = self.total_page
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        result['Results'] = []
        if self.results is not None:
            for k in self.results:
                result['Results'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('TotalPage') is not None:
            self.total_page = m.get('TotalPage')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        self.results = []
        if m.get('Results') is not None:
            for k in m.get('Results'):
                temp_model = ListVehicleEntryResultsResponseBodyResults()
                self.results.append(temp_model.from_map(k))
        return self


class ListVehicleEntryResultsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ListVehicleEntryResultsResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ListVehicleEntryResultsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyAlgoLibRequest(TeaModel):
    def __init__(
        self,
        algo_lib_name: str = None,
        algo_lib_version: str = None,
        capacity: int = None,
        oss_endpoint: str = None,
        oss_access_key_id: str = None,
        oss_bucket: str = None,
        oss_path: str = None,
        json_text: str = None,
        capability_names: str = None,
        algo_lib_id: str = None,
        oss_access_key_secret: str = None,
        text: str = None,
        region_id: str = None,
        instance_id: str = None,
    ):
        self.algo_lib_name = algo_lib_name
        self.algo_lib_version = algo_lib_version
        self.capacity = capacity
        self.oss_endpoint = oss_endpoint
        self.oss_access_key_id = oss_access_key_id
        self.oss_bucket = oss_bucket
        self.oss_path = oss_path
        self.json_text = json_text
        self.capability_names = capability_names
        self.algo_lib_id = algo_lib_id
        self.oss_access_key_secret = oss_access_key_secret
        self.text = text
        self.region_id = region_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.algo_lib_name is not None:
            result['AlgoLibName'] = self.algo_lib_name
        if self.algo_lib_version is not None:
            result['AlgoLibVersion'] = self.algo_lib_version
        if self.capacity is not None:
            result['Capacity'] = self.capacity
        if self.oss_endpoint is not None:
            result['OssEndpoint'] = self.oss_endpoint
        if self.oss_access_key_id is not None:
            result['OssAccessKeyId'] = self.oss_access_key_id
        if self.oss_bucket is not None:
            result['OssBucket'] = self.oss_bucket
        if self.oss_path is not None:
            result['OssPath'] = self.oss_path
        if self.json_text is not None:
            result['JsonText'] = self.json_text
        if self.capability_names is not None:
            result['CapabilityNames'] = self.capability_names
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.oss_access_key_secret is not None:
            result['OssAccessKeySecret'] = self.oss_access_key_secret
        if self.text is not None:
            result['Text'] = self.text
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('AlgoLibName') is not None:
            self.algo_lib_name = m.get('AlgoLibName')
        if m.get('AlgoLibVersion') is not None:
            self.algo_lib_version = m.get('AlgoLibVersion')
        if m.get('Capacity') is not None:
            self.capacity = m.get('Capacity')
        if m.get('OssEndpoint') is not None:
            self.oss_endpoint = m.get('OssEndpoint')
        if m.get('OssAccessKeyId') is not None:
            self.oss_access_key_id = m.get('OssAccessKeyId')
        if m.get('OssBucket') is not None:
            self.oss_bucket = m.get('OssBucket')
        if m.get('OssPath') is not None:
            self.oss_path = m.get('OssPath')
        if m.get('JsonText') is not None:
            self.json_text = m.get('JsonText')
        if m.get('CapabilityNames') is not None:
            self.capability_names = m.get('CapabilityNames')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('OssAccessKeySecret') is not None:
            self.oss_access_key_secret = m.get('OssAccessKeySecret')
        if m.get('Text') is not None:
            self.text = m.get('Text')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class ModifyAlgoLibResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyAlgoLibResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyAlgoLibResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyAlgoLibResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyCameraRequest(TeaModel):
    def __init__(
        self,
        camera_name: str = None,
        camera_id: str = None,
        location_info: str = None,
        invite_uri: str = None,
        region_id: str = None,
        stream_status: str = None,
    ):
        self.camera_name = camera_name
        self.camera_id = camera_id
        self.location_info = location_info
        self.invite_uri = invite_uri
        self.region_id = region_id
        self.stream_status = stream_status

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_name is not None:
            result['CameraName'] = self.camera_name
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.location_info is not None:
            result['LocationInfo'] = self.location_info
        if self.invite_uri is not None:
            result['InviteUri'] = self.invite_uri
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.stream_status is not None:
            result['StreamStatus'] = self.stream_status
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraName') is not None:
            self.camera_name = m.get('CameraName')
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('LocationInfo') is not None:
            self.location_info = m.get('LocationInfo')
        if m.get('InviteUri') is not None:
            self.invite_uri = m.get('InviteUri')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('StreamStatus') is not None:
            self.stream_status = m.get('StreamStatus')
        return self


class ModifyCameraResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyCameraResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyCameraResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyCameraResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyCapabilityRequest(TeaModel):
    def __init__(
        self,
        capability_name: str = None,
        capability_id: str = None,
        region_id: str = None,
        instance_id: str = None,
    ):
        self.capability_name = capability_name
        self.capability_id = capability_id
        self.region_id = region_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.capability_name is not None:
            result['CapabilityName'] = self.capability_name
        if self.capability_id is not None:
            result['CapabilityId'] = self.capability_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CapabilityName') is not None:
            self.capability_name = m.get('CapabilityName')
        if m.get('CapabilityId') is not None:
            self.capability_id = m.get('CapabilityId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class ModifyCapabilityResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyCapabilityResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyCapabilityResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyCapabilityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyInstanceRequest(TeaModel):
    def __init__(
        self,
        instance_name: str = None,
        description: str = None,
        status: str = None,
        instance_id: str = None,
        region_id: str = None,
    ):
        self.instance_name = instance_name
        self.description = description
        self.status = status
        self.instance_id = instance_id
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.instance_name is not None:
            result['InstanceName'] = self.instance_name
        if self.description is not None:
            result['Description'] = self.description
        if self.status is not None:
            result['Status'] = self.status
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('InstanceName') is not None:
            self.instance_name = m.get('InstanceName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class ModifyInstanceResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyInstanceResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyInstanceResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyJobGroupRequestJobGroupParams(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ModifyJobGroupRequest(TeaModel):
    def __init__(
        self,
        job_group_name: str = None,
        resource_profile_id: str = None,
        algo_lib_id: str = None,
        planed_job_count: int = None,
        stream_per_job: int = None,
        job_count: int = None,
        job_group_id: str = None,
        status: str = None,
        region_id: str = None,
        instance_id: str = None,
        job_group_params: List[ModifyJobGroupRequestJobGroupParams] = None,
    ):
        self.job_group_name = job_group_name
        self.resource_profile_id = resource_profile_id
        self.algo_lib_id = algo_lib_id
        self.planed_job_count = planed_job_count
        self.stream_per_job = stream_per_job
        self.job_count = job_count
        self.job_group_id = job_group_id
        self.status = status
        self.region_id = region_id
        self.instance_id = instance_id
        self.job_group_params = job_group_params

    def validate(self):
        if self.job_group_params:
            for k in self.job_group_params:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.job_group_name is not None:
            result['JobGroupName'] = self.job_group_name
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.algo_lib_id is not None:
            result['AlgoLibId'] = self.algo_lib_id
        if self.planed_job_count is not None:
            result['PlanedJobCount'] = self.planed_job_count
        if self.stream_per_job is not None:
            result['StreamPerJob'] = self.stream_per_job
        if self.job_count is not None:
            result['JobCount'] = self.job_count
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.status is not None:
            result['Status'] = self.status
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        result['JobGroupParams'] = []
        if self.job_group_params is not None:
            for k in self.job_group_params:
                result['JobGroupParams'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupName') is not None:
            self.job_group_name = m.get('JobGroupName')
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('AlgoLibId') is not None:
            self.algo_lib_id = m.get('AlgoLibId')
        if m.get('PlanedJobCount') is not None:
            self.planed_job_count = m.get('PlanedJobCount')
        if m.get('StreamPerJob') is not None:
            self.stream_per_job = m.get('StreamPerJob')
        if m.get('JobCount') is not None:
            self.job_count = m.get('JobCount')
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        self.job_group_params = []
        if m.get('JobGroupParams') is not None:
            for k in m.get('JobGroupParams'):
                temp_model = ModifyJobGroupRequestJobGroupParams()
                self.job_group_params.append(temp_model.from_map(k))
        return self


class ModifyJobGroupResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyJobGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyJobGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyJobGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyResourceProfileRequestResourceProfileParams(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ModifyResourceProfileRequest(TeaModel):
    def __init__(
        self,
        resource_profile_name: str = None,
        resource_profile_id: str = None,
        region_id: str = None,
        instance_id: str = None,
        resource_profile_params: List[ModifyResourceProfileRequestResourceProfileParams] = None,
    ):
        self.resource_profile_name = resource_profile_name
        self.resource_profile_id = resource_profile_id
        self.region_id = region_id
        self.instance_id = instance_id
        self.resource_profile_params = resource_profile_params

    def validate(self):
        if self.resource_profile_params:
            for k in self.resource_profile_params:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.resource_profile_name is not None:
            result['ResourceProfileName'] = self.resource_profile_name
        if self.resource_profile_id is not None:
            result['ResourceProfileId'] = self.resource_profile_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        result['ResourceProfileParams'] = []
        if self.resource_profile_params is not None:
            for k in self.resource_profile_params:
                result['ResourceProfileParams'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('ResourceProfileName') is not None:
            self.resource_profile_name = m.get('ResourceProfileName')
        if m.get('ResourceProfileId') is not None:
            self.resource_profile_id = m.get('ResourceProfileId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        self.resource_profile_params = []
        if m.get('ResourceProfileParams') is not None:
            for k in m.get('ResourceProfileParams'):
                temp_model = ModifyResourceProfileRequestResourceProfileParams()
                self.resource_profile_params.append(temp_model.from_map(k))
        return self


class ModifyResourceProfileResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyResourceProfileResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyResourceProfileResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyResourceProfileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ModifyWorkGroupRequest(TeaModel):
    def __init__(
        self,
        work_group_id: str = None,
        description: str = None,
        region_id: str = None,
    ):
        self.work_group_id = work_group_id
        self.description = description
        self.region_id = region_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.work_group_id is not None:
            result['WorkGroupId'] = self.work_group_id
        if self.description is not None:
            result['Description'] = self.description
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('WorkGroupId') is not None:
            self.work_group_id = m.get('WorkGroupId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        return self


class ModifyWorkGroupResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ModifyWorkGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: ModifyWorkGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = ModifyWorkGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class PutCameraConfForCameraRequest(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        instance_id: str = None,
        region_id: str = None,
        camera_name: str = None,
        context: str = None,
    ):
        self.camera_id = camera_id
        self.instance_id = instance_id
        self.region_id = region_id
        self.camera_name = camera_name
        self.context = context

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.camera_name is not None:
            result['CameraName'] = self.camera_name
        if self.context is not None:
            result['Context'] = self.context
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('CameraName') is not None:
            self.camera_name = m.get('CameraName')
        if m.get('Context') is not None:
            self.context = m.get('Context')
        return self


class PutCameraConfForCameraResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class PutCameraConfForCameraResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: PutCameraConfForCameraResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = PutCameraConfForCameraResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SearchImagesRequestAttribute(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class SearchImagesRequest(TeaModel):
    def __init__(
        self,
        from_: int = None,
        size: int = None,
        type: str = None,
        contents: str = None,
        start_time: str = None,
        end_time: str = None,
        image_ids: str = None,
        camera_ids: str = None,
        instance_id: str = None,
        no_feature: str = None,
        region_id: str = None,
        attribute: List[SearchImagesRequestAttribute] = None,
    ):
        self.from_ = from_
        self.size = size
        self.type = type
        self.contents = contents
        self.start_time = start_time
        self.end_time = end_time
        self.image_ids = image_ids
        self.camera_ids = camera_ids
        self.instance_id = instance_id
        self.no_feature = no_feature
        self.region_id = region_id
        self.attribute = attribute

    def validate(self):
        if self.attribute:
            for k in self.attribute:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        if self.from_ is not None:
            result['From'] = self.from_
        if self.size is not None:
            result['Size'] = self.size
        if self.type is not None:
            result['Type'] = self.type
        if self.contents is not None:
            result['Contents'] = self.contents
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.image_ids is not None:
            result['ImageIds'] = self.image_ids
        if self.camera_ids is not None:
            result['CameraIds'] = self.camera_ids
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.no_feature is not None:
            result['NoFeature'] = self.no_feature
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        result['Attribute'] = []
        if self.attribute is not None:
            for k in self.attribute:
                result['Attribute'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('From') is not None:
            self.from_ = m.get('From')
        if m.get('Size') is not None:
            self.size = m.get('Size')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('Contents') is not None:
            self.contents = m.get('Contents')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('ImageIds') is not None:
            self.image_ids = m.get('ImageIds')
        if m.get('CameraIds') is not None:
            self.camera_ids = m.get('CameraIds')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NoFeature') is not None:
            self.no_feature = m.get('NoFeature')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        self.attribute = []
        if m.get('Attribute') is not None:
            for k in m.get('Attribute'):
                temp_model = SearchImagesRequestAttribute()
                self.attribute.append(temp_model.from_map(k))
        return self


class SearchImagesResponseBodyImagesImage(TeaModel):
    def __init__(
        self,
        camera_id: str = None,
        trouser_type_score: float = None,
        obj_type: str = None,
        trouser_color: str = None,
        cloth_type_score: float = None,
        brand: str = None,
        pose_type: str = None,
        vehicle_color: str = None,
        obj_left: int = None,
        score: float = None,
        head_wear_score: float = None,
        age_type_score: float = None,
        sex_type_score: float = None,
        non_vehicle_type: str = None,
        obj_bottom: int = None,
        plate_number: str = None,
        cloth_type: str = None,
        time_stamp: str = None,
        orig_image: str = None,
        vehicle_type_score: float = None,
        trouser_color_score: float = None,
        image_id: str = None,
        vehicle_color_score: float = None,
        hair_type_score: float = None,
        hair_type: str = None,
        non_vehicle_type_score: float = None,
        head_wear: str = None,
        vehicle_type: str = None,
        sex_type: str = None,
        pose_type_score: float = None,
        obj_right: int = None,
        feature: str = None,
        cloth_color_score: float = None,
        crop_image: str = None,
        obj_top: int = None,
        brand_score: float = None,
        cloth_color: str = None,
        age_type: str = None,
        leave_time: str = None,
        trouser_type: str = None,
        entry_time: str = None,
    ):
        self.camera_id = camera_id
        self.trouser_type_score = trouser_type_score
        self.obj_type = obj_type
        self.trouser_color = trouser_color
        self.cloth_type_score = cloth_type_score
        self.brand = brand
        self.pose_type = pose_type
        self.vehicle_color = vehicle_color
        self.obj_left = obj_left
        self.score = score
        self.head_wear_score = head_wear_score
        self.age_type_score = age_type_score
        self.sex_type_score = sex_type_score
        self.non_vehicle_type = non_vehicle_type
        self.obj_bottom = obj_bottom
        self.plate_number = plate_number
        self.cloth_type = cloth_type
        self.time_stamp = time_stamp
        self.orig_image = orig_image
        self.vehicle_type_score = vehicle_type_score
        self.trouser_color_score = trouser_color_score
        self.image_id = image_id
        self.vehicle_color_score = vehicle_color_score
        self.hair_type_score = hair_type_score
        self.hair_type = hair_type
        self.non_vehicle_type_score = non_vehicle_type_score
        self.head_wear = head_wear
        self.vehicle_type = vehicle_type
        self.sex_type = sex_type
        self.pose_type_score = pose_type_score
        self.obj_right = obj_right
        self.feature = feature
        self.cloth_color_score = cloth_color_score
        self.crop_image = crop_image
        self.obj_top = obj_top
        self.brand_score = brand_score
        self.cloth_color = cloth_color
        self.age_type = age_type
        self.leave_time = leave_time
        self.trouser_type = trouser_type
        self.entry_time = entry_time

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.camera_id is not None:
            result['CameraId'] = self.camera_id
        if self.trouser_type_score is not None:
            result['TrouserTypeScore'] = self.trouser_type_score
        if self.obj_type is not None:
            result['ObjType'] = self.obj_type
        if self.trouser_color is not None:
            result['TrouserColor'] = self.trouser_color
        if self.cloth_type_score is not None:
            result['ClothTypeScore'] = self.cloth_type_score
        if self.brand is not None:
            result['Brand'] = self.brand
        if self.pose_type is not None:
            result['PoseType'] = self.pose_type
        if self.vehicle_color is not None:
            result['VehicleColor'] = self.vehicle_color
        if self.obj_left is not None:
            result['ObjLeft'] = self.obj_left
        if self.score is not None:
            result['Score'] = self.score
        if self.head_wear_score is not None:
            result['HeadWearScore'] = self.head_wear_score
        if self.age_type_score is not None:
            result['AgeTypeScore'] = self.age_type_score
        if self.sex_type_score is not None:
            result['SexTypeScore'] = self.sex_type_score
        if self.non_vehicle_type is not None:
            result['NonVehicleType'] = self.non_vehicle_type
        if self.obj_bottom is not None:
            result['ObjBottom'] = self.obj_bottom
        if self.plate_number is not None:
            result['PlateNumber'] = self.plate_number
        if self.cloth_type is not None:
            result['ClothType'] = self.cloth_type
        if self.time_stamp is not None:
            result['TimeStamp'] = self.time_stamp
        if self.orig_image is not None:
            result['OrigImage'] = self.orig_image
        if self.vehicle_type_score is not None:
            result['VehicleTypeScore'] = self.vehicle_type_score
        if self.trouser_color_score is not None:
            result['TrouserColorScore'] = self.trouser_color_score
        if self.image_id is not None:
            result['ImageId'] = self.image_id
        if self.vehicle_color_score is not None:
            result['VehicleColorScore'] = self.vehicle_color_score
        if self.hair_type_score is not None:
            result['HairTypeScore'] = self.hair_type_score
        if self.hair_type is not None:
            result['HairType'] = self.hair_type
        if self.non_vehicle_type_score is not None:
            result['NonVehicleTypeScore'] = self.non_vehicle_type_score
        if self.head_wear is not None:
            result['HeadWear'] = self.head_wear
        if self.vehicle_type is not None:
            result['VehicleType'] = self.vehicle_type
        if self.sex_type is not None:
            result['SexType'] = self.sex_type
        if self.pose_type_score is not None:
            result['PoseTypeScore'] = self.pose_type_score
        if self.obj_right is not None:
            result['ObjRight'] = self.obj_right
        if self.feature is not None:
            result['Feature'] = self.feature
        if self.cloth_color_score is not None:
            result['ClothColorScore'] = self.cloth_color_score
        if self.crop_image is not None:
            result['CropImage'] = self.crop_image
        if self.obj_top is not None:
            result['ObjTop'] = self.obj_top
        if self.brand_score is not None:
            result['BrandScore'] = self.brand_score
        if self.cloth_color is not None:
            result['ClothColor'] = self.cloth_color
        if self.age_type is not None:
            result['AgeType'] = self.age_type
        if self.leave_time is not None:
            result['LeaveTime'] = self.leave_time
        if self.trouser_type is not None:
            result['TrouserType'] = self.trouser_type
        if self.entry_time is not None:
            result['EntryTime'] = self.entry_time
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('CameraId') is not None:
            self.camera_id = m.get('CameraId')
        if m.get('TrouserTypeScore') is not None:
            self.trouser_type_score = m.get('TrouserTypeScore')
        if m.get('ObjType') is not None:
            self.obj_type = m.get('ObjType')
        if m.get('TrouserColor') is not None:
            self.trouser_color = m.get('TrouserColor')
        if m.get('ClothTypeScore') is not None:
            self.cloth_type_score = m.get('ClothTypeScore')
        if m.get('Brand') is not None:
            self.brand = m.get('Brand')
        if m.get('PoseType') is not None:
            self.pose_type = m.get('PoseType')
        if m.get('VehicleColor') is not None:
            self.vehicle_color = m.get('VehicleColor')
        if m.get('ObjLeft') is not None:
            self.obj_left = m.get('ObjLeft')
        if m.get('Score') is not None:
            self.score = m.get('Score')
        if m.get('HeadWearScore') is not None:
            self.head_wear_score = m.get('HeadWearScore')
        if m.get('AgeTypeScore') is not None:
            self.age_type_score = m.get('AgeTypeScore')
        if m.get('SexTypeScore') is not None:
            self.sex_type_score = m.get('SexTypeScore')
        if m.get('NonVehicleType') is not None:
            self.non_vehicle_type = m.get('NonVehicleType')
        if m.get('ObjBottom') is not None:
            self.obj_bottom = m.get('ObjBottom')
        if m.get('PlateNumber') is not None:
            self.plate_number = m.get('PlateNumber')
        if m.get('ClothType') is not None:
            self.cloth_type = m.get('ClothType')
        if m.get('TimeStamp') is not None:
            self.time_stamp = m.get('TimeStamp')
        if m.get('OrigImage') is not None:
            self.orig_image = m.get('OrigImage')
        if m.get('VehicleTypeScore') is not None:
            self.vehicle_type_score = m.get('VehicleTypeScore')
        if m.get('TrouserColorScore') is not None:
            self.trouser_color_score = m.get('TrouserColorScore')
        if m.get('ImageId') is not None:
            self.image_id = m.get('ImageId')
        if m.get('VehicleColorScore') is not None:
            self.vehicle_color_score = m.get('VehicleColorScore')
        if m.get('HairTypeScore') is not None:
            self.hair_type_score = m.get('HairTypeScore')
        if m.get('HairType') is not None:
            self.hair_type = m.get('HairType')
        if m.get('NonVehicleTypeScore') is not None:
            self.non_vehicle_type_score = m.get('NonVehicleTypeScore')
        if m.get('HeadWear') is not None:
            self.head_wear = m.get('HeadWear')
        if m.get('VehicleType') is not None:
            self.vehicle_type = m.get('VehicleType')
        if m.get('SexType') is not None:
            self.sex_type = m.get('SexType')
        if m.get('PoseTypeScore') is not None:
            self.pose_type_score = m.get('PoseTypeScore')
        if m.get('ObjRight') is not None:
            self.obj_right = m.get('ObjRight')
        if m.get('Feature') is not None:
            self.feature = m.get('Feature')
        if m.get('ClothColorScore') is not None:
            self.cloth_color_score = m.get('ClothColorScore')
        if m.get('CropImage') is not None:
            self.crop_image = m.get('CropImage')
        if m.get('ObjTop') is not None:
            self.obj_top = m.get('ObjTop')
        if m.get('BrandScore') is not None:
            self.brand_score = m.get('BrandScore')
        if m.get('ClothColor') is not None:
            self.cloth_color = m.get('ClothColor')
        if m.get('AgeType') is not None:
            self.age_type = m.get('AgeType')
        if m.get('LeaveTime') is not None:
            self.leave_time = m.get('LeaveTime')
        if m.get('TrouserType') is not None:
            self.trouser_type = m.get('TrouserType')
        if m.get('EntryTime') is not None:
            self.entry_time = m.get('EntryTime')
        return self


class SearchImagesResponseBodyImages(TeaModel):
    def __init__(
        self,
        image: List[SearchImagesResponseBodyImagesImage] = None,
    ):
        self.image = image

    def validate(self):
        if self.image:
            for k in self.image:
                if k:
                    k.validate()

    def to_map(self):
        result = dict()
        result['Image'] = []
        if self.image is not None:
            for k in self.image:
                result['Image'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.image = []
        if m.get('Image') is not None:
            for k in m.get('Image'):
                temp_model = SearchImagesResponseBodyImagesImage()
                self.image.append(temp_model.from_map(k))
        return self


class SearchImagesResponseBody(TeaModel):
    def __init__(
        self,
        total_count: int = None,
        request_id: str = None,
        images: SearchImagesResponseBodyImages = None,
    ):
        self.total_count = total_count
        self.request_id = request_id
        self.images = images

    def validate(self):
        if self.images:
            self.images.validate()

    def to_map(self):
        result = dict()
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.images is not None:
            result['Images'] = self.images.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Images') is not None:
            temp_model = SearchImagesResponseBodyImages()
            self.images = temp_model.from_map(m['Images'])
        return self


class SearchImagesResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: SearchImagesResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = SearchImagesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StartJobGroupRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        region_id: str = None,
        instance_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.region_id = region_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class StartJobGroupResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class StartJobGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: StartJobGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = StartJobGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StopJobGroupRequest(TeaModel):
    def __init__(
        self,
        job_group_id: str = None,
        region_id: str = None,
        instance_id: str = None,
    ):
        self.job_group_id = job_group_id
        self.region_id = region_id
        self.instance_id = instance_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.job_group_id is not None:
            result['JobGroupId'] = self.job_group_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('JobGroupId') is not None:
            self.job_group_id = m.get('JobGroupId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        return self


class StopJobGroupResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
    ):
        self.request_id = request_id

    def validate(self):
        pass

    def to_map(self):
        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class StopJobGroupResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        body: StopJobGroupResponseBody = None,
    ):
        self.headers = headers
        self.body = body

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('body') is not None:
            temp_model = StopJobGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self