cdrs-20201101/main.tea

/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;

init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('cdrs', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }

  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}
model SearchObjectRequest {
  corpId?: string(name='CorpId'),
  objectType?: string(name='ObjectType'),
  vendor?: string(name='Vendor'),
  feature?: string(name='Feature'),
  imageContent?: string(name='ImageContent'),
  imageUrl?: string(name='ImageUrl'),
  deviceList?: string(name='DeviceList'),
  attributes?: string(name='Attributes'),
  shotTimeStart?: string(name='ShotTimeStart'),
  shotTimeEnd?: string(name='ShotTimeEnd'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model SearchObjectResponseBody = {
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  total?: int32(name='Total'),
  data?: {
    bodyList?: [ 
      {
        sourceImageUrl?: string(name='SourceImageUrl'),
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        targetImageUrl?: string(name='TargetImageUrl'),
        rightBottomY?: int32(name='RightBottomY'),
        leftTopY?: int32(name='LeftTopY'),
        score?: float(name='Score'),
        shotTime?: string(name='ShotTime'),
        rightBottomX?: int32(name='RightBottomX'),
        leftTopX?: int32(name='LeftTopX'),
      }
    ](name='BodyList'),
    faceList?: [ 
      {
        sourceImageUrl?: string(name='SourceImageUrl'),
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        targetImageUrl?: string(name='TargetImageUrl'),
        rightBottomY?: int32(name='RightBottomY'),
        leftTopY?: int32(name='LeftTopY'),
        score?: float(name='Score'),
        shotTime?: string(name='ShotTime'),
        rightBottomX?: int32(name='RightBottomX'),
        leftTopX?: int32(name='LeftTopX'),
      }
    ](name='FaceList'),
    motorList?: [ 
      {
        sourceImageUrl?: string(name='SourceImageUrl'),
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        targetImageUrl?: string(name='TargetImageUrl'),
        rightBottomY?: int32(name='RightBottomY'),
        leftTopY?: int32(name='LeftTopY'),
        score?: float(name='Score'),
        shotTime?: string(name='ShotTime'),
        rightBottomX?: int32(name='RightBottomX'),
        leftTopX?: int32(name='LeftTopX'),
      }
    ](name='MotorList'),
    nonMotorList?: [ 
      {
        sourceImageUrl?: string(name='SourceImageUrl'),
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        targetImageUrl?: string(name='TargetImageUrl'),
        rightBottomY?: int32(name='RightBottomY'),
        leftTopY?: int32(name='LeftTopY'),
        score?: float(name='Score'),
        shotTime?: string(name='ShotTime'),
        rightBottomX?: int32(name='RightBottomX'),
        leftTopX?: int32(name='LeftTopX'),
      }
    ](name='NonMotorList'),
  }(name='Data'),
  code?: string(name='Code'),
  success?: boolean(name='Success'),
}

model SearchObjectResponse = {
  headers: map[string]string(name='headers'),
  body: SearchObjectResponseBody(name='body'),
}

async function searchObjectWithOptions(request: SearchObjectRequest, runtime: Util.RuntimeOptions): SearchObjectResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('SearchObject', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function searchObject(request: SearchObjectRequest): SearchObjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchObjectWithOptions(request, runtime);
}

model ListAreaHotSpotMetricsRequest {
  corpId?: string(name='CorpId'),
  personId?: string(name='PersonId'),
  deviceId?: string(name='DeviceId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: string(name='PageNumber'),
  pageSize?: string(name='PageSize'),
}

model ListAreaHotSpotMetricsResponseBody = {
  totalCount?: string(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: string(name='PageSize'),
  pageNumber?: string(name='PageNumber'),
  data?: [ 
    {
      coordinates?: string(name='Coordinates'),
      deviceId?: string(name='DeviceId'),
      times?: string(name='Times'),
      intervalTime?: string(name='IntervalTime'),
      personId?: string(name='PersonId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListAreaHotSpotMetricsResponse = {
  headers: map[string]string(name='headers'),
  body: ListAreaHotSpotMetricsResponseBody(name='body'),
}

async function listAreaHotSpotMetricsWithOptions(request: ListAreaHotSpotMetricsRequest, runtime: Util.RuntimeOptions): ListAreaHotSpotMetricsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListAreaHotSpotMetrics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listAreaHotSpotMetrics(request: ListAreaHotSpotMetricsRequest): ListAreaHotSpotMetricsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAreaHotSpotMetricsWithOptions(request, runtime);
}

model BindDeviceRequest {
  corpId?: string(name='CorpId'),
  devices?: [ 
    {
      deviceId?: string(name='DeviceId'),
      corpId?: string(name='CorpId'),
    }
  ](name='Devices'),
}

model BindDeviceResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      deviceId?: string(name='DeviceId'),
      success?: boolean(name='Success'),
      code?: string(name='Code'),
      message?: string(name='Message'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model BindDeviceResponse = {
  headers: map[string]string(name='headers'),
  body: BindDeviceResponseBody(name='body'),
}

async function bindDeviceWithOptions(request: BindDeviceRequest, runtime: Util.RuntimeOptions): BindDeviceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('BindDevice', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function bindDevice(request: BindDeviceRequest): BindDeviceResponse {
  var runtime = new Util.RuntimeOptions{};
  return bindDeviceWithOptions(request, runtime);
}

model GetCdrsMonitorResultRequest {
  corpId?: string(name='CorpId'),
  taskId?: string(name='TaskId'),
  minRecordId?: string(name='MinRecordId'),
  startTime?: long(name='StartTime'),
  endTime?: long(name='EndTime'),
  algorithmVendor?: string(name='AlgorithmVendor'),
}

model GetCdrsMonitorResultResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    maxId?: string(name='MaxId'),
    records?: [ 
      {
        picUrl?: string(name='PicUrl'),
        rightBottomY?: string(name='RightBottomY'),
        score?: string(name='Score'),
        monitorPicUrl?: string(name='MonitorPicUrl'),
        rightBottomX?: string(name='RightBottomX'),
        extendInfo?: {
          plateNo?: string(name='PlateNo'),
        }(name='ExtendInfo'),
        gbId?: string(name='GbId'),
        leftUpY?: string(name='LeftUpY'),
        leftUpX?: string(name='LeftUpX'),
        shotTime?: string(name='ShotTime'),
        taskId?: string(name='TaskId'),
        targetPicUrl?: string(name='TargetPicUrl'),
      }
    ](name='Records'),
  }(name='Data'),
  code?: string(name='Code'),
}

model GetCdrsMonitorResultResponse = {
  headers: map[string]string(name='headers'),
  body: GetCdrsMonitorResultResponseBody(name='body'),
}

async function getCdrsMonitorResultWithOptions(request: GetCdrsMonitorResultRequest, runtime: Util.RuntimeOptions): GetCdrsMonitorResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetCdrsMonitorResult', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getCdrsMonitorResult(request: GetCdrsMonitorResultRequest): GetCdrsMonitorResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCdrsMonitorResultWithOptions(request, runtime);
}

model ListVehicleDetailsRequest {
  corpId?: string(name='CorpId'),
  plateId?: string(name='PlateId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: string(name='PageNumber'),
  pageSize?: string(name='PageSize'),
}

model ListVehicleDetailsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      vehicleApplication?: string(name='VehicleApplication'),
      sourceUrl?: string(name='SourceUrl'),
      gender?: string(name='Gender'),
      vehicleColor?: string(name='VehicleColor'),
      vehicleId?: string(name='VehicleId'),
      sourceImageStoragePath?: string(name='SourceImageStoragePath'),
      personType?: string(name='PersonType'),
      popularPoi?: string(name='PopularPoi'),
      popularAddress?: string(name='PopularAddress'),
      plateId?: string(name='PlateId'),
      targetUrl?: string(name='TargetUrl'),
      vehicleClass?: string(name='VehicleClass'),
      prefOutTime?: string(name='PrefOutTime'),
      personId?: string(name='PersonId'),
      targetImageStoragePath?: string(name='TargetImageStoragePath'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListVehicleDetailsResponse = {
  headers: map[string]string(name='headers'),
  body: ListVehicleDetailsResponseBody(name='body'),
}

async function listVehicleDetailsWithOptions(request: ListVehicleDetailsRequest, runtime: Util.RuntimeOptions): ListVehicleDetailsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListVehicleDetails', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listVehicleDetails(request: ListVehicleDetailsRequest): ListVehicleDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listVehicleDetailsWithOptions(request, runtime);
}

model GetCdrsMonitorListRequest {
  corpId?: string(name='CorpId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
}

model GetCdrsMonitorListResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    records?: [ 
      {
        status?: string(name='Status'),
        ruleExpression?: string(name='RuleExpression'),
        imageMatch?: string(name='ImageMatch'),
        monitorType?: string(name='MonitorType'),
        createDate?: string(name='CreateDate'),
        ruleName?: string(name='RuleName'),
        notifierType?: string(name='NotifierType'),
        description?: string(name='Description'),
        expression?: string(name='Expression'),
        notifierExtra?: string(name='NotifierExtra'),
        attributes?: string(name='Attributes'),
        deviceList?: string(name='DeviceList'),
        taskId?: string(name='TaskId'),
        modifiedDate?: string(name='ModifiedDate'),
        algorithmVendor?: string(name='AlgorithmVendor'),
      }
    ](name='Records'),
    pageNo?: int32(name='PageNo'),
    totalPage?: int32(name='TotalPage'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  code?: string(name='Code'),
}

model GetCdrsMonitorListResponse = {
  headers: map[string]string(name='headers'),
  body: GetCdrsMonitorListResponseBody(name='body'),
}

async function getCdrsMonitorListWithOptions(request: GetCdrsMonitorListRequest, runtime: Util.RuntimeOptions): GetCdrsMonitorListResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetCdrsMonitorList', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getCdrsMonitorList(request: GetCdrsMonitorListRequest): GetCdrsMonitorListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCdrsMonitorListWithOptions(request, runtime);
}

model UpdateMonitorRequest {
  corpId?: string(name='CorpId'),
  taskId?: string(name='TaskId'),
  ruleName?: string(name='RuleName'),
  deviceOperateType?: string(name='DeviceOperateType'),
  deviceList?: string(name='DeviceList'),
  picOperateType?: string(name='PicOperateType'),
  picList?: string(name='PicList'),
  attributeOperateType?: string(name='AttributeOperateType'),
  attributeName?: string(name='AttributeName'),
  attributeValueList?: string(name='AttributeValueList'),
  description?: string(name='Description'),
  ruleExpression?: string(name='RuleExpression'),
  algorithmVendor?: string(name='AlgorithmVendor'),
  notifierType?: string(name='NotifierType'),
  notifierUrl?: string(name='NotifierUrl'),
  notifierAppSecret?: string(name='NotifierAppSecret'),
  notifierTimeOut?: int32(name='NotifierTimeOut'),
  notifierExtendValues?: string(name='NotifierExtendValues'),
  picExtendList?: string(name='PicExtendList'),
}

model UpdateMonitorResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: string(name='Code'),
}

model UpdateMonitorResponse = {
  headers: map[string]string(name='headers'),
  body: UpdateMonitorResponseBody(name='body'),
}

async function updateMonitorWithOptions(request: UpdateMonitorRequest, runtime: Util.RuntimeOptions): UpdateMonitorResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateMonitor', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateMonitor(request: UpdateMonitorRequest): UpdateMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateMonitorWithOptions(request, runtime);
}

model ListDataStatisticsRequest {
  backCategory?: string(name='BackCategory'),
  schema?: string(name='Schema'),
}

model ListDataStatisticsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      corpId?: string(name='CorpId'),
      number?: string(name='Number'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDataStatisticsResponse = {
  headers: map[string]string(name='headers'),
  body: ListDataStatisticsResponseBody(name='body'),
}

async function listDataStatisticsWithOptions(request: ListDataStatisticsRequest, runtime: Util.RuntimeOptions): ListDataStatisticsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDataStatistics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDataStatistics(request: ListDataStatisticsRequest): ListDataStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDataStatisticsWithOptions(request, runtime);
}

model UnbindDeviceRequest {
  corpId?: string(name='CorpId'),
  deviceIds?: string(name='DeviceIds'),
}

model UnbindDeviceResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      deviceId?: string(name='DeviceId'),
      success?: boolean(name='Success'),
      code?: string(name='Code'),
      message?: string(name='Message'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model UnbindDeviceResponse = {
  headers: map[string]string(name='headers'),
  body: UnbindDeviceResponseBody(name='body'),
}

async function unbindDeviceWithOptions(request: UnbindDeviceRequest, runtime: Util.RuntimeOptions): UnbindDeviceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UnbindDevice', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function unbindDevice(request: UnbindDeviceRequest): UnbindDeviceResponse {
  var runtime = new Util.RuntimeOptions{};
  return unbindDeviceWithOptions(request, runtime);
}

model ListPersonDetailsRequest {
  corpId?: string(name='CorpId'),
  personId?: string(name='PersonId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  schema?: string(name='Schema'),
}

model ListPersonDetailsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      updateTime?: string(name='UpdateTime'),
      gender?: string(name='Gender'),
      bodyTargetImage?: string(name='BodyTargetImage'),
      preferredColor?: string(name='PreferredColor'),
      hotSpotAddress?: string(name='HotSpotAddress'),
      age?: string(name='Age'),
      personType?: string(name='PersonType'),
      transportation?: string(name='Transportation'),
      profession?: string(name='Profession'),
      address?: string(name='Address'),
      faceSourceImage?: string(name='FaceSourceImage'),
      faceTargetImage?: string(name='FaceTargetImage'),
      prefOutTime?: string(name='PrefOutTime'),
      bodySourceImage?: string(name='BodySourceImage'),
      personId?: string(name='PersonId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListPersonDetailsResponse = {
  headers: map[string]string(name='headers'),
  body: ListPersonDetailsResponseBody(name='body'),
}

async function listPersonDetailsWithOptions(request: ListPersonDetailsRequest, runtime: Util.RuntimeOptions): ListPersonDetailsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListPersonDetails', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listPersonDetails(request: ListPersonDetailsRequest): ListPersonDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPersonDetailsWithOptions(request, runtime);
}

model ListVehicleTagDistributeRequest {
  corpId?: string(name='CorpId'),
  tagCode?: string(name='TagCode'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
}

model ListVehicleTagDistributeResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      value?: string(name='Value'),
      corpId?: string(name='CorpId'),
      tagValue?: string(name='TagValue'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListVehicleTagDistributeResponse = {
  headers: map[string]string(name='headers'),
  body: ListVehicleTagDistributeResponseBody(name='body'),
}

async function listVehicleTagDistributeWithOptions(request: ListVehicleTagDistributeRequest, runtime: Util.RuntimeOptions): ListVehicleTagDistributeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListVehicleTagDistribute', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listVehicleTagDistribute(request: ListVehicleTagDistributeRequest): ListVehicleTagDistributeResponse {
  var runtime = new Util.RuntimeOptions{};
  return listVehicleTagDistributeWithOptions(request, runtime);
}

model ListDevicePersonStatisticsRequest {
  dataSourceId?: string(name='DataSourceId'),
  statisticsType?: string(name='StatisticsType'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  corpId?: string(name='CorpId'),
}

model ListDevicePersonStatisticsResponseBody = {
  totalCount?: long(name='TotalCount'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      dataSourceId?: string(name='DataSourceId'),
      number?: string(name='Number'),
      shotTime?: string(name='ShotTime'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDevicePersonStatisticsResponse = {
  headers: map[string]string(name='headers'),
  body: ListDevicePersonStatisticsResponseBody(name='body'),
}

async function listDevicePersonStatisticsWithOptions(request: ListDevicePersonStatisticsRequest, runtime: Util.RuntimeOptions): ListDevicePersonStatisticsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDevicePersonStatistics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDevicePersonStatistics(request: ListDevicePersonStatisticsRequest): ListDevicePersonStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDevicePersonStatisticsWithOptions(request, runtime);
}

model AddMonitorRequest {
  corpId?: string(name='CorpId'),
  monitorType?: string(name='MonitorType'),
  description?: string(name='Description'),
  batchIndicator?: int32(name='BatchIndicator'),
  algorithmVendor?: string(name='AlgorithmVendor'),
  notifierType?: string(name='NotifierType'),
  notifierUrl?: string(name='NotifierUrl'),
  notifierAppSecret?: string(name='NotifierAppSecret'),
  notifierTimeOut?: int32(name='NotifierTimeOut'),
  notifierExtendValues?: string(name='NotifierExtendValues'),
}

model AddMonitorResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    taskId?: string(name='TaskId'),
  }(name='Data'),
  code?: string(name='Code'),
}

model AddMonitorResponse = {
  headers: map[string]string(name='headers'),
  body: AddMonitorResponseBody(name='body'),
}

async function addMonitorWithOptions(request: AddMonitorRequest, runtime: Util.RuntimeOptions): AddMonitorResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddMonitor', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addMonitor(request: AddMonitorRequest): AddMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return addMonitorWithOptions(request, runtime);
}

model PaginateDeviceRequest {
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  countTotalNum?: boolean(name='CountTotalNum'),
  corpId?: string(name='CorpId'),
}

model PaginateDeviceResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    records?: [ 
      {
        deviceId?: string(name='DeviceId'),
      }
    ](name='Records'),
    pageNumber?: int32(name='PageNumber'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  code?: string(name='Code'),
}

model PaginateDeviceResponse = {
  headers: map[string]string(name='headers'),
  body: PaginateDeviceResponseBody(name='body'),
}

async function paginateDeviceWithOptions(request: PaginateDeviceRequest, runtime: Util.RuntimeOptions): PaginateDeviceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('PaginateDevice', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function paginateDevice(request: PaginateDeviceRequest): PaginateDeviceResponse {
  var runtime = new Util.RuntimeOptions{};
  return paginateDeviceWithOptions(request, runtime);
}

model StopCdrsMonitorRequest {
  taskId?: string(name='TaskId'),
  algorithmVendor?: string(name='AlgorithmVendor'),
  corpId?: string(name='CorpId'),
}

model StopCdrsMonitorResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: string(name='Code'),
}

model StopCdrsMonitorResponse = {
  headers: map[string]string(name='headers'),
  body: StopCdrsMonitorResponseBody(name='body'),
}

async function stopCdrsMonitorWithOptions(request: StopCdrsMonitorRequest, runtime: Util.RuntimeOptions): StopCdrsMonitorResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('StopCdrsMonitor', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function stopCdrsMonitor(request: StopCdrsMonitorRequest): StopCdrsMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return stopCdrsMonitorWithOptions(request, runtime);
}

model RecallTrajectoryByCoordinateTimeRequest {
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  corpId?: string(name='CorpId'),
  outputIdCount?: int32(name='OutputIdCount'),
  pointList?: [ 
    {
      endTime?: string(name='EndTime'),
      startTime?: string(name='StartTime'),
      longitude?: float(name='Longitude'),
      latitude?: float(name='Latitude'),
      deltaDistance?: float(name='DeltaDistance'),
    }
  ](name='PointList'),
  outputIdTypeList?: [ string ](name='OutputIdTypeList'),
}

model RecallTrajectoryByCoordinateTimeResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: int32(name='Code'),
  success?: boolean(name='Success'),
}

model RecallTrajectoryByCoordinateTimeResponse = {
  headers: map[string]string(name='headers'),
  body: RecallTrajectoryByCoordinateTimeResponseBody(name='body'),
}

async function recallTrajectoryByCoordinateTimeWithOptions(request: RecallTrajectoryByCoordinateTimeRequest, runtime: Util.RuntimeOptions): RecallTrajectoryByCoordinateTimeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RecallTrajectoryByCoordinateTime', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function recallTrajectoryByCoordinateTime(request: RecallTrajectoryByCoordinateTimeRequest): RecallTrajectoryByCoordinateTimeResponse {
  var runtime = new Util.RuntimeOptions{};
  return recallTrajectoryByCoordinateTimeWithOptions(request, runtime);
}

model ListCityMapPersonFlowRequest {
  originDataSourceIdList?: map[string]any(name='OriginDataSourceIdList'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  targetDataSourceIdList?: map[string]any(name='TargetDataSourceIdList'),
  endTime?: string(name='EndTime'),
  startTime?: string(name='StartTime'),
  range?: string(name='Range'),
}

model ListCityMapPersonFlowShrinkRequest {
  originDataSourceIdListShrink?: string(name='OriginDataSourceIdList'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  targetDataSourceIdListShrink?: string(name='TargetDataSourceIdList'),
  endTime?: string(name='EndTime'),
  startTime?: string(name='StartTime'),
  range?: string(name='Range'),
}

model ListCityMapPersonFlowResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      flowNumber?: string(name='FlowNumber'),
      originDataSourceId?: string(name='OriginDataSourceId'),
      targetDataSourceId?: string(name='TargetDataSourceId'),
      flowDirection?: string(name='FlowDirection'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListCityMapPersonFlowResponse = {
  headers: map[string]string(name='headers'),
  body: ListCityMapPersonFlowResponseBody(name='body'),
}

async function listCityMapPersonFlowWithOptions(tmpReq: ListCityMapPersonFlowRequest, runtime: Util.RuntimeOptions): ListCityMapPersonFlowResponse {
  Util.validateModel(tmpReq);
  var request = new ListCityMapPersonFlowShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.originDataSourceIdList)) {
    request.originDataSourceIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.originDataSourceIdList, 'OriginDataSourceIdList', 'json');
  }
  if (!Util.isUnset(tmpReq.targetDataSourceIdList)) {
    request.targetDataSourceIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.targetDataSourceIdList, 'TargetDataSourceIdList', 'json');
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCityMapPersonFlow', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCityMapPersonFlow(request: ListCityMapPersonFlowRequest): ListCityMapPersonFlowResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCityMapPersonFlowWithOptions(request, runtime);
}

model AddCdrsMonitorRequest {
  corpId?: string(name='CorpId'),
  monitorType?: string(name='MonitorType'),
  description?: string(name='Description'),
  batchIndicator?: int32(name='BatchIndicator'),
  algorithmVendor?: string(name='AlgorithmVendor'),
  notifierType?: string(name='NotifierType'),
  notifierUrl?: string(name='NotifierUrl'),
  notifierAppSecret?: string(name='NotifierAppSecret'),
  notifierTimeOut?: int32(name='NotifierTimeOut'),
  notifierExtendValues?: string(name='NotifierExtendValues'),
}

model AddCdrsMonitorResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    taskId?: string(name='TaskId'),
  }(name='Data'),
  code?: string(name='Code'),
}

model AddCdrsMonitorResponse = {
  headers: map[string]string(name='headers'),
  body: AddCdrsMonitorResponseBody(name='body'),
}

async function addCdrsMonitorWithOptions(request: AddCdrsMonitorRequest, runtime: Util.RuntimeOptions): AddCdrsMonitorResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddCdrsMonitor', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addCdrsMonitor(request: AddCdrsMonitorRequest): AddCdrsMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return addCdrsMonitorWithOptions(request, runtime);
}

model ListMapRouteDetailsRequest {
  routeList?: map[string]any(name='RouteList'),
}

model ListMapRouteDetailsShrinkRequest {
  routeListShrink?: string(name='RouteList'),
}

model ListMapRouteDetailsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      type?: string(name='Type'),
      destination?: string(name='Destination'),
      origin?: string(name='Origin'),
      route?: string(name='Route'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListMapRouteDetailsResponse = {
  headers: map[string]string(name='headers'),
  body: ListMapRouteDetailsResponseBody(name='body'),
}

async function listMapRouteDetailsWithOptions(tmpReq: ListMapRouteDetailsRequest, runtime: Util.RuntimeOptions): ListMapRouteDetailsResponse {
  Util.validateModel(tmpReq);
  var request = new ListMapRouteDetailsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.routeList)) {
    request.routeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.routeList, 'RouteList', 'json');
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListMapRouteDetails', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listMapRouteDetails(request: ListMapRouteDetailsRequest): ListMapRouteDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listMapRouteDetailsWithOptions(request, runtime);
}

model ListPersonTopRequest {
  corpId?: string(name='CorpId'),
  personId?: string(name='PersonId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
}

model ListPersonTopResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      frequency?: string(name='Frequency'),
      poiId?: string(name='PoiId'),
      corpId?: string(name='CorpId'),
      passHour?: string(name='PassHour'),
      poiName?: string(name='PoiName'),
      personId?: string(name='PersonId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListPersonTopResponse = {
  headers: map[string]string(name='headers'),
  body: ListPersonTopResponseBody(name='body'),
}

async function listPersonTopWithOptions(request: ListPersonTopRequest, runtime: Util.RuntimeOptions): ListPersonTopResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListPersonTop', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listPersonTop(request: ListPersonTopRequest): ListPersonTopResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPersonTopWithOptions(request, runtime);
}

model GetMonitorResultRequest {
  corpId?: string(name='CorpId'),
  taskId?: string(name='TaskId'),
  minRecordId?: string(name='MinRecordId'),
  startTime?: long(name='StartTime'),
  endTime?: long(name='EndTime'),
  algorithmVendor?: string(name='AlgorithmVendor'),
}

model GetMonitorResultResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    maxId?: string(name='MaxId'),
    records?: [ 
      {
        picUrl?: string(name='PicUrl'),
        rightBottomY?: string(name='RightBottomY'),
        score?: string(name='Score'),
        monitorPicUrl?: string(name='MonitorPicUrl'),
        rightBottomX?: string(name='RightBottomX'),
        extendInfo?: {
          plateNo?: string(name='PlateNo'),
        }(name='ExtendInfo'),
        gbId?: string(name='GbId'),
        leftUpY?: string(name='LeftUpY'),
        leftUpX?: string(name='LeftUpX'),
        shotTime?: string(name='ShotTime'),
        taskId?: string(name='TaskId'),
        targetPicUrl?: string(name='TargetPicUrl'),
      }
    ](name='Records'),
  }(name='Data'),
  code?: string(name='Code'),
}

model GetMonitorResultResponse = {
  headers: map[string]string(name='headers'),
  body: GetMonitorResultResponseBody(name='body'),
}

async function getMonitorResultWithOptions(request: GetMonitorResultRequest, runtime: Util.RuntimeOptions): GetMonitorResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetMonitorResult', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getMonitorResult(request: GetMonitorResultRequest): GetMonitorResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMonitorResultWithOptions(request, runtime);
}

model ListCityMapAoisRequest {
  radius?: int32(name='Radius'),
  latitude?: string(name='Latitude'),
  longitude?: string(name='Longitude'),
}

model ListCityMapAoisResponseBody = {
  totalCount?: long(name='TotalCount'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      value?: string(name='Value'),
      id?: string(name='Id'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListCityMapAoisResponse = {
  headers: map[string]string(name='headers'),
  body: ListCityMapAoisResponseBody(name='body'),
}

async function listCityMapAoisWithOptions(request: ListCityMapAoisRequest, runtime: Util.RuntimeOptions): ListCityMapAoisResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCityMapAois', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCityMapAois(request: ListCityMapAoisRequest): ListCityMapAoisResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCityMapAoisWithOptions(request, runtime);
}

model RecognizeImageRequest {
  corpId?: string(name='CorpId'),
  vendor?: string(name='Vendor'),
  imageContent?: string(name='ImageContent'),
  imageUrl?: string(name='ImageUrl'),
  recognizeType?: string(name='RecognizeType'),
  requireCropImage?: boolean(name='RequireCropImage'),
}

model RecognizeImageResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    bodyList?: [ 
      {
        cropAlgorithmCode?: string(name='CropAlgorithmCode'),
        rightBottomY?: int32(name='RightBottomY'),
        feature?: string(name='Feature'),
        leftTopY?: int32(name='LeftTopY'),
        targetImageContent?: string(name='TargetImageContent'),
        leftTopX?: int32(name='LeftTopX'),
        rightBottomX?: int32(name='RightBottomX'),
      }
    ](name='BodyList'),
    faceList?: [ 
      {
        cropAlgorithmCode?: string(name='CropAlgorithmCode'),
        feature?: string(name='Feature'),
        rightBottomY?: int32(name='RightBottomY'),
        leftTopY?: int32(name='LeftTopY'),
        targetImageContent?: string(name='TargetImageContent'),
        faceQuality?: float(name='FaceQuality'),
        rightBottomX?: int32(name='RightBottomX'),
        leftTopX?: int32(name='LeftTopX'),
        faceKeyPointQuality?: float(name='FaceKeyPointQuality'),
      }
    ](name='FaceList'),
  }(name='Data'),
  code?: string(name='Code'),
  success?: string(name='Success'),
}

model RecognizeImageResponse = {
  headers: map[string]string(name='headers'),
  body: RecognizeImageResponseBody(name='body'),
}

async function recognizeImageWithOptions(request: RecognizeImageRequest, runtime: Util.RuntimeOptions): RecognizeImageResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RecognizeImage', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function recognizeImage(request: RecognizeImageRequest): RecognizeImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return recognizeImageWithOptions(request, runtime);
}

model GetMonitorListRequest {
  corpId?: string(name='CorpId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model GetMonitorListResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    records?: [ 
      {
        status?: string(name='Status'),
        ruleExpression?: string(name='RuleExpression'),
        imageMatch?: string(name='ImageMatch'),
        monitorType?: string(name='MonitorType'),
        createDate?: string(name='CreateDate'),
        ruleName?: string(name='RuleName'),
        notifierType?: string(name='NotifierType'),
        description?: string(name='Description'),
        expression?: string(name='Expression'),
        notifierExtra?: string(name='NotifierExtra'),
        attributes?: string(name='Attributes'),
        deviceList?: string(name='DeviceList'),
        taskId?: string(name='TaskId'),
        modifiedDate?: string(name='ModifiedDate'),
        algorithmVendor?: string(name='AlgorithmVendor'),
      }
    ](name='Records'),
    totalPage?: int32(name='TotalPage'),
    pageNumber?: int32(name='PageNumber'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  code?: string(name='Code'),
}

model GetMonitorListResponse = {
  headers: map[string]string(name='headers'),
  body: GetMonitorListResponseBody(name='body'),
}

async function getMonitorListWithOptions(request: GetMonitorListRequest, runtime: Util.RuntimeOptions): GetMonitorListResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetMonitorList', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getMonitorList(request: GetMonitorListRequest): GetMonitorListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMonitorListWithOptions(request, runtime);
}

model ListDeviceRelationRequest {
  deviceId?: string(name='DeviceId'),
}

model ListDeviceRelationResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      corpId?: string(name='CorpId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDeviceRelationResponse = {
  headers: map[string]string(name='headers'),
  body: ListDeviceRelationResponseBody(name='body'),
}

async function listDeviceRelationWithOptions(request: ListDeviceRelationRequest, runtime: Util.RuntimeOptions): ListDeviceRelationResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDeviceRelation', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDeviceRelation(request: ListDeviceRelationRequest): ListDeviceRelationResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDeviceRelationWithOptions(request, runtime);
}

model ListPersonTrackRequest {
  corpId?: string(name='CorpId'),
  personId?: string(name='PersonId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  imageSourceType?: string(name='ImageSourceType'),
  aggregateDimension?: string(name='AggregateDimension'),
  qualityScore?: string(name='QualityScore'),
}

model ListPersonTrackResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      sourceUrl?: string(name='SourceUrl'),
      rightBottomY?: string(name='RightBottomY'),
      dataSourceName?: string(name='DataSourceName'),
      picUrlPath?: string(name='PicUrlPath'),
      dataSourceId?: string(name='DataSourceId'),
      rightBottomX?: string(name='RightBottomX'),
      targetPicUrlPath?: string(name='TargetPicUrlPath'),
      leftTopY?: string(name='LeftTopY'),
      targetUrl?: string(name='TargetUrl'),
      corpId?: string(name='CorpId'),
      longitude?: string(name='Longitude'),
      latitude?: string(name='Latitude'),
      shotTime?: string(name='ShotTime'),
      personId?: string(name='PersonId'),
      leftTopX?: string(name='LeftTopX'),
      tagGender?: string(name='TagGender'),
      tagAge?: string(name='TagAge'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListPersonTrackResponse = {
  headers: map[string]string(name='headers'),
  body: ListPersonTrackResponseBody(name='body'),
}

async function listPersonTrackWithOptions(request: ListPersonTrackRequest, runtime: Util.RuntimeOptions): ListPersonTrackResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListPersonTrack', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listPersonTrack(request: ListPersonTrackRequest): ListPersonTrackResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPersonTrackWithOptions(request, runtime);
}

model ListCityMapCameraResultsRequest {
  dataSourceIdList?: map[string]any(name='DataSourceIdList'),
  pageNum?: long(name='PageNum'),
  pageSize?: long(name='PageSize'),
}

model ListCityMapCameraResultsShrinkRequest {
  dataSourceIdListShrink?: string(name='DataSourceIdList'),
  pageNum?: long(name='PageNum'),
  pageSize?: long(name='PageSize'),
}

model ListCityMapCameraResultsResponseBody = {
  totalCount?: long(name='TotalCount'),
  pageNum?: string(name='PageNum'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: string(name='PageSize'),
  data?: [ 
    {
      dataSourceName?: string(name='DataSourceName'),
      dataSourceId?: string(name='DataSourceId'),
      corpId?: string(name='CorpId'),
      longitude?: string(name='Longitude'),
      latitude?: string(name='Latitude'),
      dataSourcePoi?: string(name='DataSourcePoi'),
      nearPoi?: string(name='NearPoi'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListCityMapCameraResultsResponse = {
  headers: map[string]string(name='headers'),
  body: ListCityMapCameraResultsResponseBody(name='body'),
}

async function listCityMapCameraResultsWithOptions(tmpReq: ListCityMapCameraResultsRequest, runtime: Util.RuntimeOptions): ListCityMapCameraResultsResponse {
  Util.validateModel(tmpReq);
  var request = new ListCityMapCameraResultsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.dataSourceIdList)) {
    request.dataSourceIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.dataSourceIdList, 'DataSourceIdList', 'json');
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCityMapCameraResults', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCityMapCameraResults(request: ListCityMapCameraResultsRequest): ListCityMapCameraResultsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCityMapCameraResultsWithOptions(request, runtime);
}

model QueryTrajectoryByIdRequest {
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  corpId?: string(name='CorpId'),
  idList?: [ 
    {
      idValue?: string(name='IdValue'),
      idType?: string(name='IdType'),
    }
  ](name='IdList'),
  deviceList?: [ 
    {
      deviceId?: string(name='DeviceId'),
    }
  ](name='DeviceList'),
}

model QueryTrajectoryByIdResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: int32(name='Code'),
  success?: boolean(name='Success'),
}

model QueryTrajectoryByIdResponse = {
  headers: map[string]string(name='headers'),
  body: QueryTrajectoryByIdResponseBody(name='body'),
}

async function queryTrajectoryByIdWithOptions(request: QueryTrajectoryByIdRequest, runtime: Util.RuntimeOptions): QueryTrajectoryByIdResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('QueryTrajectoryById', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function queryTrajectoryById(request: QueryTrajectoryByIdRequest): QueryTrajectoryByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTrajectoryByIdWithOptions(request, runtime);
}

model ListCityMapImageDetailsRequest {
  dataSourceId?: string(name='DataSourceId'),
  recordNumber?: long(name='RecordNumber'),
  timeInterval?: string(name='TimeInterval'),
}

model ListCityMapImageDetailsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      motorTargetImageStoragePath?: string(name='MotorTargetImageStoragePath'),
      rightBottomY?: string(name='RightBottomY'),
      dataSourceId?: string(name='DataSourceId'),
      recordId?: string(name='RecordId'),
      vehicleColor?: string(name='VehicleColor'),
      sourceImageStoragePath?: string(name='SourceImageStoragePath'),
      ageUpLimit?: string(name='AgeUpLimit'),
      coatColor?: string(name='CoatColor'),
      rightBottomX?: string(name='RightBottomX'),
      trousersColorReliability?: string(name='TrousersColorReliability'),
      ageLowerLimit?: string(name='AgeLowerLimit'),
      leftTopY?: string(name='LeftTopY'),
      shotTime?: string(name='ShotTime'),
      personTargetImageStoragePath?: string(name='PersonTargetImageStoragePath'),
      vehicleClassReliability?: string(name='VehicleClassReliability'),
      genderCodeReliability?: string(name='GenderCodeReliability'),
      gender?: string(name='Gender'),
      trousersColor?: string(name='TrousersColor'),
      ageCodeReliability?: string(name='AgeCodeReliability'),
      faceTargetImageStoragePath?: string(name='FaceTargetImageStoragePath'),
      vehicleClass?: string(name='VehicleClass'),
      vehicleColorReliability?: string(name='VehicleColorReliability'),
      leftTopX?: string(name='LeftTopX'),
      ageLowerLimitReliability?: string(name='AgeLowerLimitReliability'),
      coatColorReliability?: string(name='CoatColorReliability'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListCityMapImageDetailsResponse = {
  headers: map[string]string(name='headers'),
  body: ListCityMapImageDetailsResponseBody(name='body'),
}

async function listCityMapImageDetailsWithOptions(request: ListCityMapImageDetailsRequest, runtime: Util.RuntimeOptions): ListCityMapImageDetailsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCityMapImageDetails', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCityMapImageDetails(request: ListCityMapImageDetailsRequest): ListCityMapImageDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCityMapImageDetailsWithOptions(request, runtime);
}

model CreateProjectRequest {
  name?: string(name='Name'),
  icon?: string(name='Icon'),
  description?: string(name='Description'),
  aggregateSceneCode?: string(name='AggregateSceneCode'),
}

model CreateProjectResponseBody = {
  corpId?: string(name='CorpId'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  code?: string(name='Code'),
}

model CreateProjectResponse = {
  headers: map[string]string(name='headers'),
  body: CreateProjectResponseBody(name='body'),
}

async function createProjectWithOptions(request: CreateProjectRequest, runtime: Util.RuntimeOptions): CreateProjectResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateProject', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createProject(request: CreateProjectRequest): CreateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return createProjectWithOptions(request, runtime);
}

model ListVehicleTopRequest {
  corpId?: string(name='CorpId'),
  plateId?: string(name='PlateId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageSize?: string(name='PageSize'),
  pageNum?: string(name='PageNum'),
}

model ListVehicleTopResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      frequency?: string(name='Frequency'),
      poiId?: string(name='PoiId'),
      corpId?: string(name='CorpId'),
      vehicleId?: string(name='VehicleId'),
      passHour?: string(name='PassHour'),
      poiName?: string(name='PoiName'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListVehicleTopResponse = {
  headers: map[string]string(name='headers'),
  body: ListVehicleTopResponseBody(name='body'),
}

async function listVehicleTopWithOptions(request: ListVehicleTopRequest, runtime: Util.RuntimeOptions): ListVehicleTopResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListVehicleTop', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listVehicleTop(request: ListVehicleTopRequest): ListVehicleTopResponse {
  var runtime = new Util.RuntimeOptions{};
  return listVehicleTopWithOptions(request, runtime);
}

model ListDataStatisticsByDayRequest {
  corpId?: string(name='CorpId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
}

model ListDataStatisticsByDayResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      nonMotorNumber?: int32(name='NonMotorNumber'),
      faceNumber?: int32(name='FaceNumber'),
      motorNumber?: int32(name='MotorNumber'),
      corpId?: string(name='CorpId'),
      date?: string(name='Date'),
      bodyNumber?: int32(name='BodyNumber'),
      totalNumber?: int32(name='TotalNumber'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDataStatisticsByDayResponse = {
  headers: map[string]string(name='headers'),
  body: ListDataStatisticsByDayResponseBody(name='body'),
}

async function listDataStatisticsByDayWithOptions(request: ListDataStatisticsByDayRequest, runtime: Util.RuntimeOptions): ListDataStatisticsByDayResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDataStatisticsByDay', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDataStatisticsByDay(request: ListDataStatisticsByDayRequest): ListDataStatisticsByDayResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDataStatisticsByDayWithOptions(request, runtime);
}

model ListVehicleResultsRequest {
  corpId?: string(name='CorpId'),
  vehicleColor?: string(name='VehicleColor'),
  vehicleClass?: string(name='VehicleClass'),
  vehicleApplication?: string(name='VehicleApplication'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
}

model ListVehicleResultsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      vehicleApplication?: string(name='VehicleApplication'),
      profession?: string(name='Profession'),
      updateTime?: string(name='UpdateTime'),
      gender?: string(name='Gender'),
      plateId?: string(name='PlateId'),
      vehicleClass?: string(name='VehicleClass'),
      liveAddress?: string(name='LiveAddress'),
      vehicleId?: string(name='VehicleId'),
      personId?: string(name='PersonId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListVehicleResultsResponse = {
  headers: map[string]string(name='headers'),
  body: ListVehicleResultsResponseBody(name='body'),
}

async function listVehicleResultsWithOptions(request: ListVehicleResultsRequest, runtime: Util.RuntimeOptions): ListVehicleResultsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListVehicleResults', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listVehicleResults(request: ListVehicleResultsRequest): ListVehicleResultsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listVehicleResultsWithOptions(request, runtime);
}

model SearchAggregateObjectRequest {
  corpId?: string(name='CorpId'),
  objectType?: string(name='ObjectType'),
  vendor?: string(name='Vendor'),
  feature?: string(name='Feature'),
  imageContent?: string(name='ImageContent'),
  imageUrl?: string(name='ImageUrl'),
  deviceList?: string(name='DeviceList'),
  attributes?: string(name='Attributes'),
  shotTimeStart?: string(name='ShotTimeStart'),
  shotTimeEnd?: string(name='ShotTimeEnd'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  requireTotalCount?: boolean(name='RequireTotalCount'),
}

model SearchAggregateObjectResponseBody = {
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  total?: int32(name='Total'),
  data?: {
    bodyList?: [ 
      {
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        deviceName?: string(name='DeviceName'),
        rightBottomY?: int32(name='RightBottomY'),
        score?: float(name='Score'),
        rightBottomX?: int32(name='RightBottomX'),
        deviceLongitude?: float(name='DeviceLongitude'),
        sourceImageUrl?: string(name='SourceImageUrl'),
        targetImageUrl?: string(name='TargetImageUrl'),
        leftTopY?: int32(name='LeftTopY'),
        shotTime?: string(name='ShotTime'),
        personId?: string(name='PersonId'),
        leftTopX?: int32(name='LeftTopX'),
        deviceLatitude?: float(name='DeviceLatitude'),
      }
    ](name='BodyList'),
    faceList?: [ 
      {
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        deviceName?: string(name='DeviceName'),
        rightBottomY?: int32(name='RightBottomY'),
        score?: float(name='Score'),
        rightBottomX?: int32(name='RightBottomX'),
        deviceLongitude?: float(name='DeviceLongitude'),
        sourceImageUrl?: string(name='SourceImageUrl'),
        targetImageUrl?: string(name='TargetImageUrl'),
        leftTopY?: int32(name='LeftTopY'),
        shotTime?: string(name='ShotTime'),
        personId?: string(name='PersonId'),
        leftTopX?: int32(name='LeftTopX'),
        deviceLatitude?: float(name='DeviceLatitude'),
      }
    ](name='FaceList'),
    motorList?: [ 
      {
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        deviceName?: string(name='DeviceName'),
        rightBottomY?: int32(name='RightBottomY'),
        score?: float(name='Score'),
        rightBottomX?: int32(name='RightBottomX'),
        deviceLongitude?: float(name='DeviceLongitude'),
        sourceImageUrl?: string(name='SourceImageUrl'),
        targetImageUrl?: string(name='TargetImageUrl'),
        leftTopY?: int32(name='LeftTopY'),
        shotTime?: string(name='ShotTime'),
        personId?: string(name='PersonId'),
        leftTopX?: int32(name='LeftTopX'),
        deviceLatitude?: float(name='DeviceLatitude'),
      }
    ](name='MotorList'),
    nonMotorList?: [ 
      {
        deviceID?: string(name='DeviceID'),
        objectType?: string(name='ObjectType'),
        deviceName?: string(name='DeviceName'),
        rightBottomY?: int32(name='RightBottomY'),
        score?: float(name='Score'),
        rightBottomX?: int32(name='RightBottomX'),
        deviceLongitude?: float(name='DeviceLongitude'),
        sourceImageUrl?: string(name='SourceImageUrl'),
        targetImageUrl?: string(name='TargetImageUrl'),
        leftTopY?: int32(name='LeftTopY'),
        shotTime?: string(name='ShotTime'),
        personId?: string(name='PersonId'),
        leftTopX?: int32(name='LeftTopX'),
        deviceLatitude?: float(name='DeviceLatitude'),
      }
    ](name='NonMotorList'),
  }(name='Data'),
  code?: string(name='Code'),
  success?: boolean(name='Success'),
}

model SearchAggregateObjectResponse = {
  headers: map[string]string(name='headers'),
  body: SearchAggregateObjectResponseBody(name='body'),
}

async function searchAggregateObjectWithOptions(request: SearchAggregateObjectRequest, runtime: Util.RuntimeOptions): SearchAggregateObjectResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('SearchAggregateObject', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function searchAggregateObject(request: SearchAggregateObjectRequest): SearchAggregateObjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchAggregateObjectWithOptions(request, runtime);
}

model ListCorpMetricsStatisticRequest {
  corpId?: string(name='CorpId'),
  tagCode?: string(name='TagCode'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  userGroupList?: map[string]any(name='UserGroupList'),
  deviceGroupList?: map[string]any(name='DeviceGroupList'),
  deviceIdList?: map[string]any(name='DeviceIdList'),
  qualitScore?: string(name='QualitScore'),
}

model ListCorpMetricsStatisticShrinkRequest {
  corpId?: string(name='CorpId'),
  tagCode?: string(name='TagCode'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  userGroupListShrink?: string(name='UserGroupList'),
  deviceGroupListShrink?: string(name='DeviceGroupList'),
  deviceIdListShrink?: string(name='DeviceIdList'),
  qualitScore?: string(name='QualitScore'),
}

model ListCorpMetricsStatisticResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: int32(name='PageSize'),
  pageNumber?: int32(name='PageNumber'),
  data?: [ 
    {
      dateId?: string(name='DateId'),
      deviceGroupId?: string(name='DeviceGroupId'),
      deviceId?: string(name='DeviceId'),
      tagCode?: string(name='TagCode'),
      userGroupId?: string(name='UserGroupId'),
      corpId?: string(name='CorpId'),
      tagMetrics?: string(name='TagMetrics'),
      tagValue?: string(name='TagValue'),
      personId?: string(name='PersonId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
  success?: string(name='Success'),
}

model ListCorpMetricsStatisticResponse = {
  headers: map[string]string(name='headers'),
  body: ListCorpMetricsStatisticResponseBody(name='body'),
}

async function listCorpMetricsStatisticWithOptions(tmpReq: ListCorpMetricsStatisticRequest, runtime: Util.RuntimeOptions): ListCorpMetricsStatisticResponse {
  Util.validateModel(tmpReq);
  var request = new ListCorpMetricsStatisticShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.userGroupList)) {
    request.userGroupListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.userGroupList, 'UserGroupList', 'json');
  }
  if (!Util.isUnset(tmpReq.deviceGroupList)) {
    request.deviceGroupListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.deviceGroupList, 'DeviceGroupList', 'json');
  }
  if (!Util.isUnset(tmpReq.deviceIdList)) {
    request.deviceIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.deviceIdList, 'DeviceIdList', 'json');
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCorpMetricsStatistic', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCorpMetricsStatistic(request: ListCorpMetricsStatisticRequest): ListCorpMetricsStatisticResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCorpMetricsStatisticWithOptions(request, runtime);
}

model DetectTrajectoryRegularPatternRequest {
  corpId?: string(name='CorpId'),
  idType?: string(name='IdType'),
  idValue?: string(name='IdValue'),
  predictDate?: string(name='PredictDate'),
}

model DetectTrajectoryRegularPatternResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: int32(name='Code'),
  success?: boolean(name='Success'),
}

model DetectTrajectoryRegularPatternResponse = {
  headers: map[string]string(name='headers'),
  body: DetectTrajectoryRegularPatternResponseBody(name='body'),
}

async function detectTrajectoryRegularPatternWithOptions(request: DetectTrajectoryRegularPatternRequest, runtime: Util.RuntimeOptions): DetectTrajectoryRegularPatternResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DetectTrajectoryRegularPattern', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function detectTrajectoryRegularPattern(request: DetectTrajectoryRegularPatternRequest): DetectTrajectoryRegularPatternResponse {
  var runtime = new Util.RuntimeOptions{};
  return detectTrajectoryRegularPatternWithOptions(request, runtime);
}

model ListVehicleTrackRequest {
  corpId?: string(name='CorpId'),
  plateId?: string(name='PlateId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
}

model ListVehicleTrackResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      sourceUrl?: string(name='SourceUrl'),
      rightBottomY?: string(name='RightBottomY'),
      dataSourceName?: string(name='DataSourceName'),
      picUrlPath?: string(name='PicUrlPath'),
      dataSourceId?: string(name='DataSourceId'),
      rightBottomX?: string(name='RightBottomX'),
      targetPicUrlPath?: string(name='TargetPicUrlPath'),
      plateId?: string(name='PlateId'),
      leftTopY?: string(name='LeftTopY'),
      targetUrl?: string(name='TargetUrl'),
      corpId?: string(name='CorpId'),
      longitude?: string(name='Longitude'),
      latitude?: string(name='Latitude'),
      leftTopX?: string(name='LeftTopX'),
      passTime?: string(name='PassTime'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListVehicleTrackResponse = {
  headers: map[string]string(name='headers'),
  body: ListVehicleTrackResponseBody(name='body'),
}

async function listVehicleTrackWithOptions(request: ListVehicleTrackRequest, runtime: Util.RuntimeOptions): ListVehicleTrackResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListVehicleTrack', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listVehicleTrack(request: ListVehicleTrackRequest): ListVehicleTrackResponse {
  var runtime = new Util.RuntimeOptions{};
  return listVehicleTrackWithOptions(request, runtime);
}

model ListStructureStatisticsRequest {
  corpId?: string(name='CorpId'),
  backCategory?: string(name='BackCategory'),
}

model ListStructureStatisticsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      corpId?: string(name='CorpId'),
      number?: string(name='Number'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListStructureStatisticsResponse = {
  headers: map[string]string(name='headers'),
  body: ListStructureStatisticsResponseBody(name='body'),
}

async function listStructureStatisticsWithOptions(request: ListStructureStatisticsRequest, runtime: Util.RuntimeOptions): ListStructureStatisticsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListStructureStatistics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listStructureStatistics(request: ListStructureStatisticsRequest): ListStructureStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listStructureStatisticsWithOptions(request, runtime);
}

model StopMonitorRequest {
  taskId?: string(name='TaskId'),
  algorithmVendor?: string(name='AlgorithmVendor'),
  corpId?: string(name='CorpId'),
}

model StopMonitorResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: string(name='Code'),
}

model StopMonitorResponse = {
  headers: map[string]string(name='headers'),
  body: StopMonitorResponseBody(name='body'),
}

async function stopMonitorWithOptions(request: StopMonitorRequest, runtime: Util.RuntimeOptions): StopMonitorResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('StopMonitor', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function stopMonitor(request: StopMonitorRequest): StopMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return stopMonitorWithOptions(request, runtime);
}

model PredictTrajectoryDestinationRequest {
  corpId?: string(name='CorpId'),
  idType?: string(name='IdType'),
  idValue?: string(name='IdValue'),
  predictTimeSpan?: int32(name='PredictTimeSpan'),
}

model PredictTrajectoryDestinationResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: int32(name='Code'),
  success?: boolean(name='Success'),
}

model PredictTrajectoryDestinationResponse = {
  headers: map[string]string(name='headers'),
  body: PredictTrajectoryDestinationResponseBody(name='body'),
}

async function predictTrajectoryDestinationWithOptions(request: PredictTrajectoryDestinationRequest, runtime: Util.RuntimeOptions): PredictTrajectoryDestinationResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('PredictTrajectoryDestination', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function predictTrajectoryDestination(request: PredictTrajectoryDestinationRequest): PredictTrajectoryDestinationResponse {
  var runtime = new Util.RuntimeOptions{};
  return predictTrajectoryDestinationWithOptions(request, runtime);
}

model ListRangeDeviceRequest {
  radius?: int32(name='Radius'),
  dataSourceId?: string(name='DataSourceId'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  corpId?: string(name='CorpId'),
}

model ListRangeDeviceResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      dataSourceIdPoi?: string(name='DataSourceIdPoi'),
      distance?: string(name='Distance'),
      dataSourceId?: string(name='DataSourceId'),
      corpId?: string(name='CorpId'),
      longitude?: string(name='Longitude'),
      dataSourceIdName?: string(name='DataSourceIdName'),
      latitude?: string(name='Latitude'),
      nearPoi?: string(name='NearPoi'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListRangeDeviceResponse = {
  headers: map[string]string(name='headers'),
  body: ListRangeDeviceResponseBody(name='body'),
}

async function listRangeDeviceWithOptions(request: ListRangeDeviceRequest, runtime: Util.RuntimeOptions): ListRangeDeviceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListRangeDevice', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listRangeDevice(request: ListRangeDeviceRequest): ListRangeDeviceResponse {
  var runtime = new Util.RuntimeOptions{};
  return listRangeDeviceWithOptions(request, runtime);
}

model ListCityMapRangeStatisticRequest {
  radius?: int32(name='Radius'),
  latitude?: string(name='Latitude'),
  longitude?: string(name='Longitude'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
}

model ListCityMapRangeStatisticResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      adultValue?: string(name='AdultValue'),
      childValue?: string(name='ChildValue'),
      oldValue?: string(name='OldValue'),
      manValue?: string(name='ManValue'),
      dataSourceName?: string(name='DataSourceName'),
      dataSourceId?: string(name='DataSourceId'),
      corpId?: string(name='CorpId'),
      motorValue?: string(name='MotorValue'),
      longitude?: string(name='Longitude'),
      latitude?: string(name='Latitude'),
      womanValue?: string(name='WomanValue'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListCityMapRangeStatisticResponse = {
  headers: map[string]string(name='headers'),
  body: ListCityMapRangeStatisticResponseBody(name='body'),
}

async function listCityMapRangeStatisticWithOptions(request: ListCityMapRangeStatisticRequest, runtime: Util.RuntimeOptions): ListCityMapRangeStatisticResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCityMapRangeStatistic', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCityMapRangeStatistic(request: ListCityMapRangeStatisticRequest): ListCityMapRangeStatisticResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCityMapRangeStatisticWithOptions(request, runtime);
}

model ListStorageStatisticsRequest {
  corpId?: string(name='CorpId'),
}

model ListStorageStatisticsResponseBody = {
  totalCount?: long(name='TotalCount'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      usedStore?: string(name='UsedStore'),
      unusedStore?: string(name='UnusedStore'),
      corpId?: string(name='CorpId'),
      number?: string(name='Number'),
      totalStore?: string(name='TotalStore'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListStorageStatisticsResponse = {
  headers: map[string]string(name='headers'),
  body: ListStorageStatisticsResponseBody(name='body'),
}

async function listStorageStatisticsWithOptions(request: ListStorageStatisticsRequest, runtime: Util.RuntimeOptions): ListStorageStatisticsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListStorageStatistics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listStorageStatistics(request: ListStorageStatisticsRequest): ListStorageStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listStorageStatisticsWithOptions(request, runtime);
}

model PaginateProjectRequest {
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  countTotalNum?: boolean(name='CountTotalNum'),
  type?: string(name='Type'),
  nameLike?: string(name='NameLike'),
}

model PaginateProjectResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: {
    records?: [ 
      {
        type?: string(name='Type'),
        modifiedTime?: string(name='ModifiedTime'),
        description?: string(name='Description'),
        aggregateSceneCode?: string(name='AggregateSceneCode'),
        corpId?: string(name='CorpId'),
        userId?: string(name='UserId'),
        icon?: string(name='Icon'),
        name?: string(name='Name'),
        createdTime?: string(name='CreatedTime'),
      }
    ](name='Records'),
    totalPage?: int32(name='TotalPage'),
    pageNumber?: int32(name='PageNumber'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  code?: string(name='Code'),
}

model PaginateProjectResponse = {
  headers: map[string]string(name='headers'),
  body: PaginateProjectResponseBody(name='body'),
}

async function paginateProjectWithOptions(request: PaginateProjectRequest, runtime: Util.RuntimeOptions): PaginateProjectResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('PaginateProject', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function paginateProject(request: PaginateProjectRequest): PaginateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return paginateProjectWithOptions(request, runtime);
}

model ListCityMapCameraStatisticsRequest {
  endTime?: string(name='EndTime'),
  startTime?: string(name='StartTime'),
  dataSourceIdList?: string(name='DataSourceIdList'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
}

model ListCityMapCameraStatisticsResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      oldValue?: string(name='OldValue'),
      dataSourceName?: string(name='DataSourceName'),
      dataSourceId?: string(name='DataSourceId'),
      statisticTime?: string(name='StatisticTime'),
      adultValue?: string(name='AdultValue'),
      childValue?: string(name='ChildValue'),
      manValue?: string(name='ManValue'),
      corpId?: string(name='CorpId'),
      motorValue?: string(name='MotorValue'),
      longitude?: string(name='Longitude'),
      latitude?: string(name='Latitude'),
      womanValue?: string(name='WomanValue'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListCityMapCameraStatisticsResponse = {
  headers: map[string]string(name='headers'),
  body: ListCityMapCameraStatisticsResponseBody(name='body'),
}

async function listCityMapCameraStatisticsWithOptions(request: ListCityMapCameraStatisticsRequest, runtime: Util.RuntimeOptions): ListCityMapCameraStatisticsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListCityMapCameraStatistics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listCityMapCameraStatistics(request: ListCityMapCameraStatisticsRequest): ListCityMapCameraStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCityMapCameraStatisticsWithOptions(request, runtime);
}

model UpdateCdrsMonitorRequest {
  corpId?: string(name='CorpId'),
  taskId?: string(name='TaskId'),
  ruleName?: string(name='RuleName'),
  deviceOperateType?: string(name='DeviceOperateType'),
  deviceList?: string(name='DeviceList'),
  picOperateType?: string(name='PicOperateType'),
  picList?: string(name='PicList'),
  attributeOperateType?: string(name='AttributeOperateType'),
  attributeName?: string(name='AttributeName'),
  attributeValueList?: string(name='AttributeValueList'),
  description?: string(name='Description'),
  ruleExpression?: string(name='RuleExpression'),
  algorithmVendor?: string(name='AlgorithmVendor'),
  notifierType?: string(name='NotifierType'),
  notifierUrl?: string(name='NotifierUrl'),
  notifierAppSecret?: string(name='NotifierAppSecret'),
  notifierTimeOut?: int32(name='NotifierTimeOut'),
  notifierExtendValues?: string(name='NotifierExtendValues'),
}

model UpdateCdrsMonitorResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: string(name='Data'),
  code?: string(name='Code'),
}

model UpdateCdrsMonitorResponse = {
  headers: map[string]string(name='headers'),
  body: UpdateCdrsMonitorResponseBody(name='body'),
}

async function updateCdrsMonitorWithOptions(request: UpdateCdrsMonitorRequest, runtime: Util.RuntimeOptions): UpdateCdrsMonitorResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateCdrsMonitor', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateCdrsMonitor(request: UpdateCdrsMonitorRequest): UpdateCdrsMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateCdrsMonitorWithOptions(request, runtime);
}

model ListPersonResultRequest {
  corpId?: string(name='CorpId'),
  age?: string(name='Age'),
  gender?: string(name='Gender'),
  profession?: string(name='Profession'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  qualityScore?: string(name='QualityScore'),
}

model ListPersonResultResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      sourceUrl?: string(name='SourceUrl'),
      profession?: string(name='Profession'),
      updateTime?: string(name='UpdateTime'),
      gender?: string(name='Gender'),
      targetUrl?: string(name='TargetUrl'),
      address?: string(name='Address'),
      hotSpotAddress?: string(name='HotSpotAddress'),
      age?: string(name='Age'),
      personId?: string(name='PersonId'),
      personType?: string(name='PersonType'),
      transportation?: string(name='Transportation'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListPersonResultResponse = {
  headers: map[string]string(name='headers'),
  body: ListPersonResultResponseBody(name='body'),
}

async function listPersonResultWithOptions(request: ListPersonResultRequest, runtime: Util.RuntimeOptions): ListPersonResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListPersonResult', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listPersonResult(request: ListPersonResultRequest): ListPersonResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPersonResultWithOptions(request, runtime);
}

model ListTagMetricsRequest {
  corpId?: string(name='CorpId'),
  tagCode?: map[string]any(name='TagCode'),
  aggregateType?: string(name='AggregateType'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: string(name='PageNumber'),
  pageSize?: string(name='PageSize'),
}

model ListTagMetricsShrinkRequest {
  corpId?: string(name='CorpId'),
  tagCodeShrink?: string(name='TagCode'),
  aggregateType?: string(name='AggregateType'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: string(name='PageNumber'),
  pageSize?: string(name='PageSize'),
}

model ListTagMetricsResponseBody = {
  totalCount?: string(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: string(name='PageSize'),
  pageNumber?: string(name='PageNumber'),
  data?: [ 
    {
      tagMetric?: string(name='TagMetric'),
      tagCode?: string(name='TagCode'),
      corpId?: string(name='CorpId'),
      tagValue?: string(name='TagValue'),
      dateTime?: string(name='DateTime'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListTagMetricsResponse = {
  headers: map[string]string(name='headers'),
  body: ListTagMetricsResponseBody(name='body'),
}

async function listTagMetricsWithOptions(tmpReq: ListTagMetricsRequest, runtime: Util.RuntimeOptions): ListTagMetricsResponse {
  Util.validateModel(tmpReq);
  var request = new ListTagMetricsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.tagCode)) {
    request.tagCodeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.tagCode, 'TagCode', 'json');
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListTagMetrics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listTagMetrics(request: ListTagMetricsRequest): ListTagMetricsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listTagMetricsWithOptions(request, runtime);
}

model ListPersonTagRequest {
  corpId?: string(name='CorpId'),
  tagCode?: string(name='TagCode'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
}

model ListPersonTagResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      value?: string(name='Value'),
      corpId?: string(name='CorpId'),
      tagValue?: string(name='TagValue'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListPersonTagResponse = {
  headers: map[string]string(name='headers'),
  body: ListPersonTagResponseBody(name='body'),
}

async function listPersonTagWithOptions(request: ListPersonTagRequest, runtime: Util.RuntimeOptions): ListPersonTagResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListPersonTag', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listPersonTag(request: ListPersonTagRequest): ListPersonTagResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPersonTagWithOptions(request, runtime);
}

model UpdateProjectRequest {
  corpId?: string(name='CorpId'),
  icon?: string(name='Icon'),
  name?: string(name='Name'),
  description?: string(name='Description'),
  aggregateSceneCode?: string(name='AggregateSceneCode'),
}

model UpdateProjectResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  code?: string(name='Code'),
}

model UpdateProjectResponse = {
  headers: map[string]string(name='headers'),
  body: UpdateProjectResponseBody(name='body'),
}

async function updateProjectWithOptions(request: UpdateProjectRequest, runtime: Util.RuntimeOptions): UpdateProjectResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateProject', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateProject(request: UpdateProjectRequest): UpdateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateProjectWithOptions(request, runtime);
}

model ListDevicePersonRequest {
  dataSourceId?: string(name='DataSourceId'),
  statisticsType?: string(name='StatisticsType'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  corpId?: string(name='CorpId'),
}

model ListDevicePersonResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      targetPicUrlPath?: string(name='TargetPicUrlPath'),
      gender?: string(name='Gender'),
      dataSourceId?: string(name='DataSourceId'),
      freqNum?: string(name='FreqNum'),
      personId?: string(name='PersonId'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDevicePersonResponse = {
  headers: map[string]string(name='headers'),
  body: ListDevicePersonResponseBody(name='body'),
}

async function listDevicePersonWithOptions(request: ListDevicePersonRequest, runtime: Util.RuntimeOptions): ListDevicePersonResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDevicePerson', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDevicePerson(request: ListDevicePersonRequest): ListDevicePersonResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDevicePersonWithOptions(request, runtime);
}

model ListDeviceDetailRequest {
  dataSourceId?: string(name='DataSourceId'),
  pageNumber?: long(name='PageNumber'),
  pageSize?: long(name='PageSize'),
  corpId?: string(name='CorpId'),
}

model ListDeviceDetailResponseBody = {
  totalCount?: long(name='TotalCount'),
  requestId?: string(name='RequestId'),
  message?: string(name='Message'),
  pageSize?: long(name='PageSize'),
  pageNumber?: long(name='PageNumber'),
  data?: [ 
    {
      dataSourceName?: string(name='DataSourceName'),
      dataSourceId?: string(name='DataSourceId'),
      corpId?: string(name='CorpId'),
      longitude?: string(name='Longitude'),
      latitude?: string(name='Latitude'),
      dataSourcePoi?: string(name='DataSourcePoi'),
      nearPoi?: string(name='NearPoi'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDeviceDetailResponse = {
  headers: map[string]string(name='headers'),
  body: ListDeviceDetailResponseBody(name='body'),
}

async function listDeviceDetailWithOptions(request: ListDeviceDetailRequest, runtime: Util.RuntimeOptions): ListDeviceDetailResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDeviceDetail', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDeviceDetail(request: ListDeviceDetailRequest): ListDeviceDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDeviceDetailWithOptions(request, runtime);
}

model ListDeviceGenderStatisticsRequest {
  dataSourceId?: string(name='DataSourceId'),
  startTime?: string(name='StartTime'),
  endTime?: string(name='EndTime'),
  corpId?: string(name='CorpId'),
}

model ListDeviceGenderStatisticsResponseBody = {
  totalCount?: long(name='TotalCount'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      gender?: string(name='Gender'),
      dataSourceId?: string(name='DataSourceId'),
      number?: string(name='Number'),
    }
  ](name='Data'),
  code?: string(name='Code'),
}

model ListDeviceGenderStatisticsResponse = {
  headers: map[string]string(name='headers'),
  body: ListDeviceGenderStatisticsResponseBody(name='body'),
}

async function listDeviceGenderStatisticsWithOptions(request: ListDeviceGenderStatisticsRequest, runtime: Util.RuntimeOptions): ListDeviceGenderStatisticsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ListDeviceGenderStatistics', '2020-11-01', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function listDeviceGenderStatistics(request: ListDeviceGenderStatisticsRequest): ListDeviceGenderStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDeviceGenderStatisticsWithOptions(request, runtime);
}