tdsr-20200101/main.tea

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

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'regional';
  @endpointMap = {
    'cn-hangzhou' = 'lyj.cn-hangzhou.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('tdsr', @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 AddHotspotFileRequest {
  fileName?: string(name='FileName', description='This parameter is required.'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1'),
  type?: string(name='Type', description='This parameter is required.'),
}

model AddHotspotFileResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AddHotspotFileResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddHotspotFileResponseBody(name='body'),
}

/**
 * @summary 保存模型文件
 *
 * @param request AddHotspotFileRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddHotspotFileResponse
 */
async function addHotspotFileWithOptions(request: AddHotspotFileRequest, runtime: Util.RuntimeOptions): AddHotspotFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fileName)) {
    query['FileName'] = request.fileName;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddHotspotFile',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 保存模型文件
 *
 * @param request AddHotspotFileRequest
 * @return AddHotspotFileResponse
 */
async function addHotspotFile(request: AddHotspotFileRequest): AddHotspotFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return addHotspotFileWithOptions(request, runtime);
}

model AddMosaicsRequest {
  markPosition?: string(name='MarkPosition', description='This parameter is required.', example='[{"x": 504,"y": 450,"w": 256,"h": 153}]'),
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='skjjskjk****'),
}

model AddMosaicsResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='SUCCESS'),
  requestId?: string(name='RequestId', example='3BCAD49D-2AC1-13EB-AC19-8C7A46C****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='OvFuuwhfoAX8uIpxC/GJ****'),
}

model AddMosaicsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddMosaicsResponseBody(name='body'),
}

/**
 * @summary 打马赛克
 *
 * @param request AddMosaicsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddMosaicsResponse
 */
async function addMosaicsWithOptions(request: AddMosaicsRequest, runtime: Util.RuntimeOptions): AddMosaicsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.markPosition)) {
    query['MarkPosition'] = request.markPosition;
  }
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddMosaics',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 打马赛克
 *
 * @param request AddMosaicsRequest
 * @return AddMosaicsResponse
 */
async function addMosaics(request: AddMosaicsRequest): AddMosaicsResponse {
  var runtime = new Util.RuntimeOptions{};
  return addMosaicsWithOptions(request, runtime);
}

model AddProjectRequest {
  businessId?: long(name='BusinessId', example='5432****'),
  name?: string(name='Name', description='This parameter is required.'),
}

model AddProjectResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  id?: string(name='Id', example='1234****'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='344794c32937474a9c59eb130936****'),
  success?: boolean(name='Success', example='true'),
}

model AddProjectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddProjectResponseBody(name='body'),
}

/**
 * @summary 添加项目
 *
 * @param request AddProjectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddProjectResponse
 */
async function addProjectWithOptions(request: AddProjectRequest, runtime: Util.RuntimeOptions): AddProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessId)) {
    query['BusinessId'] = request.businessId;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddProject',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 添加项目
 *
 * @param request AddProjectRequest
 * @return AddProjectResponse
 */
async function addProject(request: AddProjectRequest): AddProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return addProjectWithOptions(request, runtime);
}

model AddRelativePositionRequest {
  relativePosition?: string(name='RelativePosition', description='This parameter is required.', example='{"key"："value"}'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1234****'),
}

model AddRelativePositionResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model AddRelativePositionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddRelativePositionResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI AddRelativePosition is deprecated
 *
 * @summary 添加相对位置
 *
 * @param request AddRelativePositionRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddRelativePositionResponse
 */
// Deprecated
async function addRelativePositionWithOptions(request: AddRelativePositionRequest, runtime: Util.RuntimeOptions): AddRelativePositionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.relativePosition)) {
    query['RelativePosition'] = request.relativePosition;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddRelativePosition',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @deprecated OpenAPI AddRelativePosition is deprecated
 *
 * @summary 添加相对位置
 *
 * @param request AddRelativePositionRequest
 * @return AddRelativePositionResponse
 */
// Deprecated
async function addRelativePosition(request: AddRelativePositionRequest): AddRelativePositionResponse {
  var runtime = new Util.RuntimeOptions{};
  return addRelativePositionWithOptions(request, runtime);
}

model AddRoomPlanRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1234****'),
}

model AddRoomPlanResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    accessId?: string(name='AccessId', example='LTAI5t9kjkiudsnsu****'),
    callback?: string(name='Callback', example='""'),
    dir?: string(name='Dir', example='123/'),
    expire?: string(name='Expire', example='1640315897'),
    host?: string(name='Host', example='oss.aliyun.com'),
    policy?: string(name='Policy', example='eyJleHBpcmF0aW9uIjoiMjAy****'),
    signature?: string(name='Signature', example='ngEWGzttc3v2gJWCxEEt****'),
  }(name='Data'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model AddRoomPlanResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddRoomPlanResponseBody(name='body'),
}

/**
 * @summary 移动端添加rooms.json
 *
 * @param request AddRoomPlanRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddRoomPlanResponse
 */
async function addRoomPlanWithOptions(request: AddRoomPlanRequest, runtime: Util.RuntimeOptions): AddRoomPlanResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddRoomPlan',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 移动端添加rooms.json
 *
 * @param request AddRoomPlanRequest
 * @return AddRoomPlanResponse
 */
async function addRoomPlan(request: AddRoomPlanRequest): AddRoomPlanResponse {
  var runtime = new Util.RuntimeOptions{};
  return addRoomPlanWithOptions(request, runtime);
}

model AddSceneRequest {
  customerUid?: string(name='CustomerUid', example='2345****'),
  name?: string(name='Name', description='This parameter is required.', example='测试名称'),
  projectId?: string(name='ProjectId', description='This parameter is required.', example='1234****'),
  type?: string(name='Type', description='This parameter is required.', example='MODEL_3D'),
}

model AddSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  id?: string(name='Id', example='2345****'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

model AddSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddSceneResponseBody(name='body'),
}

/**
 * @summary 添加主场景
 *
 * @param request AddSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddSceneResponse
 */
async function addSceneWithOptions(request: AddSceneRequest, runtime: Util.RuntimeOptions): AddSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.customerUid)) {
    query['CustomerUid'] = request.customerUid;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 添加主场景
 *
 * @param request AddSceneRequest
 * @return AddSceneResponse
 */
async function addScene(request: AddSceneRequest): AddSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return addSceneWithOptions(request, runtime);
}

model AddSubSceneRequest {
  name?: string(name='Name', description='This parameter is required.', example='测试'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1234****'),
  uploadType?: string(name='UploadType', example='IMAGE'),
}

model AddSubSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  id?: string(name='Id', example='234****'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model AddSubSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddSubSceneResponseBody(name='body'),
}

/**
 * @summary 创建子场景
 *
 * @param request AddSubSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddSubSceneResponse
 */
async function addSubSceneWithOptions(request: AddSubSceneRequest, runtime: Util.RuntimeOptions): AddSubSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.uploadType)) {
    query['UploadType'] = request.uploadType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddSubScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 创建子场景
 *
 * @param request AddSubSceneRequest
 * @return AddSubSceneResponse
 */
async function addSubScene(request: AddSubSceneRequest): AddSubSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return addSubSceneWithOptions(request, runtime);
}

model CheckUserPropertyRequest {
  uid?: string(name='Uid', description='This parameter is required.', example='2345****'),
}

model CheckUserPropertyResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  match?: boolean(name='Match', example='true'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='344794c32937474a9c59eb1309366493'),
  success?: boolean(name='Success', example='true'),
}

model CheckUserPropertyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CheckUserPropertyResponseBody(name='body'),
}

/**
 * @summary 检查指定uid用户属性
 *
 * @param request CheckUserPropertyRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CheckUserPropertyResponse
 */
async function checkUserPropertyWithOptions(request: CheckUserPropertyRequest, runtime: Util.RuntimeOptions): CheckUserPropertyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CheckUserProperty',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 检查指定uid用户属性
 *
 * @param request CheckUserPropertyRequest
 * @return CheckUserPropertyResponse
 */
async function checkUserProperty(request: CheckUserPropertyRequest): CheckUserPropertyResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkUserPropertyWithOptions(request, runtime);
}

model CopySceneRequest {
  projectId?: string(name='ProjectId', example='opwuoieywtyqw****'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='sgyuyewyew****'),
  sceneName?: string(name='SceneName', description='This parameter is required.'),
}

model CopySceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    taskId?: string(name='TaskId', example='yuywey****'),
  }(name='Data'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

model CopySceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CopySceneResponseBody(name='body'),
}

/**
 * @summary 复制主场景
 *
 * @param request CopySceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CopySceneResponse
 */
async function copySceneWithOptions(request: CopySceneRequest, runtime: Util.RuntimeOptions): CopySceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.sceneName)) {
    query['SceneName'] = request.sceneName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CopyScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 复制主场景
 *
 * @param request CopySceneRequest
 * @return CopySceneResponse
 */
async function copyScene(request: CopySceneRequest): CopySceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return copySceneWithOptions(request, runtime);
}

model CreateUploadPolicyRequest {
  option?: string(name='Option', description='This parameter is required.', example='{}'),
  type?: string(name='Type', description='This parameter is required.', example='scene'),
}

model CreateUploadPolicyResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    accessId?: string(name='AccessId', description='accessId', example='LTAI5t9k9****'),
    callback?: string(name='Callback', example='""'),
    dir?: string(name='Dir', example='dir/'),
    expire?: string(name='Expire', example='1658812297'),
    host?: string(name='Host', example='oss.aliyun.com'),
    policy?: string(name='Policy', example='eyJleHBpcmF0aW9uIjoiMj****'),
    signature?: string(name='Signature', example='KdnPJFIG25SM****'),
  }(name='Data'),
  message?: string(name='Message', example='SUCCESS'),
  requestId?: string(name='RequestId', example='B28A2ECB-AB29-1E01****'),
  success?: boolean(name='Success', example='true'),
}

model CreateUploadPolicyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateUploadPolicyResponseBody(name='body'),
}

/**
 * @summary 获取OSS授权
 *
 * @param request CreateUploadPolicyRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateUploadPolicyResponse
 */
async function createUploadPolicyWithOptions(request: CreateUploadPolicyRequest, runtime: Util.RuntimeOptions): CreateUploadPolicyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.option)) {
    query['Option'] = request.option;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateUploadPolicy',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 获取OSS授权
 *
 * @param request CreateUploadPolicyRequest
 * @return CreateUploadPolicyResponse
 */
async function createUploadPolicy(request: CreateUploadPolicyRequest): CreateUploadPolicyResponse {
  var runtime = new Util.RuntimeOptions{};
  return createUploadPolicyWithOptions(request, runtime);
}

model DetailProjectRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234****'),
}

model DetailProjectResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  businessId?: long(name='BusinessId', example='5244****'),
  businessName?: string(name='BusinessName'),
  code?: long(name='Code', example='200'),
  gmtCreate?: long(name='GmtCreate', example='1621236933677'),
  gmtModified?: long(name='GmtModified', example='1621236933677'),
  id?: string(name='Id', example='1234****'),
  message?: string(name='Message', example='success'),
  name?: string(name='Name'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
  token?: string(name='Token', description='Token', example='d989623696ab4f87a80b8d5b0b00****'),
}

model DetailProjectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DetailProjectResponseBody(name='body'),
}

/**
 * @summary 查询项目详情
 *
 * @param request DetailProjectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DetailProjectResponse
 */
async function detailProjectWithOptions(request: DetailProjectRequest, runtime: Util.RuntimeOptions): DetailProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DetailProject',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询项目详情
 *
 * @param request DetailProjectRequest
 * @return DetailProjectResponse
 */
async function detailProject(request: DetailProjectRequest): DetailProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return detailProjectWithOptions(request, runtime);
}

model DetailSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234***'),
}

model DetailSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  captures?: [ 
    {
      title?: string(name='Title'),
      url?: string(name='Url', example='http://www.aliyun.com/test1.jpg'),
    }
  ](name='Captures'),
  code?: long(name='Code', example='200'),
  coverUrl?: string(name='CoverUrl', example='www.example.com/xxx/xxx.jpg'),
  floorPlans?: [ 
    {
      colorMapUrl?: string(name='ColorMapUrl'),
      floorLabel?: string(name='FloorLabel'),
      floorName?: string(name='FloorName'),
      miniMapUrl?: string(name='MiniMapUrl'),
    }
  ](name='FloorPlans'),
  gmtCreate?: long(name='GmtCreate', example='1621236933677'),
  gmtModified?: long(name='GmtModified', example='1621236933677'),
  id?: string(name='Id', example='1234***'),
  message?: string(name='Message', example='success'),
  name?: string(name='Name', example='测试'),
  previewToken?: string(name='PreviewToken', example='d989623696ab4f87a80b8d5b0b0****'),
  published?: boolean(name='Published', example='false'),
  requestId?: string(name='RequestId', example='344794c32937474a9c59eb130936****'),
  sourceNum?: long(name='SourceNum', example='20'),
  status?: string(name='Status', example='init'),
  statusName?: string(name='StatusName'),
  subSceneNum?: long(name='SubSceneNum', example='20'),
  success?: boolean(name='Success', example='true'),
  type?: string(name='Type', example='MODEL_3D'),
}

model DetailSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DetailSceneResponseBody(name='body'),
}

/**
 * @summary 主场景详细
 *
 * @param request DetailSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DetailSceneResponse
 */
async function detailSceneWithOptions(request: DetailSceneRequest, runtime: Util.RuntimeOptions): DetailSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DetailScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 主场景详细
 *
 * @param request DetailSceneRequest
 * @return DetailSceneResponse
 */
async function detailScene(request: DetailSceneRequest): DetailSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return detailSceneWithOptions(request, runtime);
}

model DetailSubSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='F79siXLsJsVVca8Yp4fgPA=='),
}

model DetailSubSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  coverUrl?: string(name='CoverUrl', example='https://image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
  cubemapPath?: string(name='CubemapPath', example='https://image-demo.oss-cn-hangzhou.aliyuncs.com/cubemap/****'),
  gmtCreate?: long(name='GmtCreate', example='1621236933677'),
  gmtModified?: long(name='GmtModified', example='1621236933677'),
  id?: string(name='Id', example='1234***'),
  imageUrl?: string(name='ImageUrl', example='http://www.aliyun.com/test1.jpg'),
  layoutData?: string(name='LayoutData', example='{}'),
  message?: string(name='Message', example='success'),
  name?: string(name='Name', example='测试'),
  originUrl?: string(name='OriginUrl', example='http://www.aliyun.com/test.jpg'),
  position?: string(name='Position', example='[-0.8928,-0.21467,0.39603]'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  resourceId?: string(name='ResourceId', example='1234***'),
  status?: long(name='Status', example='1'),
  success?: boolean(name='Success', example='true'),
  type?: string(name='Type', example='IMAGE'),
  url?: string(name='Url', example='https://image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
}

model DetailSubSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DetailSubSceneResponseBody(name='body'),
}

/**
 * @summary 查询子场景详情
 *
 * @param request DetailSubSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DetailSubSceneResponse
 */
async function detailSubSceneWithOptions(request: DetailSubSceneRequest, runtime: Util.RuntimeOptions): DetailSubSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DetailSubScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询子场景详情
 *
 * @param request DetailSubSceneRequest
 * @return DetailSubSceneResponse
 */
async function detailSubScene(request: DetailSubSceneRequest): DetailSubSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return detailSubSceneWithOptions(request, runtime);
}

model DropProjectRequest {
  projectId?: string(name='ProjectId', description='This parameter is required.', example='3242****'),
}

model DropProjectResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

model DropProjectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DropProjectResponseBody(name='body'),
}

/**
 * @summary 删除项目
 *
 * @param request DropProjectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DropProjectResponse
 */
async function dropProjectWithOptions(request: DropProjectRequest, runtime: Util.RuntimeOptions): DropProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DropProject',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除项目
 *
 * @param request DropProjectRequest
 * @return DropProjectResponse
 */
async function dropProject(request: DropProjectRequest): DropProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return dropProjectWithOptions(request, runtime);
}

model DropSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234***'),
}

model DropSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model DropSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DropSceneResponseBody(name='body'),
}

/**
 * @summary 删除主场景
 *
 * @param request DropSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DropSceneResponse
 */
async function dropSceneWithOptions(request: DropSceneRequest, runtime: Util.RuntimeOptions): DropSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DropScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除主场景
 *
 * @param request DropSceneRequest
 * @return DropSceneResponse
 */
async function dropScene(request: DropSceneRequest): DropSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return dropSceneWithOptions(request, runtime);
}

model DropSubSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234****'),
}

model DropSubSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model DropSubSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DropSubSceneResponseBody(name='body'),
}

/**
 * @summary 删除子场景
 *
 * @param request DropSubSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DropSubSceneResponse
 */
async function dropSubSceneWithOptions(request: DropSubSceneRequest, runtime: Util.RuntimeOptions): DropSubSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DropSubScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除子场景
 *
 * @param request DropSubSceneRequest
 * @return DropSubSceneResponse
 */
async function dropSubScene(request: DropSubSceneRequest): DropSubSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return dropSubSceneWithOptions(request, runtime);
}

model GetConnDataRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1234****'),
}

model GetConnDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  extend?: string(name='Extend', example='{}'),
  list?: [ 
    {
      id?: string(name='Id', description='ID', example='1#234#abc'),
      mapId?: string(name='MapId', example='1#456#def'),
      type?: string(name='Type', example='outer'),
    }
  ](name='List'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', description='Id of the request', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  version?: string(name='Version', example='2.1'),
}

model GetConnDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetConnDataResponseBody(name='body'),
}

/**
 * @summary 查询关联数据
 *
 * @param request GetConnDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetConnDataResponse
 */
async function getConnDataWithOptions(request: GetConnDataRequest, runtime: Util.RuntimeOptions): GetConnDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetConnData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询关联数据
 *
 * @param request GetConnDataRequest
 * @return GetConnDataResponse
 */
async function getConnData(request: GetConnDataRequest): GetConnDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getConnDataWithOptions(request, runtime);
}

model GetCopySceneTaskStatusRequest {
  taskId?: string(name='TaskId', description='This parameter is required.', example='yuywey****'),
}

model GetCopySceneTaskStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    progress?: long(name='Progress', example='100'),
    status?: string(name='Status', example='succeed'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', example='A8CD0AD9-8A92-455A-A984-A7E4****'),
  success?: boolean(name='Success', example='true'),
}

model GetCopySceneTaskStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetCopySceneTaskStatusResponseBody(name='body'),
}

/**
 * @summary 复制场景任务状态查询
 *
 * @param request GetCopySceneTaskStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetCopySceneTaskStatusResponse
 */
async function getCopySceneTaskStatusWithOptions(request: GetCopySceneTaskStatusRequest, runtime: Util.RuntimeOptions): GetCopySceneTaskStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCopySceneTaskStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 复制场景任务状态查询
 *
 * @param request GetCopySceneTaskStatusRequest
 * @return GetCopySceneTaskStatusResponse
 */
async function getCopySceneTaskStatus(request: GetCopySceneTaskStatusRequest): GetCopySceneTaskStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCopySceneTaskStatusWithOptions(request, runtime);
}

model GetHotspotConfigRequest {
  domain?: string(name='Domain', example='www.aliyundoc.com'),
  enabled?: boolean(name='Enabled', example='true/false'),
  previewToken?: string(name='PreviewToken', description='This parameter is required.', example='344794c32937474a9c59eb130936****'),
  type?: long(name='Type', description='This parameter is required.', example='0'),
}

model GetHotspotConfigResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: string(name='Data', example='config'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

model GetHotspotConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetHotspotConfigResponseBody(name='body'),
}

/**
 * @param request GetHotspotConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetHotspotConfigResponse
 */
async function getHotspotConfigWithOptions(request: GetHotspotConfigRequest, runtime: Util.RuntimeOptions): GetHotspotConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.enabled)) {
    query['Enabled'] = request.enabled;
  }
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotspotConfig',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @param request GetHotspotConfigRequest
 * @return GetHotspotConfigResponse
 */
async function getHotspotConfig(request: GetHotspotConfigRequest): GetHotspotConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotspotConfigWithOptions(request, runtime);
}

model GetHotspotSceneDataRequest {
  domain?: string(name='Domain', example='www.aliyundoc.com'),
  enabled?: boolean(name='Enabled', example='true'),
  previewToken?: string(name='PreviewToken', description='This parameter is required.', example='344794c32937474a9c59eb130936****'),
  type?: long(name='Type', description='This parameter is required.', example='0'),
}

model GetHotspotSceneDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    modelToken?: string(name='ModelToken', example='A.e.QRQRLWYEHIUE****'),
    previewData?: string(name='PreviewData'),
    previewToken?: string(name='PreviewToken', example='344794c32937474a9c59eb130936****'),
    sceneType?: string(name='SceneType', example='MODEL_3D'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', description='Id of the request', example='A8CD0AD9-8A92-455A-A984-A7E4B76****'),
  success?: boolean(name='Success', example='true/false'),
}

model GetHotspotSceneDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetHotspotSceneDataResponseBody(name='body'),
}

/**
 * @summary 查询后处理场景信息
 *
 * @param request GetHotspotSceneDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetHotspotSceneDataResponse
 */
async function getHotspotSceneDataWithOptions(request: GetHotspotSceneDataRequest, runtime: Util.RuntimeOptions): GetHotspotSceneDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.enabled)) {
    query['Enabled'] = request.enabled;
  }
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotspotSceneData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询后处理场景信息
 *
 * @param request GetHotspotSceneDataRequest
 * @return GetHotspotSceneDataResponse
 */
async function getHotspotSceneData(request: GetHotspotSceneDataRequest): GetHotspotSceneDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotspotSceneDataWithOptions(request, runtime);
}

model GetHotspotTagRequest {
  domain?: string(name='Domain', example='www.aliyundoc.com'),
  enabled?: boolean(name='Enabled', example='true/false'),
  previewToken?: string(name='PreviewToken', example='344794c32937474a9c59eb130936****'),
  subSceneUuid?: string(name='SubSceneUuid', example='123456'),
  type?: string(name='Type', example='1'),
}

model GetHotspotTagResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  data?: string(name='Data', example='{"watermarkImg":[],"enabledTitleTag":0}'),
  errMessage?: string(name='ErrMessage', example='success'),
  objectString?: string(name='ObjectString', example='"{}"'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

model GetHotspotTagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetHotspotTagResponseBody(name='body'),
}

/**
 * @param request GetHotspotTagRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetHotspotTagResponse
 */
async function getHotspotTagWithOptions(request: GetHotspotTagRequest, runtime: Util.RuntimeOptions): GetHotspotTagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.enabled)) {
    query['Enabled'] = request.enabled;
  }
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  if (!Util.isUnset(request.subSceneUuid)) {
    query['SubSceneUuid'] = request.subSceneUuid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotspotTag',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @param request GetHotspotTagRequest
 * @return GetHotspotTagResponse
 */
async function getHotspotTag(request: GetHotspotTagRequest): GetHotspotTagResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotspotTagWithOptions(request, runtime);
}

model GetLayoutDataRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model GetLayoutDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: string(name='Data', example='{}'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model GetLayoutDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetLayoutDataResponseBody(name='body'),
}

/**
 * @summary 获取标注数据
 *
 * @param request GetLayoutDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetLayoutDataResponse
 */
async function getLayoutDataWithOptions(request: GetLayoutDataRequest, runtime: Util.RuntimeOptions): GetLayoutDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLayoutData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 获取标注数据
 *
 * @param request GetLayoutDataRequest
 * @return GetLayoutDataResponse
 */
async function getLayoutData(request: GetLayoutDataRequest): GetLayoutDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLayoutDataWithOptions(request, runtime);
}

model GetOriginLayoutDataRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model GetOriginLayoutDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: string(name='Data', example='{}'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model GetOriginLayoutDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetOriginLayoutDataResponseBody(name='body'),
}

/**
 * @summary 获取算法自动标注数据
 *
 * @param request GetOriginLayoutDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetOriginLayoutDataResponse
 */
async function getOriginLayoutDataWithOptions(request: GetOriginLayoutDataRequest, runtime: Util.RuntimeOptions): GetOriginLayoutDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOriginLayoutData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 获取算法自动标注数据
 *
 * @param request GetOriginLayoutDataRequest
 * @return GetOriginLayoutDataResponse
 */
async function getOriginLayoutData(request: GetOriginLayoutDataRequest): GetOriginLayoutDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOriginLayoutDataWithOptions(request, runtime);
}

model GetOssPolicyRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model GetOssPolicyResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  accessId?: string(name='AccessId', example='abc'),
  callback?: string(name='Callback', example='""'),
  code?: long(name='Code', example='200'),
  dir?: string(name='Dir', example='123/'),
  expire?: string(name='Expire', example='60'),
  host?: string(name='Host', example='oss.aliyun.com'),
  message?: string(name='Message', example='success'),
  policy?: string(name='Policy', example='def'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  signature?: string(name='Signature', example='ghi'),
  success?: boolean(name='Success', example='true'),
}

model GetOssPolicyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetOssPolicyResponseBody(name='body'),
}

/**
 * @summary 获取OSS授权
 *
 * @param request GetOssPolicyRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetOssPolicyResponse
 */
async function getOssPolicyWithOptions(request: GetOssPolicyRequest, runtime: Util.RuntimeOptions): GetOssPolicyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOssPolicy',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 获取OSS授权
 *
 * @param request GetOssPolicyRequest
 * @return GetOssPolicyResponse
 */
async function getOssPolicy(request: GetOssPolicyRequest): GetOssPolicyResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOssPolicyWithOptions(request, runtime);
}

model GetPackSceneTaskStatusRequest {
  taskId?: string(name='TaskId', description='This parameter is required.', example='hjsyuyiuwe7wehg****'),
  type?: string(name='Type', description='This parameter is required.', example='download'),
}

model GetPackSceneTaskStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    progress?: long(name='Progress', example='100'),
    status?: string(name='Status', example='succeed'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', example='A8CD0AD9-8A92-455A-A984-A7E4B****'),
  success?: boolean(name='Success', example='true'),
}

model GetPackSceneTaskStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPackSceneTaskStatusResponseBody(name='body'),
}

/**
 * @summary 打包场景任务状态查询
 *
 * @param request GetPackSceneTaskStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetPackSceneTaskStatusResponse
 */
async function getPackSceneTaskStatusWithOptions(request: GetPackSceneTaskStatusRequest, runtime: Util.RuntimeOptions): GetPackSceneTaskStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPackSceneTaskStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 打包场景任务状态查询
 *
 * @param request GetPackSceneTaskStatusRequest
 * @return GetPackSceneTaskStatusResponse
 */
async function getPackSceneTaskStatus(request: GetPackSceneTaskStatusRequest): GetPackSceneTaskStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPackSceneTaskStatusWithOptions(request, runtime);
}

model GetRectifyImageRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model GetRectifyImageResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  url?: string(name='Url', example='https://image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
}

model GetRectifyImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRectifyImageResponseBody(name='body'),
}

/**
 * @summary 查询矫正后图片
 *
 * @param request GetRectifyImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRectifyImageResponse
 */
async function getRectifyImageWithOptions(request: GetRectifyImageRequest, runtime: Util.RuntimeOptions): GetRectifyImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRectifyImage',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询矫正后图片
 *
 * @param request GetRectifyImageRequest
 * @return GetRectifyImageResponse
 */
async function getRectifyImage(request: GetRectifyImageRequest): GetRectifyImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRectifyImageWithOptions(request, runtime);
}

model GetSceneBuildTaskStatusRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='m+0cmndEGjg9pv/hy4jh****'),
}

model GetSceneBuildTaskStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  errorCode?: string(name='ErrorCode', example='2001'),
  errorMsg?: string(name='ErrorMsg', example='xx'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  sceneId?: string(name='SceneId', example='m+0cmndEGjg9pv/hy4jh****'),
  status?: string(name='Status', example='failed'),
  success?: boolean(name='Success', example='true'),
}

model GetSceneBuildTaskStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSceneBuildTaskStatusResponseBody(name='body'),
}

/**
 * @summary 查看场景下重建任务
 *
 * @param request GetSceneBuildTaskStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetSceneBuildTaskStatusResponse
 */
async function getSceneBuildTaskStatusWithOptions(request: GetSceneBuildTaskStatusRequest, runtime: Util.RuntimeOptions): GetSceneBuildTaskStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSceneBuildTaskStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查看场景下重建任务
 *
 * @param request GetSceneBuildTaskStatusRequest
 * @return GetSceneBuildTaskStatusResponse
 */
async function getSceneBuildTaskStatus(request: GetSceneBuildTaskStatusRequest): GetSceneBuildTaskStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSceneBuildTaskStatusWithOptions(request, runtime);
}

model GetScenePackUrlRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='L2omaCMmQZZkEg4p****'),
}

model GetScenePackUrlResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    expire?: string(name='Expire', example='2022-05-17 11:00:17'),
    url?: string(name='Url'),
    valid?: boolean(name='Valid', example='true'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', example='A8CD0AD9-8A92-455A-A984-A7E4B76****'),
  success?: boolean(name='Success', example='true'),
}

model GetScenePackUrlResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenePackUrlResponseBody(name='body'),
}

/**
 * @summary 获取场景的打包地址
 *
 * @param request GetScenePackUrlRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetScenePackUrlResponse
 */
async function getScenePackUrlWithOptions(request: GetScenePackUrlRequest, runtime: Util.RuntimeOptions): GetScenePackUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenePackUrl',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 获取场景的打包地址
 *
 * @param request GetScenePackUrlRequest
 * @return GetScenePackUrlResponse
 */
async function getScenePackUrl(request: GetScenePackUrlRequest): GetScenePackUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenePackUrlWithOptions(request, runtime);
}

model GetScenePreviewDataRequest {
  domain?: string(name='Domain', example='www.example.com'),
  enabled?: boolean(name='Enabled', example='true/false'),
  previewToken?: string(name='PreviewToken', description='This parameter is required.', example='2735913e96da44ea8c86f8e777c8****'),
  showTag?: boolean(name='ShowTag', example='true/false'),
}

model GetScenePreviewDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='0：成功，其他：失败'),
  data?: {
    model?: {
      modelPath?: string(name='ModelPath'),
      panoList?: [ 
        {
          curRoomPicList?: [ string ](name='CurRoomPicList'),
          enabled?: boolean(name='Enabled', example='true/false'),
          floorIdx?: string(name='FloorIdx', example='1****'),
          id?: string(name='Id', example='1****'),
          mainImage?: boolean(name='MainImage', example='true/false'),
          neighbours?: [ string ](name='Neighbours'),
          position?: {
            rotation?: [ double ](name='Rotation'),
            spot?: [ double ](name='Spot'),
            viewpoint?: [ double ](name='Viewpoint'),
          }(name='Position'),
          rawName?: string(name='RawName', example='location_93132801658010****'),
          resource?: string(name='Resource'),
          roomIdx?: string(name='RoomIdx', example='1****'),
          subSceneId?: string(name='SubSceneId', example='a7RqCd3kLMgglmn****'),
          token?: string(name='Token', description='token', example='sIPGWRGLJHEIQE****'),
          virtualId?: string(name='VirtualId', example='93132801658010****'),
          virtualName?: string(name='VirtualName'),
        }
      ](name='PanoList'),
      textureModelPath?: string(name='TextureModelPath'),
      texturePanoPath?: string(name='TexturePanoPath'),
    }(name='Model'),
    tags?: [ 
      {
        config?: {
          backgroundColor?: string(name='BackgroundColor', example='#00000'),
          buttonConfig?: {
            customText?: string(name='CustomText'),
            type?: string(name='Type', example='CLICK_CHECK'),
          }(name='ButtonConfig'),
          content?: string(name='Content'),
          formImgSize?: [ long ](name='FormImgSize'),
          formJumpType?: boolean(name='FormJumpType', example='true/false'),
          formSelectImgType?: string(name='FormSelectImgType', example='default'),
          images?: [ string ](name='Images'),
          isTagVisibleBy3d?: boolean(name='IsTagVisibleBy3d', example='true/false'),
          link?: string(name='Link', example='http://www.example.com/***'),
          panoId?: string(name='PanoId', example='1****'),
          position?: [ double ](name='Position'),
          positionPanoCube?: [ double ](name='PositionPanoCube'),
          relatedPanoIds?: [ string ](name='RelatedPanoIds'),
          sceneId?: long(name='SceneId', example='323****'),
          title?: string(name='Title'),
          video?: string(name='Video', example='http://www.example.com/****.mp4'),
        }(name='Config'),
        id?: string(name='Id', example='1****'),
        position?: [ double ](name='Position'),
        positionPanoCube?: [ double ](name='PositionPanoCube'),
        type?: string(name='Type', example='IMAGE'),
      }
    ](name='Tags'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', description='Id of the request', example='A8CD0AD9-8A92-455A-A984-A7E4B76FF387'),
  success?: boolean(name='Success', example='true/false'),
}

model GetScenePreviewDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenePreviewDataResponseBody(name='body'),
}

/**
 * @summary 查询模型数据
 *
 * @param request GetScenePreviewDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetScenePreviewDataResponse
 */
async function getScenePreviewDataWithOptions(request: GetScenePreviewDataRequest, runtime: Util.RuntimeOptions): GetScenePreviewDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.enabled)) {
    query['Enabled'] = request.enabled;
  }
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  if (!Util.isUnset(request.showTag)) {
    query['ShowTag'] = request.showTag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenePreviewData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询模型数据
 *
 * @param request GetScenePreviewDataRequest
 * @return GetScenePreviewDataResponse
 */
async function getScenePreviewData(request: GetScenePreviewDataRequest): GetScenePreviewDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenePreviewDataWithOptions(request, runtime);
}

model GetScenePreviewInfoRequest {
  domain?: string(name='Domain', example='www.aliyundoc.com'),
  enabled?: boolean(name='Enabled', example='true'),
  modelToken?: string(name='ModelToken', description='This parameter is required.', example='A.e.RQJRPYGIJJQP****'),
}

model GetScenePreviewInfoResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='0：成功，其他：失败'),
  data?: {
    modelPath?: string(name='ModelPath', example='https://www.aliyundoc.com/sgm/A.e.QRQRLWYEHIUEYLYW/A.e.QRQRLWYEHIUEYLYW****.sgm'),
    panoList?: string(name='PanoList'),
    textureModelPath?: string(name='TextureModelPath'),
    texturePanoPath?: string(name='TexturePanoPath'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', description='Id of the request', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true/false'),
}

model GetScenePreviewInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenePreviewInfoResponseBody(name='body'),
}

/**
 * @summary 查询模型预览信息
 *
 * @param request GetScenePreviewInfoRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetScenePreviewInfoResponse
 */
async function getScenePreviewInfoWithOptions(request: GetScenePreviewInfoRequest, runtime: Util.RuntimeOptions): GetScenePreviewInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.enabled)) {
    query['Enabled'] = request.enabled;
  }
  if (!Util.isUnset(request.modelToken)) {
    query['ModelToken'] = request.modelToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenePreviewInfo',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询模型预览信息
 *
 * @param request GetScenePreviewInfoRequest
 * @return GetScenePreviewInfoResponse
 */
async function getScenePreviewInfo(request: GetScenePreviewInfoRequest): GetScenePreviewInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenePreviewInfoWithOptions(request, runtime);
}

model GetScenePreviewResourceRequest {
  draft?: boolean(name='Draft', example='false'),
  previewToken?: string(name='PreviewToken', description='This parameter is required.', example='2deb941b3e1****'),
}

model GetScenePreviewResourceResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='0：成功，其他：失败'),
  data?: {
    name?: string(name='Name'),
    resourceDirectory?: {
      hotspotTagConfig?: string(name='HotspotTagConfig', example='hotspotTag.json'),
      modelConfig?: string(name='ModelConfig', example='config.json'),
      orthomapConfig?: string(name='OrthomapConfig', example='orthomap/orthomap.json'),
      rootPath?: string(name='RootPath', example='A.e.YKPYuuYuituy****'),
    }(name='ResourceDirectory'),
    version?: string(name='Version', example='1.0'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', description='Id of the request', example='A8CD0AD9-8A92-455A-A984-A7E4B76*****'),
  success?: boolean(name='Success', example='true/false'),
}

model GetScenePreviewResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenePreviewResourceResponseBody(name='body'),
}

/**
 * @summary 获取模型预览数据
 *
 * @param request GetScenePreviewResourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetScenePreviewResourceResponse
 */
async function getScenePreviewResourceWithOptions(request: GetScenePreviewResourceRequest, runtime: Util.RuntimeOptions): GetScenePreviewResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.draft)) {
    query['Draft'] = request.draft;
  }
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenePreviewResource',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 获取模型预览数据
 *
 * @param request GetScenePreviewResourceRequest
 * @return GetScenePreviewResourceResponse
 */
async function getScenePreviewResource(request: GetScenePreviewResourceRequest): GetScenePreviewResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenePreviewResourceWithOptions(request, runtime);
}

model GetSingleConnDataRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model GetSingleConnDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  list?: [ 
    {
      id?: string(name='Id', description='ID', example='1#234@abc'),
      mapId?: string(name='MapId', example='1#567#def'),
      type?: string(name='Type', example='outer'),
    }
  ](name='List'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  version?: string(name='Version', example='2.1'),
}

model GetSingleConnDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSingleConnDataResponseBody(name='body'),
}

/**
 * @summary 查询单场景关联数据
 *
 * @param request GetSingleConnDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetSingleConnDataResponse
 */
async function getSingleConnDataWithOptions(request: GetSingleConnDataRequest, runtime: Util.RuntimeOptions): GetSingleConnDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSingleConnData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单场景关联数据
 *
 * @param request GetSingleConnDataRequest
 * @return GetSingleConnDataResponse
 */
async function getSingleConnData(request: GetSingleConnDataRequest): GetSingleConnDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSingleConnDataWithOptions(request, runtime);
}

model GetSourcePackStatusRequest {
  taskId?: string(name='TaskId', description='This parameter is required.', example='hjsyuyiuwe7wehg****'),
}

model GetSourcePackStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    progress?: long(name='Progress', example='100'),
    status?: string(name='Status', example='succeed'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', example='A8CD0AD9-8A92-455A-A984-A7E4B76****'),
  success?: boolean(name='Success', example='true'),
  url?: string(name='Url'),
}

model GetSourcePackStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSourcePackStatusResponseBody(name='body'),
}

/**
 * @summary 打包58数据状态检查
 *
 * @param request GetSourcePackStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetSourcePackStatusResponse
 */
async function getSourcePackStatusWithOptions(request: GetSourcePackStatusRequest, runtime: Util.RuntimeOptions): GetSourcePackStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSourcePackStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 打包58数据状态检查
 *
 * @param request GetSourcePackStatusRequest
 * @return GetSourcePackStatusResponse
 */
async function getSourcePackStatus(request: GetSourcePackStatusRequest): GetSourcePackStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSourcePackStatusWithOptions(request, runtime);
}

model GetSubSceneTaskStatusRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model GetSubSceneTaskStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  list?: [ 
    {
      errorCode?: string(name='ErrorCode', example='2001'),
      errorMsg?: string(name='ErrorMsg', example='xx'),
      id?: string(name='Id', example='4638****'),
      sceneId?: string(name='SceneId', example='2345****'),
      status?: string(name='Status', example='init'),
      subSceneId?: string(name='SubSceneId', example='3456***'),
      type?: string(name='Type', example='cutimage'),
    }
  ](name='List'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model GetSubSceneTaskStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSubSceneTaskStatusResponseBody(name='body'),
}

/**
 * @summary 查看子场景下预处理及切图任务
 *
 * @param request GetSubSceneTaskStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetSubSceneTaskStatusResponse
 */
async function getSubSceneTaskStatusWithOptions(request: GetSubSceneTaskStatusRequest, runtime: Util.RuntimeOptions): GetSubSceneTaskStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSubSceneTaskStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查看子场景下预处理及切图任务
 *
 * @param request GetSubSceneTaskStatusRequest
 * @return GetSubSceneTaskStatusResponse
 */
async function getSubSceneTaskStatus(request: GetSubSceneTaskStatusRequest): GetSubSceneTaskStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSubSceneTaskStatusWithOptions(request, runtime);
}

model GetTaskStatusRequest {
  taskId?: string(name='TaskId', description='This parameter is required.', example='1234****'),
}

model GetTaskStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  errorCode?: string(name='ErrorCode', example='2001'),
  errorMsg?: string(name='ErrorMsg', example='xxx'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  status?: string(name='Status', example='init'),
  success?: boolean(name='Success', example='true'),
  type?: string(name='Type', example='wallline'),
}

model GetTaskStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetTaskStatusResponseBody(name='body'),
}

/**
 * @summary 查看任务状态
 *
 * @param request GetTaskStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetTaskStatusResponse
 */
async function getTaskStatusWithOptions(request: GetTaskStatusRequest, runtime: Util.RuntimeOptions): GetTaskStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTaskStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查看任务状态
 *
 * @param request GetTaskStatusRequest
 * @return GetTaskStatusResponse
 */
async function getTaskStatus(request: GetTaskStatusRequest): GetTaskStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTaskStatusWithOptions(request, runtime);
}

model GetWindowConfigRequest {
  previewToken?: string(name='PreviewToken', example='5dc5c2dd927e45039dadb312384b****'),
}

model GetWindowConfigResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  data?: map[string]any(name='Data', example='2345****'),
  errMessage?: string(name='ErrMessage'),
  objectString?: string(name='ObjectString', example='"{}"'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='success'),
}

model GetWindowConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetWindowConfigResponseBody(name='body'),
}

/**
 * @param request GetWindowConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetWindowConfigResponse
 */
async function getWindowConfigWithOptions(request: GetWindowConfigRequest, runtime: Util.RuntimeOptions): GetWindowConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetWindowConfig',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @param request GetWindowConfigRequest
 * @return GetWindowConfigResponse
 */
async function getWindowConfig(request: GetWindowConfigRequest): GetWindowConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getWindowConfigWithOptions(request, runtime);
}

model LabelBuildRequest {
  mode?: string(name='Mode'),
  modelStyle?: string(name='ModelStyle', example='PATCH'),
  optimizeWallWidth?: string(name='OptimizeWallWidth', example='OFF'),
  planStyle?: string(name='PlanStyle', example='DEFAULT'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1234****'),
  wallHeight?: long(name='WallHeight', example='0'),
}

model LabelBuildResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='234****'),
}

model LabelBuildResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: LabelBuildResponseBody(name='body'),
}

/**
 * @summary 重建
 *
 * @param request LabelBuildRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return LabelBuildResponse
 */
async function labelBuildWithOptions(request: LabelBuildRequest, runtime: Util.RuntimeOptions): LabelBuildResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.mode)) {
    query['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modelStyle)) {
    query['ModelStyle'] = request.modelStyle;
  }
  if (!Util.isUnset(request.optimizeWallWidth)) {
    query['OptimizeWallWidth'] = request.optimizeWallWidth;
  }
  if (!Util.isUnset(request.planStyle)) {
    query['PlanStyle'] = request.planStyle;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.wallHeight)) {
    query['WallHeight'] = request.wallHeight;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'LabelBuild',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 重建
 *
 * @param request LabelBuildRequest
 * @return LabelBuildResponse
 */
async function labelBuild(request: LabelBuildRequest): LabelBuildResponse {
  var runtime = new Util.RuntimeOptions{};
  return labelBuildWithOptions(request, runtime);
}

model LinkImageRequest {
  cameraHeight?: int32(name='CameraHeight', example='160'),
  fileName?: string(name='FileName', description='This parameter is required.', example='****.jpg'),
  platform?: string(name='Platform', example='PC'),
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model LinkImageResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  resourceId?: string(name='ResourceId', example='234****'),
  success?: boolean(name='Success', example='true'),
}

model LinkImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: LinkImageResponseBody(name='body'),
}

/**
 * @summary 关联图片
 *
 * @param request LinkImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return LinkImageResponse
 */
async function linkImageWithOptions(request: LinkImageRequest, runtime: Util.RuntimeOptions): LinkImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.cameraHeight)) {
    query['CameraHeight'] = request.cameraHeight;
  }
  if (!Util.isUnset(request.fileName)) {
    query['FileName'] = request.fileName;
  }
  if (!Util.isUnset(request.platform)) {
    query['Platform'] = request.platform;
  }
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'LinkImage',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 关联图片
 *
 * @param request LinkImageRequest
 * @return LinkImageResponse
 */
async function linkImage(request: LinkImageRequest): LinkImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return linkImageWithOptions(request, runtime);
}

model ListProjectRequest {
  name?: string(name='Name'),
  pageNum?: long(name='PageNum', description='This parameter is required.', example='1'),
  pageSize?: long(name='PageSize', description='This parameter is required.', example='20'),
}

model ListProjectResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  count?: long(name='Count', description='count', example='100'),
  currentPage?: long(name='CurrentPage', example='1'),
  hasNext?: boolean(name='HasNext', example='true'),
  list?: [ 
    {
      businessId?: long(name='BusinessId', example='5244****'),
      businessName?: string(name='BusinessName'),
      createTime?: long(name='CreateTime', example='123123'),
      id?: string(name='Id', example='1234****'),
      modifiedTime?: long(name='ModifiedTime', example='123214'),
      name?: string(name='Name'),
      token?: string(name='Token', description='Token', example='d989623696ab4f87a80b8d5b0b0****'),
    }
  ](name='List'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
  totalPage?: long(name='TotalPage', example='5'),
}

model ListProjectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListProjectResponseBody(name='body'),
}

/**
 * @summary 分页查询项目列表
 *
 * @param request ListProjectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListProjectResponse
 */
async function listProjectWithOptions(request: ListProjectRequest, runtime: Util.RuntimeOptions): ListProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListProject',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 分页查询项目列表
 *
 * @param request ListProjectRequest
 * @return ListProjectResponse
 */
async function listProject(request: ListProjectRequest): ListProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectWithOptions(request, runtime);
}

model ListSceneRequest {
  name?: string(name='Name', example='厨房'),
  pageNum?: long(name='PageNum', description='This parameter is required.', example='1'),
  pageSize?: long(name='PageSize', description='This parameter is required.', example='20'),
  projectId?: string(name='ProjectId', description='This parameter is required.', example='1234****'),
}

model ListSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  count?: long(name='Count', example='100'),
  currentPage?: long(name='CurrentPage', example='1'),
  hasNext?: boolean(name='HasNext', example='true'),
  list?: [ 
    {
      coverUrl?: string(name='CoverUrl', example='www.example.com/xxxx/xxx.jpg'),
      gmtCreate?: long(name='GmtCreate', example='1621236933677'),
      gmtModified?: long(name='GmtModified', example='1621236933677'),
      id?: string(name='Id', example='1234****'),
      name?: string(name='Name', example='厨房'),
      previewToken?: string(name='PreviewToken', example='d989623696ab4f87a80b8d5b0b00****'),
      published?: boolean(name='Published', example='false'),
      sourceNum?: long(name='SourceNum', example='20'),
      status?: string(name='Status', example='init'),
      statusName?: string(name='StatusName'),
      subSceneNum?: long(name='SubSceneNum', example='20'),
      type?: string(name='Type', example='MODEL_3D'),
    }
  ](name='List'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
  totalPage?: long(name='TotalPage', example='5'),
}

model ListSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSceneResponseBody(name='body'),
}

/**
 * @summary 分页查询主场景列表
 *
 * @param request ListSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListSceneResponse
 */
async function listSceneWithOptions(request: ListSceneRequest, runtime: Util.RuntimeOptions): ListSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 分页查询主场景列表
 *
 * @param request ListSceneRequest
 * @return ListSceneResponse
 */
async function listScene(request: ListSceneRequest): ListSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSceneWithOptions(request, runtime);
}

model ListSubSceneRequest {
  pageNum?: long(name='PageNum', description='This parameter is required.', example='1'),
  pageSize?: long(name='PageSize', description='This parameter is required.', example='20'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='L2omaCMmQZZkEg4pE****'),
  showLayoutData?: boolean(name='ShowLayoutData', example='true'),
  sortField?: string(name='SortField', example='NAME'),
}

model ListSubSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  count?: long(name='Count', example='100'),
  currentPage?: long(name='CurrentPage', example='1'),
  hasNext?: boolean(name='HasNext', example='true'),
  list?: [ 
    {
      baseImageUrl?: string(name='BaseImageUrl', example='https:/image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
      coverUrl?: string(name='CoverUrl', example='https:/image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
      cubemapPath?: string(name='CubemapPath'),
      deleted?: boolean(name='Deleted', example='true'),
      gmtCreate?: long(name='GmtCreate', example='1621236933677'),
      gmtModified?: long(name='GmtModified', example='1621236933677'),
      id?: string(name='Id', example='xsfwsddd=='),
      layoutData?: string(name='LayoutData', example='{}'),
      name?: string(name='Name', example='c俄式'),
      originUrl?: string(name='OriginUrl', example='https:/image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
      resourceId?: string(name='ResourceId', example='2345****'),
      resourceName?: string(name='ResourceName', example='xxxx.jpg'),
      status?: long(name='Status', example='1'),
      type?: string(name='Type', example='IMAGE'),
      url?: string(name='Url', example='https:/image-demo.oss-cn-hangzhou.aliyuncs.com/****.jpg'),
    }
  ](name='List'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  totalPage?: long(name='TotalPage', example='5'),
}

model ListSubSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSubSceneResponseBody(name='body'),
}

/**
 * @summary 查询子场景列表
 *
 * @param request ListSubSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListSubSceneResponse
 */
async function listSubSceneWithOptions(request: ListSubSceneRequest, runtime: Util.RuntimeOptions): ListSubSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.showLayoutData)) {
    query['ShowLayoutData'] = request.showLayoutData;
  }
  if (!Util.isUnset(request.sortField)) {
    query['SortField'] = request.sortField;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSubScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询子场景列表
 *
 * @param request ListSubSceneRequest
 * @return ListSubSceneResponse
 */
async function listSubScene(request: ListSubSceneRequest): ListSubSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSubSceneWithOptions(request, runtime);
}

model OptimizeRightAngleRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model OptimizeRightAngleResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='2345****'),
}

model OptimizeRightAngleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: OptimizeRightAngleResponseBody(name='body'),
}

/**
 * @summary 直角优化
 *
 * @param request OptimizeRightAngleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return OptimizeRightAngleResponse
 */
async function optimizeRightAngleWithOptions(request: OptimizeRightAngleRequest, runtime: Util.RuntimeOptions): OptimizeRightAngleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OptimizeRightAngle',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 直角优化
 *
 * @param request OptimizeRightAngleRequest
 * @return OptimizeRightAngleResponse
 */
async function optimizeRightAngle(request: OptimizeRightAngleRequest): OptimizeRightAngleResponse {
  var runtime = new Util.RuntimeOptions{};
  return optimizeRightAngleWithOptions(request, runtime);
}

model PackSceneRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='L2omaCMmQZZkEg4p****'),
  type?: string(name='Type', description='This parameter is required.', example='download'),
}

model PackSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    taskId?: string(name='TaskId', example='hjsyuyiuwe7wehg****'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', example='A8CD0AD9-8A92-455A-A984-A7E4B76****'),
  success?: boolean(name='Success', example='true'),
}

model PackSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PackSceneResponseBody(name='body'),
}

/**
 * @summary 打包场景
 *
 * @param request PackSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PackSceneResponse
 */
async function packSceneWithOptions(request: PackSceneRequest, runtime: Util.RuntimeOptions): PackSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PackScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 打包场景
 *
 * @param request PackSceneRequest
 * @return PackSceneResponse
 */
async function packScene(request: PackSceneRequest): PackSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return packSceneWithOptions(request, runtime);
}

model PackSourceRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='L2omaCMmQZZkEg4p****'),
}

model PackSourceResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  data?: {
    taskId?: string(name='TaskId', example='hjsyuyiuwe7wehg****'),
  }(name='Data'),
  message?: string(name='Message', example='xxxxx'),
  requestId?: string(name='RequestId', example='A8CD0AD9-8A92-455A-A984-A7E4B76F****'),
  success?: boolean(name='Success', example='true'),
}

model PackSourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PackSourceResponseBody(name='body'),
}

/**
 * @summary 打包场景
 *
 * @param request PackSourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PackSourceResponse
 */
async function packSourceWithOptions(request: PackSourceRequest, runtime: Util.RuntimeOptions): PackSourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PackSource',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 打包场景
 *
 * @param request PackSourceRequest
 * @return PackSourceResponse
 */
async function packSource(request: PackSourceRequest): PackSourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return packSourceWithOptions(request, runtime);
}

model PredImageRequest {
  correctVertical?: boolean(name='CorrectVertical', description='This parameter is required.', example='true'),
  countDetectDoor?: long(name='CountDetectDoor', example='2'),
  detectDoor?: boolean(name='DetectDoor', description='This parameter is required.', example='true'),
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='2345****'),
}

model PredImageResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='1234****'),
}

model PredImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PredImageResponseBody(name='body'),
}

/**
 * @summary 预处理
 *
 * @param request PredImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PredImageResponse
 */
async function predImageWithOptions(request: PredImageRequest, runtime: Util.RuntimeOptions): PredImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.correctVertical)) {
    query['CorrectVertical'] = request.correctVertical;
  }
  if (!Util.isUnset(request.countDetectDoor)) {
    query['CountDetectDoor'] = request.countDetectDoor;
  }
  if (!Util.isUnset(request.detectDoor)) {
    query['DetectDoor'] = request.detectDoor;
  }
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PredImage',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 预处理
 *
 * @param request PredImageRequest
 * @return PredImageResponse
 */
async function predImage(request: PredImageRequest): PredImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return predImageWithOptions(request, runtime);
}

model PredictionWallLineRequest {
  cameraHeight?: long(name='CameraHeight', example='160'),
  url?: string(name='Url', description='This parameter is required.', example='https://www.aliyundoc.com/****.jpg'),
}

model PredictionWallLineResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  subSceneId?: string(name='SubSceneId', example='2345****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='1234****'),
}

model PredictionWallLineResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PredictionWallLineResponseBody(name='body'),
}

/**
 * @summary 墙线预测
 *
 * @param request PredictionWallLineRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PredictionWallLineResponse
 */
async function predictionWallLineWithOptions(request: PredictionWallLineRequest, runtime: Util.RuntimeOptions): PredictionWallLineResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.cameraHeight)) {
    query['CameraHeight'] = request.cameraHeight;
  }
  if (!Util.isUnset(request.url)) {
    query['Url'] = request.url;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PredictionWallLine',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 墙线预测
 *
 * @param request PredictionWallLineRequest
 * @return PredictionWallLineResponse
 */
async function predictionWallLine(request: PredictionWallLineRequest): PredictionWallLineResponse {
  var runtime = new Util.RuntimeOptions{};
  return predictionWallLineWithOptions(request, runtime);
}

model PublishHotspotRequest {
  paramTag?: string(name='ParamTag'),
  subSceneUuid?: string(name='SubSceneUuid', example='2345****'),
}

model PublishHotspotResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  data?: map[string]any(name='Data', example='2345****'),
  errMessage?: string(name='ErrMessage'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='success'),
}

model PublishHotspotResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PublishHotspotResponseBody(name='body'),
}

/**
 * @param request PublishHotspotRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PublishHotspotResponse
 */
async function publishHotspotWithOptions(request: PublishHotspotRequest, runtime: Util.RuntimeOptions): PublishHotspotResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.paramTag)) {
    query['ParamTag'] = request.paramTag;
  }
  if (!Util.isUnset(request.subSceneUuid)) {
    query['SubSceneUuid'] = request.subSceneUuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PublishHotspot',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @param request PublishHotspotRequest
 * @return PublishHotspotResponse
 */
async function publishHotspot(request: PublishHotspotRequest): PublishHotspotResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishHotspotWithOptions(request, runtime);
}

model PublishHotspotConfigRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='rteyauiiuw****'),
}

model PublishHotspotConfigResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='B28A2ECB-AB29-1E01****'),
  success?: boolean(name='Success', example='true'),
}

model PublishHotspotConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PublishHotspotConfigResponseBody(name='body'),
}

/**
 * @summary 保存扩展配置
 *
 * @param request PublishHotspotConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PublishHotspotConfigResponse
 */
async function publishHotspotConfigWithOptions(request: PublishHotspotConfigRequest, runtime: Util.RuntimeOptions): PublishHotspotConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PublishHotspotConfig',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 保存扩展配置
 *
 * @param request PublishHotspotConfigRequest
 * @return PublishHotspotConfigResponse
 */
async function publishHotspotConfig(request: PublishHotspotConfigRequest): PublishHotspotConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishHotspotConfigWithOptions(request, runtime);
}

model PublishSceneRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='m+0cmndEGjg9pv/hy4jh****'),
}

model PublishSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  previewUrl?: string(name='PreviewUrl', example='preview-lyj.aliyuncs.com/preview/xxx****'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model PublishSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PublishSceneResponseBody(name='body'),
}

/**
 * @summary 发布
 *
 * @param request PublishSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PublishSceneResponse
 */
async function publishSceneWithOptions(request: PublishSceneRequest, runtime: Util.RuntimeOptions): PublishSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PublishScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 发布
 *
 * @param request PublishSceneRequest
 * @return PublishSceneResponse
 */
async function publishScene(request: PublishSceneRequest): PublishSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishSceneWithOptions(request, runtime);
}

model PublishStatusRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='m+0cmndEGjg9pv/hy4jh****'),
}

model PublishStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='344794c32937474a9c59eb130936****'),
  status?: string(name='Status', example='succeed'),
  success?: boolean(name='Success', example='true'),
  syncStatus?: string(name='SyncStatus', example='succeed'),
}

model PublishStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PublishStatusResponseBody(name='body'),
}

/**
 * @summary 发布
 *
 * @param request PublishStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PublishStatusResponse
 */
async function publishStatusWithOptions(request: PublishStatusRequest, runtime: Util.RuntimeOptions): PublishStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PublishStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 发布
 *
 * @param request PublishStatusRequest
 * @return PublishStatusResponse
 */
async function publishStatus(request: PublishStatusRequest): PublishStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishStatusWithOptions(request, runtime);
}

model RecoveryOriginImageRequest {
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='skjjskjk****'),
}

model RecoveryOriginImageResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='SUCCESS'),
  requestId?: string(name='RequestId', example='3BCAD49D-2AC1-13EB-AC19-8C7A46CF****'),
  success?: boolean(name='Success', example='true'),
}

model RecoveryOriginImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RecoveryOriginImageResponseBody(name='body'),
}

/**
 * @summary 恢复原图
 *
 * @param request RecoveryOriginImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RecoveryOriginImageResponse
 */
async function recoveryOriginImageWithOptions(request: RecoveryOriginImageRequest, runtime: Util.RuntimeOptions): RecoveryOriginImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RecoveryOriginImage',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 恢复原图
 *
 * @param request RecoveryOriginImageRequest
 * @return RecoveryOriginImageResponse
 */
async function recoveryOriginImage(request: RecoveryOriginImageRequest): RecoveryOriginImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return recoveryOriginImageWithOptions(request, runtime);
}

model RectVerticalRequest {
  countDetectDoor?: int32(name='CountDetectDoor', example='2'),
  detectDoor?: boolean(name='DetectDoor', example='true'),
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
  verticalRect?: string(name='VerticalRect', description='This parameter is required.', example='{"844946777965268992":[[0.42418407210144654,0.33625107620738004,0.42620819117478337,0.635753199572695],[0.5158627587152769,0.3071978991900134,0.5177513758740194,0.6312118011104786],[0.582693212445534,0.3733969265933281,0.5807612760319687,0.6139402811250833]]}'),
}

model RectVerticalResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='syuwoiewyieiyy****'),
}

model RectVerticalResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RectVerticalResponseBody(name='body'),
}

/**
 * @summary 手动矫正
 *
 * @param request RectVerticalRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RectVerticalResponse
 */
async function rectVerticalWithOptions(request: RectVerticalRequest, runtime: Util.RuntimeOptions): RectVerticalResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.countDetectDoor)) {
    query['CountDetectDoor'] = request.countDetectDoor;
  }
  if (!Util.isUnset(request.detectDoor)) {
    query['DetectDoor'] = request.detectDoor;
  }
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  if (!Util.isUnset(request.verticalRect)) {
    query['VerticalRect'] = request.verticalRect;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RectVertical',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 手动矫正
 *
 * @param request RectVerticalRequest
 * @return RectVerticalResponse
 */
async function rectVertical(request: RectVerticalRequest): RectVerticalResponse {
  var runtime = new Util.RuntimeOptions{};
  return rectVerticalWithOptions(request, runtime);
}

model RectifyImageRequest {
  cameraHeight?: long(name='CameraHeight', example='160'),
  url?: string(name='Url', description='This parameter is required.', example='https://www.aliyundoc.com/****.jpg'),
}

model RectifyImageResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  subSceneId?: string(name='SubSceneId', example='2345****'),
  success?: boolean(name='Success', example='true'),
  taskId?: string(name='TaskId', example='1234****'),
}

model RectifyImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RectifyImageResponseBody(name='body'),
}

/**
 * @summary 图片矫正
 *
 * @param request RectifyImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RectifyImageResponse
 */
async function rectifyImageWithOptions(request: RectifyImageRequest, runtime: Util.RuntimeOptions): RectifyImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.cameraHeight)) {
    query['CameraHeight'] = request.cameraHeight;
  }
  if (!Util.isUnset(request.url)) {
    query['Url'] = request.url;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RectifyImage',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 图片矫正
 *
 * @param request RectifyImageRequest
 * @return RectifyImageResponse
 */
async function rectifyImage(request: RectifyImageRequest): RectifyImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return rectifyImageWithOptions(request, runtime);
}

model RollbackSubSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='skjjskjk****'),
}

model RollbackSubSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='sucess'),
  requestId?: string(name='RequestId', example='3BCAD49D-2AC1-13EB-AC19-8C7A46CF****'),
  success?: boolean(name='Success', example='true'),
}

model RollbackSubSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RollbackSubSceneResponseBody(name='body'),
}

/**
 * @summary 恢复子场景
 *
 * @param request RollbackSubSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RollbackSubSceneResponse
 */
async function rollbackSubSceneWithOptions(request: RollbackSubSceneRequest, runtime: Util.RuntimeOptions): RollbackSubSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RollbackSubScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 恢复子场景
 *
 * @param request RollbackSubSceneRequest
 * @return RollbackSubSceneResponse
 */
async function rollbackSubScene(request: RollbackSubSceneRequest): RollbackSubSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return rollbackSubSceneWithOptions(request, runtime);
}

model SaveHotspotConfigRequest {
  paramTag?: string(name='ParamTag', example='{enabledTitleTag: 0, watermarkImg: []}'),
  previewToken?: string(name='PreviewToken', example='5dc5c2dd927e45039dadb312384b****'),
}

model SaveHotspotConfigResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  errMessage?: string(name='ErrMessage'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='success'),
}

model SaveHotspotConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SaveHotspotConfigResponseBody(name='body'),
}

/**
 * @param request SaveHotspotConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SaveHotspotConfigResponse
 */
async function saveHotspotConfigWithOptions(request: SaveHotspotConfigRequest, runtime: Util.RuntimeOptions): SaveHotspotConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.paramTag)) {
    query['ParamTag'] = request.paramTag;
  }
  if (!Util.isUnset(request.previewToken)) {
    query['PreviewToken'] = request.previewToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveHotspotConfig',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @param request SaveHotspotConfigRequest
 * @return SaveHotspotConfigResponse
 */
async function saveHotspotConfig(request: SaveHotspotConfigRequest): SaveHotspotConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveHotspotConfigWithOptions(request, runtime);
}

model SaveHotspotTagRequest {
  paramTag?: string(name='ParamTag'),
  subSceneUuid?: string(name='SubSceneUuid', example='2345****'),
}

model SaveHotspotTagResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  errMessage?: string(name='ErrMessage'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='success'),
}

model SaveHotspotTagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SaveHotspotTagResponseBody(name='body'),
}

/**
 * @param request SaveHotspotTagRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SaveHotspotTagResponse
 */
async function saveHotspotTagWithOptions(request: SaveHotspotTagRequest, runtime: Util.RuntimeOptions): SaveHotspotTagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.paramTag)) {
    query['ParamTag'] = request.paramTag;
  }
  if (!Util.isUnset(request.subSceneUuid)) {
    query['SubSceneUuid'] = request.subSceneUuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveHotspotTag',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @param request SaveHotspotTagRequest
 * @return SaveHotspotTagResponse
 */
async function saveHotspotTag(request: SaveHotspotTagRequest): SaveHotspotTagResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveHotspotTagWithOptions(request, runtime);
}

model SaveHotspotTagListRequest {
  hotspotListJson?: string(name='HotspotListJson', description='This parameter is required.', example='[{}]'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='tqwiuwetwet****'),
}

model SaveHotspotTagListResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='B28A2ECB-AB29-1E01****'),
  success?: boolean(name='Success', example='true'),
}

model SaveHotspotTagListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SaveHotspotTagListResponseBody(name='body'),
}

/**
 * @summary 保存热点
 *
 * @param request SaveHotspotTagListRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SaveHotspotTagListResponse
 */
async function saveHotspotTagListWithOptions(request: SaveHotspotTagListRequest, runtime: Util.RuntimeOptions): SaveHotspotTagListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.hotspotListJson)) {
    query['HotspotListJson'] = request.hotspotListJson;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveHotspotTagList',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 保存热点
 *
 * @param request SaveHotspotTagListRequest
 * @return SaveHotspotTagListResponse
 */
async function saveHotspotTagList(request: SaveHotspotTagListRequest): SaveHotspotTagListResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveHotspotTagListWithOptions(request, runtime);
}

model SaveMinimapRequest {
  data?: string(name='Data', description='This parameter is required.', example='1'),
  sceneId?: string(name='SceneId', description='This parameter is required.'),
}

model SaveMinimapResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SaveMinimapResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SaveMinimapResponseBody(name='body'),
}

/**
 * @summary 保存小地图数据
 *
 * @param request SaveMinimapRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SaveMinimapResponse
 */
async function saveMinimapWithOptions(request: SaveMinimapRequest, runtime: Util.RuntimeOptions): SaveMinimapResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.data)) {
    query['Data'] = request.data;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveMinimap',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 保存小地图数据
 *
 * @param request SaveMinimapRequest
 * @return SaveMinimapResponse
 */
async function saveMinimap(request: SaveMinimapRequest): SaveMinimapResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveMinimapWithOptions(request, runtime);
}

model SaveModelConfigRequest {
  data?: string(name='Data', description='This parameter is required.', example='{}'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='iyweyteyue****'),
}

model SaveModelConfigResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='SUCCESS'),
  requestId?: string(name='RequestId', example='B28A2ECB-AB29-1E01****'),
  success?: boolean(name='Success', example='true'),
}

model SaveModelConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SaveModelConfigResponseBody(name='body'),
}

/**
 * @summary 保存模型文件
 *
 * @param request SaveModelConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SaveModelConfigResponse
 */
async function saveModelConfigWithOptions(request: SaveModelConfigRequest, runtime: Util.RuntimeOptions): SaveModelConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.data)) {
    query['Data'] = request.data;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveModelConfig',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 保存模型文件
 *
 * @param request SaveModelConfigRequest
 * @return SaveModelConfigResponse
 */
async function saveModelConfig(request: SaveModelConfigRequest): SaveModelConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveModelConfigWithOptions(request, runtime);
}

model ScenePublishRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1'),
}

model ScenePublishResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  previewUrl?: string(name='PreviewUrl', example='https://lyj.aliyun.com/xxx'),
  requestId?: string(name='RequestId', example='344794c32937474a9c59eb1309366493'),
  success?: boolean(name='Success', example='true'),
}

model ScenePublishResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ScenePublishResponseBody(name='body'),
}

/**
 * @summary 发布
 *
 * @param request ScenePublishRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ScenePublishResponse
 */
async function scenePublishWithOptions(request: ScenePublishRequest, runtime: Util.RuntimeOptions): ScenePublishResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ScenePublish',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 发布
 *
 * @param request ScenePublishRequest
 * @return ScenePublishResponse
 */
async function scenePublish(request: ScenePublishRequest): ScenePublishResponse {
  var runtime = new Util.RuntimeOptions{};
  return scenePublishWithOptions(request, runtime);
}

model TempPreviewRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='m+0cmndEGjg9pv/hy4jh****'),
}

model TempPreviewResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  previewUrl?: string(name='PreviewUrl', example='https://preview-lyj.aliyuncs.com/preview/temp/xxx****'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  sceneId?: string(name='SceneId', example='m+0cmndEGjg9pv/hy4jh****'),
  success?: boolean(name='Success', example='true'),
}

model TempPreviewResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: TempPreviewResponseBody(name='body'),
}

/**
 * @summary 预览
 *
 * @param request TempPreviewRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return TempPreviewResponse
 */
async function tempPreviewWithOptions(request: TempPreviewRequest, runtime: Util.RuntimeOptions): TempPreviewResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'TempPreview',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 预览
 *
 * @param request TempPreviewRequest
 * @return TempPreviewResponse
 */
async function tempPreview(request: TempPreviewRequest): TempPreviewResponse {
  var runtime = new Util.RuntimeOptions{};
  return tempPreviewWithOptions(request, runtime);
}

model TempPreviewStatusRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='m+0cmndEGjg9pv/hy4jh****'),
}

model TempPreviewStatusResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  status?: string(name='Status', example='processing'),
  success?: boolean(name='Success', example='true'),
}

model TempPreviewStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: TempPreviewStatusResponseBody(name='body'),
}

/**
 * @summary 查询预览任务处理状态
 *
 * @param request TempPreviewStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return TempPreviewStatusResponse
 */
async function tempPreviewStatusWithOptions(request: TempPreviewStatusRequest, runtime: Util.RuntimeOptions): TempPreviewStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'TempPreviewStatus',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询预览任务处理状态
 *
 * @param request TempPreviewStatusRequest
 * @return TempPreviewStatusResponse
 */
async function tempPreviewStatus(request: TempPreviewStatusRequest): TempPreviewStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return tempPreviewStatusWithOptions(request, runtime);
}

model UpdateConnDataRequest {
  connData?: string(name='ConnData', description='This parameter is required.', example='{}'),
  sceneId?: string(name='SceneId', description='This parameter is required.', example='1234****'),
}

model UpdateConnDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model UpdateConnDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateConnDataResponseBody(name='body'),
}

/**
 * @summary 更新关联数据
 *
 * @param request UpdateConnDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateConnDataResponse
 */
async function updateConnDataWithOptions(request: UpdateConnDataRequest, runtime: Util.RuntimeOptions): UpdateConnDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.connData)) {
    query['ConnData'] = request.connData;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateConnData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 更新关联数据
 *
 * @param request UpdateConnDataRequest
 * @return UpdateConnDataResponse
 */
async function updateConnData(request: UpdateConnDataRequest): UpdateConnDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateConnDataWithOptions(request, runtime);
}

model UpdateLayoutDataRequest {
  layoutData?: string(name='LayoutData', description='This parameter is required.', example='{}'),
  subSceneId?: string(name='SubSceneId', description='This parameter is required.', example='1234****'),
}

model UpdateLayoutDataResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model UpdateLayoutDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateLayoutDataResponseBody(name='body'),
}

/**
 * @summary 更新标注数据
 *
 * @param request UpdateLayoutDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateLayoutDataResponse
 */
async function updateLayoutDataWithOptions(request: UpdateLayoutDataRequest, runtime: Util.RuntimeOptions): UpdateLayoutDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.layoutData)) {
    query['LayoutData'] = request.layoutData;
  }
  if (!Util.isUnset(request.subSceneId)) {
    query['SubSceneId'] = request.subSceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateLayoutData',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 更新标注数据
 *
 * @param request UpdateLayoutDataRequest
 * @return UpdateLayoutDataResponse
 */
async function updateLayoutData(request: UpdateLayoutDataRequest): UpdateLayoutDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateLayoutDataWithOptions(request, runtime);
}

model UpdateProjectRequest {
  businessId?: string(name='BusinessId', example='5432****'),
  id?: string(name='Id', description='This parameter is required.', example='1234****'),
  name?: string(name='Name'),
}

model UpdateProjectResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

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

/**
 * @summary 变更项目信息
 *
 * @param request UpdateProjectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateProjectResponse
 */
async function updateProjectWithOptions(request: UpdateProjectRequest, runtime: Util.RuntimeOptions): UpdateProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessId)) {
    query['BusinessId'] = request.businessId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateProject',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 变更项目信息
 *
 * @param request UpdateProjectRequest
 * @return UpdateProjectResponse
 */
async function updateProject(request: UpdateProjectRequest): UpdateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateProjectWithOptions(request, runtime);
}

model UpdateSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234****'),
  name?: string(name='Name', description='This parameter is required.', example='测试'),
}

model UpdateSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4B***'),
  success?: boolean(name='Success', example='true'),
}

model UpdateSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSceneResponseBody(name='body'),
}

/**
 * @summary 更新主场景
 *
 * @param request UpdateSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateSceneResponse
 */
async function updateSceneWithOptions(request: UpdateSceneRequest, runtime: Util.RuntimeOptions): UpdateSceneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 更新主场景
 *
 * @param request UpdateSceneRequest
 * @return UpdateSceneResponse
 */
async function updateScene(request: UpdateSceneRequest): UpdateSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSceneWithOptions(request, runtime);
}

model UpdateSubSceneRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234****'),
  name?: string(name='Name', example='测试'),
  viewPoint?: [ double ](name='ViewPoint'),
}

model UpdateSubSceneShrinkRequest {
  id?: string(name='Id', description='This parameter is required.', example='1234****'),
  name?: string(name='Name', example='测试'),
  viewPointShrink?: string(name='ViewPoint'),
}

model UpdateSubSceneResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='4F882EA7-3A1D-0113-94E4-70162C4****'),
  success?: boolean(name='Success', example='true'),
}

model UpdateSubSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSubSceneResponseBody(name='body'),
}

/**
 * @summary 更新子场景
 *
 * @param tmpReq UpdateSubSceneRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateSubSceneResponse
 */
async function updateSubSceneWithOptions(tmpReq: UpdateSubSceneRequest, runtime: Util.RuntimeOptions): UpdateSubSceneResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateSubSceneShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.viewPoint)) {
    request.viewPointShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.viewPoint, 'ViewPoint', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.viewPointShrink)) {
    query['ViewPoint'] = request.viewPointShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSubScene',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 更新子场景
 *
 * @param request UpdateSubSceneRequest
 * @return UpdateSubSceneResponse
 */
async function updateSubScene(request: UpdateSubSceneRequest): UpdateSubSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSubSceneWithOptions(request, runtime);
}

model UpdateSubSceneSeqRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='sgyuyewyew****'),
  sortSubSceneIds?: [ string ](name='SortSubSceneIds', description='This parameter is required.'),
}

model UpdateSubSceneSeqShrinkRequest {
  sceneId?: string(name='SceneId', description='This parameter is required.', example='sgyuyewyew****'),
  sortSubSceneIdsShrink?: string(name='SortSubSceneIds', description='This parameter is required.'),
}

model UpdateSubSceneSeqResponseBody = {
  accessDeniedDetail?: {
    authAction?: string(name='AuthAction'),
    authPrincipalDisplayName?: string(name='AuthPrincipalDisplayName'),
    authPrincipalOwnerId?: string(name='AuthPrincipalOwnerId'),
    authPrincipalType?: string(name='AuthPrincipalType'),
    encodedDiagnosticMessage?: string(name='EncodedDiagnosticMessage'),
    noPermissionType?: string(name='NoPermissionType'),
    policyType?: string(name='PolicyType'),
  }(name='AccessDeniedDetail'),
  code?: long(name='Code', example='200'),
  message?: string(name='Message', example='success'),
  requestId?: string(name='RequestId', example='344794c32937474a9c59eb13093****'),
  success?: boolean(name='Success', example='true'),
}

model UpdateSubSceneSeqResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSubSceneSeqResponseBody(name='body'),
}

/**
 * @summary 更新子场景顺序
 *
 * @param tmpReq UpdateSubSceneSeqRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateSubSceneSeqResponse
 */
async function updateSubSceneSeqWithOptions(tmpReq: UpdateSubSceneSeqRequest, runtime: Util.RuntimeOptions): UpdateSubSceneSeqResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateSubSceneSeqShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.sortSubSceneIds)) {
    request.sortSubSceneIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.sortSubSceneIds, 'SortSubSceneIds', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.sortSubSceneIdsShrink)) {
    query['SortSubSceneIds'] = request.sortSubSceneIdsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSubSceneSeq',
    version = '2020-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 更新子场景顺序
 *
 * @param request UpdateSubSceneSeqRequest
 * @return UpdateSubSceneSeqResponse
 */
async function updateSubSceneSeq(request: UpdateSubSceneSeqRequest): UpdateSubSceneSeqResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSubSceneSeqWithOptions(request, runtime);
}