@alicloud/tdsr20200101 3.0.2 → 3.0.6

package/src/client.ts

@@ -4,6 +4,7 @@
  */
 import Util, * as $Util from '@alicloud/tea-util';
 import OpenApi, * as $OpenApi from '@alicloud/openapi-client';
+import OpenApiUtil from '@alicloud/openapi-util';
 import EndpointUtil from '@alicloud/endpoint-util';
 import * as $tea from '@alicloud/tea-typescript';
 
@@ -229,6 +230,78 @@ export class AddRelativePositionResponse extends $tea.Model {
   }
 }
 
+export class AddRoomPlanRequest extends $tea.Model {
+  sceneId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      sceneId: 'SceneId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      sceneId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class AddRoomPlanResponseBody extends $tea.Model {
+  code?: number;
+  data?: AddRoomPlanResponseBodyData;
+  message?: string;
+  requestId?: string;
+  success?: boolean;
+  static names(): { [key: string]: string } {
+    return {
+      code: 'Code',
+      data: 'Data',
+      message: 'Message',
+      requestId: 'RequestId',
+      success: 'Success',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      code: 'number',
+      data: AddRoomPlanResponseBodyData,
+      message: 'string',
+      requestId: 'string',
+      success: 'boolean',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class AddRoomPlanResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: AddRoomPlanResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: AddRoomPlanResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class AddSceneRequest extends $tea.Model {
   name?: string;
   projectId?: string;
@@ -310,10 +383,12 @@ export class AddSceneResponse extends $tea.Model {
 export class AddSubSceneRequest extends $tea.Model {
   name?: string;
   sceneId?: string;
+  uploadType?: string;
   static names(): { [key: string]: string } {
     return {
       name: 'Name',
       sceneId: 'SceneId',
+      uploadType: 'UploadType',
     };
   }
 
@@ -321,6 +396,7 @@ export class AddSubSceneRequest extends $tea.Model {
     return {
       name: 'string',
       sceneId: 'string',
+      uploadType: 'string',
     };
   }
 
@@ -1029,12 +1105,16 @@ export class DetailSubSceneResponseBody extends $tea.Model {
   gmtCreate?: number;
   gmtModified?: number;
   id?: string;
+  imageUrl?: string;
+  layoutData?: string;
   message?: string;
   name?: string;
+  originUrl?: string;
   requestId?: string;
   resourceId?: string;
   status?: number;
   success?: boolean;
+  type?: string;
   url?: string;
   static names(): { [key: string]: string } {
     return {
@@ -1044,12 +1124,16 @@ export class DetailSubSceneResponseBody extends $tea.Model {
       gmtCreate: 'GmtCreate',
       gmtModified: 'GmtModified',
       id: 'Id',
+      imageUrl: 'ImageUrl',
+      layoutData: 'LayoutData',
       message: 'Message',
       name: 'Name',
+      originUrl: 'OriginUrl',
       requestId: 'RequestId',
       resourceId: 'ResourceId',
       status: 'Status',
       success: 'Success',
+      type: 'Type',
       url: 'Url',
     };
   }
@@ -1062,12 +1146,16 @@ export class DetailSubSceneResponseBody extends $tea.Model {
       gmtCreate: 'number',
       gmtModified: 'number',
       id: 'string',
+      imageUrl: 'string',
+      layoutData: 'string',
       message: 'string',
       name: 'string',
+      originUrl: 'string',
       requestId: 'string',
       resourceId: 'string',
       status: 'number',
       success: 'boolean',
+      type: 'string',
       url: 'string',
     };
   }
@@ -2092,6 +2180,87 @@ export class GetSceneBuildTaskStatusResponse extends $tea.Model {
   }
 }
 
+export class GetScenePreviewDataRequest extends $tea.Model {
+  domain?: string;
+  enabled?: boolean;
+  previewToken?: string;
+  showTag?: boolean;
+  static names(): { [key: string]: string } {
+    return {
+      domain: 'Domain',
+      enabled: 'Enabled',
+      previewToken: 'PreviewToken',
+      showTag: 'ShowTag',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      domain: 'string',
+      enabled: 'boolean',
+      previewToken: 'string',
+      showTag: 'boolean',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetScenePreviewDataResponseBody extends $tea.Model {
+  code?: number;
+  data?: GetScenePreviewDataResponseBodyData;
+  message?: string;
+  requestId?: string;
+  success?: boolean;
+  static names(): { [key: string]: string } {
+    return {
+      code: 'Code',
+      data: 'Data',
+      message: 'Message',
+      requestId: 'RequestId',
+      success: 'Success',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      code: 'number',
+      data: GetScenePreviewDataResponseBodyData,
+      message: 'string',
+      requestId: 'string',
+      success: 'boolean',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetScenePreviewDataResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: GetScenePreviewDataResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: GetScenePreviewDataResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class GetScenePreviewInfoRequest extends $tea.Model {
   domain?: string;
   enabled?: boolean;
@@ -3523,12 +3692,14 @@ export class RectVerticalResponseBody extends $tea.Model {
   message?: string;
   requestId?: string;
   success?: boolean;
+  taskId?: string;
   static names(): { [key: string]: string } {
     return {
       code: 'Code',
       message: 'Message',
       requestId: 'RequestId',
       success: 'Success',
+      taskId: 'TaskId',
     };
   }
 
@@ -3538,6 +3709,7 @@ export class RectVerticalResponseBody extends $tea.Model {
       message: 'string',
       requestId: 'string',
       success: 'boolean',
+      taskId: 'string',
     };
   }
 
@@ -4435,6 +4607,43 @@ export class UpdateSubSceneResponse extends $tea.Model {
   }
 }
 
+export class AddRoomPlanResponseBodyData extends $tea.Model {
+  accessId?: string;
+  callback?: string;
+  dir?: string;
+  expire?: string;
+  host?: string;
+  policy?: string;
+  signature?: string;
+  static names(): { [key: string]: string } {
+    return {
+      accessId: 'AccessId',
+      callback: 'Callback',
+      dir: 'Dir',
+      expire: 'Expire',
+      host: 'Host',
+      policy: 'Policy',
+      signature: 'Signature',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      accessId: 'string',
+      callback: 'string',
+      dir: 'string',
+      expire: 'string',
+      host: 'string',
+      policy: 'string',
+      signature: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class GetConnDataResponseBodyList extends $tea.Model {
   id?: string;
   mapId?: string;
@@ -4488,26 +4697,23 @@ export class GetHotspotSceneDataResponseBodyData extends $tea.Model {
   }
 }
 
-export class GetScenePreviewInfoResponseBodyData extends $tea.Model {
-  modelPath?: string;
-  panoList?: string;
-  textureModelPath?: string;
-  texturePanoPath?: string;
+export class GetScenePreviewDataResponseBodyDataModelPanoListPosition extends $tea.Model {
+  rotation?: number[];
+  spot?: number[];
+  viewpoint?: number[];
   static names(): { [key: string]: string } {
     return {
-      modelPath: 'ModelPath',
-      panoList: 'PanoList',
-      textureModelPath: 'TextureModelPath',
-      texturePanoPath: 'TexturePanoPath',
+      rotation: 'Rotation',
+      spot: 'Spot',
+      viewpoint: 'Viewpoint',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      modelPath: 'string',
-      panoList: 'string',
-      textureModelPath: 'string',
-      texturePanoPath: 'string',
+      rotation: { 'type': 'array', 'itemType': 'number' },
+      spot: { 'type': 'array', 'itemType': 'number' },
+      viewpoint: { 'type': 'array', 'itemType': 'number' },
     };
   }
 
@@ -4516,23 +4722,56 @@ export class GetScenePreviewInfoResponseBodyData extends $tea.Model {
   }
 }
 
-export class GetSingleConnDataResponseBodyList extends $tea.Model {
+export class GetScenePreviewDataResponseBodyDataModelPanoList extends $tea.Model {
+  curRoomPicList?: string[];
+  enabled?: boolean;
+  floorIdx?: string;
   id?: string;
-  mapId?: string;
-  type?: string;
+  mainImage?: boolean;
+  neighbours?: string[];
+  position?: GetScenePreviewDataResponseBodyDataModelPanoListPosition;
+  rawName?: string;
+  resource?: string;
+  roomIdx?: string;
+  subSceneId?: string;
+  token?: string;
+  virtualId?: string;
+  virtualName?: string;
   static names(): { [key: string]: string } {
     return {
+      curRoomPicList: 'CurRoomPicList',
+      enabled: 'Enabled',
+      floorIdx: 'FloorIdx',
       id: 'Id',
-      mapId: 'MapId',
-      type: 'Type',
+      mainImage: 'MainImage',
+      neighbours: 'Neighbours',
+      position: 'Position',
+      rawName: 'RawName',
+      resource: 'Resource',
+      roomIdx: 'RoomIdx',
+      subSceneId: 'SubSceneId',
+      token: 'Token',
+      virtualId: 'VirtualId',
+      virtualName: 'VirtualName',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
+      curRoomPicList: { 'type': 'array', 'itemType': 'string' },
+      enabled: 'boolean',
+      floorIdx: 'string',
       id: 'string',
-      mapId: 'string',
-      type: 'string',
+      mainImage: 'boolean',
+      neighbours: { 'type': 'array', 'itemType': 'string' },
+      position: GetScenePreviewDataResponseBodyDataModelPanoListPosition,
+      rawName: 'string',
+      resource: 'string',
+      roomIdx: 'string',
+      subSceneId: 'string',
+      token: 'string',
+      virtualId: 'string',
+      virtualName: 'string',
     };
   }
 
@@ -4541,35 +4780,26 @@ export class GetSingleConnDataResponseBodyList extends $tea.Model {
   }
 }
 
-export class GetSubSceneTaskStatusResponseBodyList extends $tea.Model {
-  errorCode?: string;
-  errorMsg?: string;
-  id?: string;
-  sceneId?: string;
-  status?: string;
-  subSceneId?: string;
-  type?: string;
+export class GetScenePreviewDataResponseBodyDataModel extends $tea.Model {
+  modelPath?: string;
+  panoList?: GetScenePreviewDataResponseBodyDataModelPanoList[];
+  textureModelPath?: string;
+  texturePanoPath?: string;
   static names(): { [key: string]: string } {
     return {
-      errorCode: 'ErrorCode',
-      errorMsg: 'ErrorMsg',
-      id: 'Id',
-      sceneId: 'SceneId',
-      status: 'Status',
-      subSceneId: 'SubSceneId',
-      type: 'Type',
+      modelPath: 'ModelPath',
+      panoList: 'PanoList',
+      textureModelPath: 'TextureModelPath',
+      texturePanoPath: 'TexturePanoPath',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      errorCode: 'string',
-      errorMsg: 'string',
-      id: 'string',
-      sceneId: 'string',
-      status: 'string',
-      subSceneId: 'string',
-      type: 'string',
+      modelPath: 'string',
+      panoList: { 'type': 'array', 'itemType': GetScenePreviewDataResponseBodyDataModelPanoList },
+      textureModelPath: 'string',
+      texturePanoPath: 'string',
     };
   }
 
@@ -4578,18 +4808,247 @@ export class GetSubSceneTaskStatusResponseBodyList extends $tea.Model {
   }
 }
 
-export class ListProjectResponseBodyList extends $tea.Model {
-  businessId?: number;
-  businessName?: string;
-  createTime?: number;
-  id?: string;
-  modifiedTime?: number;
-  name?: string;
-  token?: string;
+export class GetScenePreviewDataResponseBodyDataTagsConfigButtonConfig extends $tea.Model {
+  customText?: string;
+  type?: string;
   static names(): { [key: string]: string } {
     return {
-      businessId: 'BusinessId',
-      businessName: 'BusinessName',
+      customText: 'CustomText',
+      type: 'Type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      customText: 'string',
+      type: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetScenePreviewDataResponseBodyDataTagsConfig extends $tea.Model {
+  backgroundColor?: string;
+  buttonConfig?: GetScenePreviewDataResponseBodyDataTagsConfigButtonConfig;
+  content?: string;
+  formImgSize?: number[];
+  formJumpType?: boolean;
+  formSelectImgType?: string;
+  images?: string[];
+  isTagVisibleBy3d?: boolean;
+  link?: string;
+  panoId?: string;
+  position?: number[];
+  positionPanoCube?: number[];
+  relatedPanoIds?: string[];
+  sceneId?: number;
+  title?: string;
+  video?: string;
+  static names(): { [key: string]: string } {
+    return {
+      backgroundColor: 'BackgroundColor',
+      buttonConfig: 'ButtonConfig',
+      content: 'Content',
+      formImgSize: 'FormImgSize',
+      formJumpType: 'FormJumpType',
+      formSelectImgType: 'FormSelectImgType',
+      images: 'Images',
+      isTagVisibleBy3d: 'IsTagVisibleBy3d',
+      link: 'Link',
+      panoId: 'PanoId',
+      position: 'Position',
+      positionPanoCube: 'PositionPanoCube',
+      relatedPanoIds: 'RelatedPanoIds',
+      sceneId: 'SceneId',
+      title: 'Title',
+      video: 'Video',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      backgroundColor: 'string',
+      buttonConfig: GetScenePreviewDataResponseBodyDataTagsConfigButtonConfig,
+      content: 'string',
+      formImgSize: { 'type': 'array', 'itemType': 'number' },
+      formJumpType: 'boolean',
+      formSelectImgType: 'string',
+      images: { 'type': 'array', 'itemType': 'string' },
+      isTagVisibleBy3d: 'boolean',
+      link: 'string',
+      panoId: 'string',
+      position: { 'type': 'array', 'itemType': 'number' },
+      positionPanoCube: { 'type': 'array', 'itemType': 'number' },
+      relatedPanoIds: { 'type': 'array', 'itemType': 'string' },
+      sceneId: 'number',
+      title: 'string',
+      video: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetScenePreviewDataResponseBodyDataTags extends $tea.Model {
+  config?: GetScenePreviewDataResponseBodyDataTagsConfig;
+  id?: string;
+  position?: number[];
+  positionPanoCube?: number[];
+  type?: string;
+  static names(): { [key: string]: string } {
+    return {
+      config: 'Config',
+      id: 'Id',
+      position: 'Position',
+      positionPanoCube: 'PositionPanoCube',
+      type: 'Type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      config: GetScenePreviewDataResponseBodyDataTagsConfig,
+      id: 'string',
+      position: { 'type': 'array', 'itemType': 'number' },
+      positionPanoCube: { 'type': 'array', 'itemType': 'number' },
+      type: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetScenePreviewDataResponseBodyData extends $tea.Model {
+  model?: GetScenePreviewDataResponseBodyDataModel;
+  tags?: GetScenePreviewDataResponseBodyDataTags[];
+  static names(): { [key: string]: string } {
+    return {
+      model: 'Model',
+      tags: 'Tags',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      model: GetScenePreviewDataResponseBodyDataModel,
+      tags: { 'type': 'array', 'itemType': GetScenePreviewDataResponseBodyDataTags },
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetScenePreviewInfoResponseBodyData extends $tea.Model {
+  modelPath?: string;
+  panoList?: string;
+  textureModelPath?: string;
+  texturePanoPath?: string;
+  static names(): { [key: string]: string } {
+    return {
+      modelPath: 'ModelPath',
+      panoList: 'PanoList',
+      textureModelPath: 'TextureModelPath',
+      texturePanoPath: 'TexturePanoPath',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      modelPath: 'string',
+      panoList: 'string',
+      textureModelPath: 'string',
+      texturePanoPath: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetSingleConnDataResponseBodyList extends $tea.Model {
+  id?: string;
+  mapId?: string;
+  type?: string;
+  static names(): { [key: string]: string } {
+    return {
+      id: 'Id',
+      mapId: 'MapId',
+      type: 'Type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      id: 'string',
+      mapId: 'string',
+      type: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class GetSubSceneTaskStatusResponseBodyList extends $tea.Model {
+  errorCode?: string;
+  errorMsg?: string;
+  id?: string;
+  sceneId?: string;
+  status?: string;
+  subSceneId?: string;
+  type?: string;
+  static names(): { [key: string]: string } {
+    return {
+      errorCode: 'ErrorCode',
+      errorMsg: 'ErrorMsg',
+      id: 'Id',
+      sceneId: 'SceneId',
+      status: 'Status',
+      subSceneId: 'SubSceneId',
+      type: 'Type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      errorCode: 'string',
+      errorMsg: 'string',
+      id: 'string',
+      sceneId: 'string',
+      status: 'string',
+      subSceneId: 'string',
+      type: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ListProjectResponseBodyList extends $tea.Model {
+  businessId?: number;
+  businessName?: string;
+  createTime?: number;
+  id?: string;
+  modifiedTime?: number;
+  name?: string;
+  token?: string;
+  static names(): { [key: string]: string } {
+    return {
+      businessId: 'BusinessId',
+      businessName: 'BusinessName',
       createTime: 'CreateTime',
       id: 'Id',
       modifiedTime: 'ModifiedTime',
@@ -4691,6 +5150,7 @@ export class ListSubSceneResponseBodyList extends $tea.Model {
   resourceId?: string;
   resourceName?: string;
   status?: number;
+  type?: string;
   url?: string;
   static names(): { [key: string]: string } {
     return {
@@ -4707,6 +5167,7 @@ export class ListSubSceneResponseBodyList extends $tea.Model {
       resourceId: 'ResourceId',
       resourceName: 'ResourceName',
       status: 'Status',
+      type: 'Type',
       url: 'Url',
     };
   }
@@ -4726,6 +5187,7 @@ export class ListSubSceneResponseBodyList extends $tea.Model {
       resourceId: 'string',
       resourceName: 'string',
       status: 'number',
+      type: 'string',
       url: 'string',
     };
   }
@@ -4763,10 +5225,30 @@ export default class Client extends OpenApi {
 
   async addMosaicsWithOptions(request: AddMosaicsRequest, runtime: $Util.RuntimeOptions): Promise<AddMosaicsResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.markPosition)) {
+      query["MarkPosition"] = request.markPosition;
+    }
+
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<AddMosaicsResponse>(await this.doRPCRequest("AddMosaics", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddMosaicsResponse({}));
+    let params = new $OpenApi.Params({
+      action: "AddMosaics",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<AddMosaicsResponse>(await this.callApi(params, req, runtime), new AddMosaicsResponse({}));
   }
 
   async addMosaics(request: AddMosaicsRequest): Promise<AddMosaicsResponse> {
@@ -4776,10 +5258,30 @@ export default class Client extends OpenApi {
 
   async addProjectWithOptions(request: AddProjectRequest, runtime: $Util.RuntimeOptions): Promise<AddProjectResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.businessId)) {
+      query["BusinessId"] = request.businessId;
+    }
+
+    if (!Util.isUnset(request.name)) {
+      query["Name"] = request.name;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "AddProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<AddProjectResponse>(await this.doRPCRequest("AddProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddProjectResponse({}));
+    return $tea.cast<AddProjectResponse>(await this.callApi(params, req, runtime), new AddProjectResponse({}));
   }
 
   async addProject(request: AddProjectRequest): Promise<AddProjectResponse> {
@@ -4789,10 +5291,30 @@ export default class Client extends OpenApi {
 
   async addRelativePositionWithOptions(request: AddRelativePositionRequest, runtime: $Util.RuntimeOptions): Promise<AddRelativePositionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.relativePosition)) {
+      query["RelativePosition"] = request.relativePosition;
+    }
+
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<AddRelativePositionResponse>(await this.doRPCRequest("AddRelativePosition", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddRelativePositionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "AddRelativePosition",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<AddRelativePositionResponse>(await this.callApi(params, req, runtime), new AddRelativePositionResponse({}));
   }
 
   async addRelativePosition(request: AddRelativePositionRequest): Promise<AddRelativePositionResponse> {
@@ -4800,12 +5322,65 @@ export default class Client extends OpenApi {
     return await this.addRelativePositionWithOptions(request, runtime);
   }
 
+  async addRoomPlanWithOptions(request: AddRoomPlanRequest, runtime: $Util.RuntimeOptions): Promise<AddRoomPlanResponse> {
+    Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "AddRoomPlan",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<AddRoomPlanResponse>(await this.callApi(params, req, runtime), new AddRoomPlanResponse({}));
+  }
+
+  async addRoomPlan(request: AddRoomPlanRequest): Promise<AddRoomPlanResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.addRoomPlanWithOptions(request, runtime);
+  }
+
   async addSceneWithOptions(request: AddSceneRequest, runtime: $Util.RuntimeOptions): Promise<AddSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<AddSceneResponse>(await this.doRPCRequest("AddScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddSceneResponse({}));
+    let params = new $OpenApi.Params({
+      action: "AddScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<AddSceneResponse>(await this.callApi(params, req, runtime), new AddSceneResponse({}));
   }
 
   async addScene(request: AddSceneRequest): Promise<AddSceneResponse> {
@@ -4815,10 +5390,34 @@ export default class Client extends OpenApi {
 
   async addSubSceneWithOptions(request: AddSubSceneRequest, runtime: $Util.RuntimeOptions): Promise<AddSubSceneResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "AddSubScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<AddSubSceneResponse>(await this.doRPCRequest("AddSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddSubSceneResponse({}));
+    return $tea.cast<AddSubSceneResponse>(await this.callApi(params, req, runtime), new AddSubSceneResponse({}));
   }
 
   async addSubScene(request: AddSubSceneRequest): Promise<AddSubSceneResponse> {
@@ -4828,10 +5427,78 @@ export default class Client extends OpenApi {
 
   async checkResourceWithOptions(request: CheckResourceRequest, runtime: $Util.RuntimeOptions): Promise<CheckResourceResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.bid)) {
+      query["Bid"] = request.bid;
+    }
+
+    if (!Util.isUnset(request.country)) {
+      query["Country"] = request.country;
+    }
+
+    if (!Util.isUnset(request.gmtWakeup)) {
+      query["GmtWakeup"] = request.gmtWakeup;
+    }
+
+    if (!Util.isUnset(request.hid)) {
+      query["Hid"] = request.hid;
+    }
+
+    if (!Util.isUnset(request.interrupt)) {
+      query["Interrupt"] = request.interrupt;
+    }
+
+    if (!Util.isUnset(request.invoker)) {
+      query["Invoker"] = request.invoker;
+    }
+
+    if (!Util.isUnset(request.level)) {
+      query["Level"] = request.level;
+    }
+
+    if (!Util.isUnset(request.message)) {
+      query["Message"] = request.message;
+    }
+
+    if (!Util.isUnset(request.pk)) {
+      query["Pk"] = request.pk;
+    }
+
+    if (!Util.isUnset(request.prompt)) {
+      query["Prompt"] = request.prompt;
+    }
+
+    if (!Util.isUnset(request.success)) {
+      query["Success"] = request.success;
+    }
+
+    if (!Util.isUnset(request.taskExtraData)) {
+      query["TaskExtraData"] = request.taskExtraData;
+    }
+
+    if (!Util.isUnset(request.taskIdentifier)) {
+      query["TaskIdentifier"] = request.taskIdentifier;
+    }
+
+    if (!Util.isUnset(request.url)) {
+      query["Url"] = request.url;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<CheckResourceResponse>(await this.doRPCRequest("CheckResource", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new CheckResourceResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CheckResource",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<CheckResourceResponse>(await this.callApi(params, req, runtime), new CheckResourceResponse({}));
   }
 
   async checkResource(request: CheckResourceRequest): Promise<CheckResourceResponse> {
@@ -4841,10 +5508,42 @@ export default class Client extends OpenApi {
 
   async createProjectWithOptions(request: CreateProjectRequest, runtime: $Util.RuntimeOptions): Promise<CreateProjectResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.builderUserIdList)) {
+      query["BuilderUserIdList"] = request.builderUserIdList;
+    }
+
+    if (!Util.isUnset(request.businessId)) {
+      query["BusinessId"] = request.businessId;
+    }
+
+    if (!Util.isUnset(request.businessUserIdList)) {
+      query["BusinessUserIdList"] = request.businessUserIdList;
+    }
+
+    if (!Util.isUnset(request.gatherUserIdList)) {
+      query["GatherUserIdList"] = request.gatherUserIdList;
+    }
+
+    if (!Util.isUnset(request.name)) {
+      query["Name"] = request.name;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CreateProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CreateProjectResponse>(await this.doRPCRequest("CreateProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new CreateProjectResponse({}));
+    return $tea.cast<CreateProjectResponse>(await this.callApi(params, req, runtime), new CreateProjectResponse({}));
   }
 
   async createProject(request: CreateProjectRequest): Promise<CreateProjectResponse> {
@@ -4854,10 +5553,30 @@ export default class Client extends OpenApi {
 
   async createSceneWithOptions(request: CreateSceneRequest, runtime: $Util.RuntimeOptions): Promise<CreateSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.name)) {
+      query["Name"] = request.name;
+    }
+
+    if (!Util.isUnset(request.projectId)) {
+      query["ProjectId"] = request.projectId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CreateScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CreateSceneResponse>(await this.doRPCRequest("CreateScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new CreateSceneResponse({}));
+    return $tea.cast<CreateSceneResponse>(await this.callApi(params, req, runtime), new CreateSceneResponse({}));
   }
 
   async createScene(request: CreateSceneRequest): Promise<CreateSceneResponse> {
@@ -4867,10 +5586,30 @@ export default class Client extends OpenApi {
 
   async deleteFileWithOptions(request: DeleteFileRequest, runtime: $Util.RuntimeOptions): Promise<DeleteFileResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.paramFile)) {
+      query["ParamFile"] = request.paramFile;
+    }
+
+    if (!Util.isUnset(request.subSceneUuid)) {
+      query["SubSceneUuid"] = request.subSceneUuid;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DeleteFileResponse>(await this.doRPCRequest("DeleteFile", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteFileResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DeleteFile",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DeleteFileResponse>(await this.callApi(params, req, runtime), new DeleteFileResponse({}));
   }
 
   async deleteFile(request: DeleteFileRequest): Promise<DeleteFileResponse> {
@@ -4880,10 +5619,26 @@ export default class Client extends OpenApi {
 
   async deleteProjectWithOptions(request: DeleteProjectRequest, runtime: $Util.RuntimeOptions): Promise<DeleteProjectResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.projectId)) {
+      query["ProjectId"] = request.projectId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DeleteProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DeleteProjectResponse>(await this.doRPCRequest("DeleteProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteProjectResponse({}));
+    return $tea.cast<DeleteProjectResponse>(await this.callApi(params, req, runtime), new DeleteProjectResponse({}));
   }
 
   async deleteProject(request: DeleteProjectRequest): Promise<DeleteProjectResponse> {
@@ -4893,10 +5648,26 @@ export default class Client extends OpenApi {
 
   async detailProjectWithOptions(request: DetailProjectRequest, runtime: $Util.RuntimeOptions): Promise<DetailProjectResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DetailProjectResponse>(await this.doRPCRequest("DetailProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DetailProjectResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DetailProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DetailProjectResponse>(await this.callApi(params, req, runtime), new DetailProjectResponse({}));
   }
 
   async detailProject(request: DetailProjectRequest): Promise<DetailProjectResponse> {
@@ -4906,10 +5677,26 @@ export default class Client extends OpenApi {
 
   async detailSceneWithOptions(request: DetailSceneRequest, runtime: $Util.RuntimeOptions): Promise<DetailSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DetailScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DetailSceneResponse>(await this.doRPCRequest("DetailScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DetailSceneResponse({}));
+    return $tea.cast<DetailSceneResponse>(await this.callApi(params, req, runtime), new DetailSceneResponse({}));
   }
 
   async detailScene(request: DetailSceneRequest): Promise<DetailSceneResponse> {
@@ -4919,10 +5706,26 @@ export default class Client extends OpenApi {
 
   async detailSubSceneWithOptions(request: DetailSubSceneRequest, runtime: $Util.RuntimeOptions): Promise<DetailSubSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DetailSubSceneResponse>(await this.doRPCRequest("DetailSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DetailSubSceneResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DetailSubScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DetailSubSceneResponse>(await this.callApi(params, req, runtime), new DetailSubSceneResponse({}));
   }
 
   async detailSubScene(request: DetailSubSceneRequest): Promise<DetailSubSceneResponse> {
@@ -4932,10 +5735,26 @@ export default class Client extends OpenApi {
 
   async dropProjectWithOptions(request: DropProjectRequest, runtime: $Util.RuntimeOptions): Promise<DropProjectResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.projectId)) {
+      query["ProjectId"] = request.projectId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DropProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DropProjectResponse>(await this.doRPCRequest("DropProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DropProjectResponse({}));
+    return $tea.cast<DropProjectResponse>(await this.callApi(params, req, runtime), new DropProjectResponse({}));
   }
 
   async dropProject(request: DropProjectRequest): Promise<DropProjectResponse> {
@@ -4945,10 +5764,26 @@ export default class Client extends OpenApi {
 
   async dropSceneWithOptions(request: DropSceneRequest, runtime: $Util.RuntimeOptions): Promise<DropSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DropSceneResponse>(await this.doRPCRequest("DropScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DropSceneResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DropScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DropSceneResponse>(await this.callApi(params, req, runtime), new DropSceneResponse({}));
   }
 
   async dropScene(request: DropSceneRequest): Promise<DropSceneResponse> {
@@ -4958,10 +5793,26 @@ export default class Client extends OpenApi {
 
   async dropSubSceneWithOptions(request: DropSubSceneRequest, runtime: $Util.RuntimeOptions): Promise<DropSubSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DropSubScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DropSubSceneResponse>(await this.doRPCRequest("DropSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DropSubSceneResponse({}));
+    return $tea.cast<DropSubSceneResponse>(await this.callApi(params, req, runtime), new DropSubSceneResponse({}));
   }
 
   async dropSubScene(request: DropSubSceneRequest): Promise<DropSubSceneResponse> {
@@ -4971,10 +5822,26 @@ export default class Client extends OpenApi {
 
   async getConnDataWithOptions(request: GetConnDataRequest, runtime: $Util.RuntimeOptions): Promise<GetConnDataResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetConnDataResponse>(await this.doRPCRequest("GetConnData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetConnDataResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetConnData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetConnDataResponse>(await this.callApi(params, req, runtime), new GetConnDataResponse({}));
   }
 
   async getConnData(request: GetConnDataRequest): Promise<GetConnDataResponse> {
@@ -4984,10 +5851,38 @@ export default class Client extends OpenApi {
 
   async getHotspotConfigWithOptions(request: GetHotspotConfigRequest, runtime: $Util.RuntimeOptions): Promise<GetHotspotConfigResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetHotspotConfig",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetHotspotConfigResponse>(await this.doRPCRequest("GetHotspotConfig", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetHotspotConfigResponse({}));
+    return $tea.cast<GetHotspotConfigResponse>(await this.callApi(params, req, runtime), new GetHotspotConfigResponse({}));
   }
 
   async getHotspotConfig(request: GetHotspotConfigRequest): Promise<GetHotspotConfigResponse> {
@@ -4997,10 +5892,38 @@ export default class Client extends OpenApi {
 
   async getHotspotSceneDataWithOptions(request: GetHotspotSceneDataRequest, runtime: $Util.RuntimeOptions): Promise<GetHotspotSceneDataResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetHotspotSceneDataResponse>(await this.doRPCRequest("GetHotspotSceneData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetHotspotSceneDataResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetHotspotSceneData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetHotspotSceneDataResponse>(await this.callApi(params, req, runtime), new GetHotspotSceneDataResponse({}));
   }
 
   async getHotspotSceneData(request: GetHotspotSceneDataRequest): Promise<GetHotspotSceneDataResponse> {
@@ -5010,10 +5933,42 @@ export default class Client extends OpenApi {
 
   async getHotspotTagWithOptions(request: GetHotspotTagRequest, runtime: $Util.RuntimeOptions): Promise<GetHotspotTagResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetHotspotTag",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetHotspotTagResponse>(await this.doRPCRequest("GetHotspotTag", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetHotspotTagResponse({}));
+    return $tea.cast<GetHotspotTagResponse>(await this.callApi(params, req, runtime), new GetHotspotTagResponse({}));
   }
 
   async getHotspotTag(request: GetHotspotTagRequest): Promise<GetHotspotTagResponse> {
@@ -5023,10 +5978,26 @@ export default class Client extends OpenApi {
 
   async getLayoutDataWithOptions(request: GetLayoutDataRequest, runtime: $Util.RuntimeOptions): Promise<GetLayoutDataResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetLayoutDataResponse>(await this.doRPCRequest("GetLayoutData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetLayoutDataResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetLayoutData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetLayoutDataResponse>(await this.callApi(params, req, runtime), new GetLayoutDataResponse({}));
   }
 
   async getLayoutData(request: GetLayoutDataRequest): Promise<GetLayoutDataResponse> {
@@ -5036,10 +6007,26 @@ export default class Client extends OpenApi {
 
   async getOriginLayoutDataWithOptions(request: GetOriginLayoutDataRequest, runtime: $Util.RuntimeOptions): Promise<GetOriginLayoutDataResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetOriginLayoutData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetOriginLayoutDataResponse>(await this.doRPCRequest("GetOriginLayoutData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetOriginLayoutDataResponse({}));
+    return $tea.cast<GetOriginLayoutDataResponse>(await this.callApi(params, req, runtime), new GetOriginLayoutDataResponse({}));
   }
 
   async getOriginLayoutData(request: GetOriginLayoutDataRequest): Promise<GetOriginLayoutDataResponse> {
@@ -5049,10 +6036,26 @@ export default class Client extends OpenApi {
 
   async getOssPolicyWithOptions(request: GetOssPolicyRequest, runtime: $Util.RuntimeOptions): Promise<GetOssPolicyResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetOssPolicyResponse>(await this.doRPCRequest("GetOssPolicy", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetOssPolicyResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetOssPolicy",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetOssPolicyResponse>(await this.callApi(params, req, runtime), new GetOssPolicyResponse({}));
   }
 
   async getOssPolicy(request: GetOssPolicyRequest): Promise<GetOssPolicyResponse> {
@@ -5062,10 +6065,30 @@ export default class Client extends OpenApi {
 
   async getPolicyWithOptions(request: GetPolicyRequest, runtime: $Util.RuntimeOptions): Promise<GetPolicyResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneUuid)) {
+      query["SubSceneUuid"] = request.subSceneUuid;
+    }
+
+    if (!Util.isUnset(request.type)) {
+      query["Type"] = request.type;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetPolicy",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetPolicyResponse>(await this.doRPCRequest("GetPolicy", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetPolicyResponse({}));
+    return $tea.cast<GetPolicyResponse>(await this.callApi(params, req, runtime), new GetPolicyResponse({}));
   }
 
   async getPolicy(request: GetPolicyRequest): Promise<GetPolicyResponse> {
@@ -5075,10 +6098,26 @@ export default class Client extends OpenApi {
 
   async getRectifyImageWithOptions(request: GetRectifyImageRequest, runtime: $Util.RuntimeOptions): Promise<GetRectifyImageResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetRectifyImageResponse>(await this.doRPCRequest("GetRectifyImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetRectifyImageResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetRectifyImage",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetRectifyImageResponse>(await this.callApi(params, req, runtime), new GetRectifyImageResponse({}));
   }
 
   async getRectifyImage(request: GetRectifyImageRequest): Promise<GetRectifyImageResponse> {
@@ -5088,10 +6127,26 @@ export default class Client extends OpenApi {
 
   async getSceneBuildTaskStatusWithOptions(request: GetSceneBuildTaskStatusRequest, runtime: $Util.RuntimeOptions): Promise<GetSceneBuildTaskStatusResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetSceneBuildTaskStatus",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetSceneBuildTaskStatusResponse>(await this.doRPCRequest("GetSceneBuildTaskStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetSceneBuildTaskStatusResponse({}));
+    return $tea.cast<GetSceneBuildTaskStatusResponse>(await this.callApi(params, req, runtime), new GetSceneBuildTaskStatusResponse({}));
   }
 
   async getSceneBuildTaskStatus(request: GetSceneBuildTaskStatusRequest): Promise<GetSceneBuildTaskStatusResponse> {
@@ -5099,12 +6154,77 @@ export default class Client extends OpenApi {
     return await this.getSceneBuildTaskStatusWithOptions(request, runtime);
   }
 
+  async getScenePreviewDataWithOptions(request: GetScenePreviewDataRequest, runtime: $Util.RuntimeOptions): Promise<GetScenePreviewDataResponse> {
+    Util.validateModel(request);
+    let 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;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetScenePreviewData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetScenePreviewDataResponse>(await this.callApi(params, req, runtime), new GetScenePreviewDataResponse({}));
+  }
+
+  async getScenePreviewData(request: GetScenePreviewDataRequest): Promise<GetScenePreviewDataResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.getScenePreviewDataWithOptions(request, runtime);
+  }
+
   async getScenePreviewInfoWithOptions(request: GetScenePreviewInfoRequest, runtime: $Util.RuntimeOptions): Promise<GetScenePreviewInfoResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetScenePreviewInfo",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetScenePreviewInfoResponse>(await this.doRPCRequest("GetScenePreviewInfo", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetScenePreviewInfoResponse({}));
+    return $tea.cast<GetScenePreviewInfoResponse>(await this.callApi(params, req, runtime), new GetScenePreviewInfoResponse({}));
   }
 
   async getScenePreviewInfo(request: GetScenePreviewInfoRequest): Promise<GetScenePreviewInfoResponse> {
@@ -5114,10 +6234,26 @@ export default class Client extends OpenApi {
 
   async getSingleConnDataWithOptions(request: GetSingleConnDataRequest, runtime: $Util.RuntimeOptions): Promise<GetSingleConnDataResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetSingleConnDataResponse>(await this.doRPCRequest("GetSingleConnData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetSingleConnDataResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetSingleConnData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetSingleConnDataResponse>(await this.callApi(params, req, runtime), new GetSingleConnDataResponse({}));
   }
 
   async getSingleConnData(request: GetSingleConnDataRequest): Promise<GetSingleConnDataResponse> {
@@ -5127,10 +6263,26 @@ export default class Client extends OpenApi {
 
   async getSubSceneTaskStatusWithOptions(request: GetSubSceneTaskStatusRequest, runtime: $Util.RuntimeOptions): Promise<GetSubSceneTaskStatusResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetSubSceneTaskStatus",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetSubSceneTaskStatusResponse>(await this.doRPCRequest("GetSubSceneTaskStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetSubSceneTaskStatusResponse({}));
+    return $tea.cast<GetSubSceneTaskStatusResponse>(await this.callApi(params, req, runtime), new GetSubSceneTaskStatusResponse({}));
   }
 
   async getSubSceneTaskStatus(request: GetSubSceneTaskStatusRequest): Promise<GetSubSceneTaskStatusResponse> {
@@ -5140,10 +6292,26 @@ export default class Client extends OpenApi {
 
   async getTaskStatusWithOptions(request: GetTaskStatusRequest, runtime: $Util.RuntimeOptions): Promise<GetTaskStatusResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.taskId)) {
+      query["TaskId"] = request.taskId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetTaskStatusResponse>(await this.doRPCRequest("GetTaskStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetTaskStatusResponse({}));
+    let params = new $OpenApi.Params({
+      action: "GetTaskStatus",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<GetTaskStatusResponse>(await this.callApi(params, req, runtime), new GetTaskStatusResponse({}));
   }
 
   async getTaskStatus(request: GetTaskStatusRequest): Promise<GetTaskStatusResponse> {
@@ -5153,10 +6321,26 @@ export default class Client extends OpenApi {
 
   async getWindowConfigWithOptions(request: GetWindowConfigRequest, runtime: $Util.RuntimeOptions): Promise<GetWindowConfigResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.previewToken)) {
+      query["PreviewToken"] = request.previewToken;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "GetWindowConfig",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<GetWindowConfigResponse>(await this.doRPCRequest("GetWindowConfig", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetWindowConfigResponse({}));
+    return $tea.cast<GetWindowConfigResponse>(await this.callApi(params, req, runtime), new GetWindowConfigResponse({}));
   }
 
   async getWindowConfig(request: GetWindowConfigRequest): Promise<GetWindowConfigResponse> {
@@ -5166,10 +6350,30 @@ export default class Client extends OpenApi {
 
   async labelBuildWithOptions(request: LabelBuildRequest, runtime: $Util.RuntimeOptions): Promise<LabelBuildResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.mode)) {
+      query["Mode"] = request.mode;
+    }
+
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<LabelBuildResponse>(await this.doRPCRequest("LabelBuild", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new LabelBuildResponse({}));
+    let params = new $OpenApi.Params({
+      action: "LabelBuild",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<LabelBuildResponse>(await this.callApi(params, req, runtime), new LabelBuildResponse({}));
   }
 
   async labelBuild(request: LabelBuildRequest): Promise<LabelBuildResponse> {
@@ -5179,10 +6383,38 @@ export default class Client extends OpenApi {
 
   async linkImageWithOptions(request: LinkImageRequest, runtime: $Util.RuntimeOptions): Promise<LinkImageResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<LinkImageResponse>(await this.doRPCRequest("LinkImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new LinkImageResponse({}));
+    let params = new $OpenApi.Params({
+      action: "LinkImage",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<LinkImageResponse>(await this.callApi(params, req, runtime), new LinkImageResponse({}));
   }
 
   async linkImage(request: LinkImageRequest): Promise<LinkImageResponse> {
@@ -5192,10 +6424,34 @@ export default class Client extends OpenApi {
 
   async listProjectWithOptions(request: ListProjectRequest, runtime: $Util.RuntimeOptions): Promise<ListProjectResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ListProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ListProjectResponse>(await this.doRPCRequest("ListProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListProjectResponse({}));
+    return $tea.cast<ListProjectResponse>(await this.callApi(params, req, runtime), new ListProjectResponse({}));
   }
 
   async listProject(request: ListProjectRequest): Promise<ListProjectResponse> {
@@ -5205,10 +6461,38 @@ export default class Client extends OpenApi {
 
   async listSceneWithOptions(request: ListSceneRequest, runtime: $Util.RuntimeOptions): Promise<ListSceneResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<ListSceneResponse>(await this.doRPCRequest("ListScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListSceneResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ListScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ListSceneResponse>(await this.callApi(params, req, runtime), new ListSceneResponse({}));
   }
 
   async listScene(request: ListSceneRequest): Promise<ListSceneResponse> {
@@ -5218,10 +6502,30 @@ export default class Client extends OpenApi {
 
   async listScenesWithOptions(request: ListScenesRequest, runtime: $Util.RuntimeOptions): Promise<ListScenesResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.isPublishQuery)) {
+      query["IsPublishQuery"] = request.isPublishQuery;
+    }
+
+    if (!Util.isUnset(request.projectId)) {
+      query["ProjectId"] = request.projectId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ListScenes",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ListScenesResponse>(await this.doRPCRequest("ListScenes", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListScenesResponse({}));
+    return $tea.cast<ListScenesResponse>(await this.callApi(params, req, runtime), new ListScenesResponse({}));
   }
 
   async listScenes(request: ListScenesRequest): Promise<ListScenesResponse> {
@@ -5231,10 +6535,38 @@ export default class Client extends OpenApi {
 
   async listSubSceneWithOptions(request: ListSubSceneRequest, runtime: $Util.RuntimeOptions): Promise<ListSubSceneResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<ListSubSceneResponse>(await this.doRPCRequest("ListSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListSubSceneResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ListSubScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ListSubSceneResponse>(await this.callApi(params, req, runtime), new ListSubSceneResponse({}));
   }
 
   async listSubScene(request: ListSubSceneRequest): Promise<ListSubSceneResponse> {
@@ -5244,10 +6576,26 @@ export default class Client extends OpenApi {
 
   async optimizeRightAngleWithOptions(request: OptimizeRightAngleRequest, runtime: $Util.RuntimeOptions): Promise<OptimizeRightAngleResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "OptimizeRightAngle",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<OptimizeRightAngleResponse>(await this.doRPCRequest("OptimizeRightAngle", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new OptimizeRightAngleResponse({}));
+    return $tea.cast<OptimizeRightAngleResponse>(await this.callApi(params, req, runtime), new OptimizeRightAngleResponse({}));
   }
 
   async optimizeRightAngle(request: OptimizeRightAngleRequest): Promise<OptimizeRightAngleResponse> {
@@ -5257,10 +6605,38 @@ export default class Client extends OpenApi {
 
   async predImageWithOptions(request: PredImageRequest, runtime: $Util.RuntimeOptions): Promise<PredImageResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<PredImageResponse>(await this.doRPCRequest("PredImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PredImageResponse({}));
+    let params = new $OpenApi.Params({
+      action: "PredImage",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<PredImageResponse>(await this.callApi(params, req, runtime), new PredImageResponse({}));
   }
 
   async predImage(request: PredImageRequest): Promise<PredImageResponse> {
@@ -5270,10 +6646,30 @@ export default class Client extends OpenApi {
 
   async predictionWallLineWithOptions(request: PredictionWallLineRequest, runtime: $Util.RuntimeOptions): Promise<PredictionWallLineResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.cameraHeight)) {
+      query["CameraHeight"] = request.cameraHeight;
+    }
+
+    if (!Util.isUnset(request.url)) {
+      query["Url"] = request.url;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "PredictionWallLine",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<PredictionWallLineResponse>(await this.doRPCRequest("PredictionWallLine", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PredictionWallLineResponse({}));
+    return $tea.cast<PredictionWallLineResponse>(await this.callApi(params, req, runtime), new PredictionWallLineResponse({}));
   }
 
   async predictionWallLine(request: PredictionWallLineRequest): Promise<PredictionWallLineResponse> {
@@ -5283,10 +6679,30 @@ export default class Client extends OpenApi {
 
   async publishHotspotWithOptions(request: PublishHotspotRequest, runtime: $Util.RuntimeOptions): Promise<PublishHotspotResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.paramTag)) {
+      query["ParamTag"] = request.paramTag;
+    }
+
+    if (!Util.isUnset(request.subSceneUuid)) {
+      query["SubSceneUuid"] = request.subSceneUuid;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<PublishHotspotResponse>(await this.doRPCRequest("PublishHotspot", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PublishHotspotResponse({}));
+    let params = new $OpenApi.Params({
+      action: "PublishHotspot",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<PublishHotspotResponse>(await this.callApi(params, req, runtime), new PublishHotspotResponse({}));
   }
 
   async publishHotspot(request: PublishHotspotRequest): Promise<PublishHotspotResponse> {
@@ -5296,10 +6712,26 @@ export default class Client extends OpenApi {
 
   async publishSceneWithOptions(request: PublishSceneRequest, runtime: $Util.RuntimeOptions): Promise<PublishSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "PublishScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<PublishSceneResponse>(await this.doRPCRequest("PublishScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PublishSceneResponse({}));
+    return $tea.cast<PublishSceneResponse>(await this.callApi(params, req, runtime), new PublishSceneResponse({}));
   }
 
   async publishScene(request: PublishSceneRequest): Promise<PublishSceneResponse> {
@@ -5309,10 +6741,26 @@ export default class Client extends OpenApi {
 
   async publishStatusWithOptions(request: PublishStatusRequest, runtime: $Util.RuntimeOptions): Promise<PublishStatusResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<PublishStatusResponse>(await this.doRPCRequest("PublishStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PublishStatusResponse({}));
+    let params = new $OpenApi.Params({
+      action: "PublishStatus",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<PublishStatusResponse>(await this.callApi(params, req, runtime), new PublishStatusResponse({}));
   }
 
   async publishStatus(request: PublishStatusRequest): Promise<PublishStatusResponse> {
@@ -5322,10 +6770,26 @@ export default class Client extends OpenApi {
 
   async recoveryOriginImageWithOptions(request: RecoveryOriginImageRequest, runtime: $Util.RuntimeOptions): Promise<RecoveryOriginImageResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "RecoveryOriginImage",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<RecoveryOriginImageResponse>(await this.doRPCRequest("RecoveryOriginImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RecoveryOriginImageResponse({}));
+    return $tea.cast<RecoveryOriginImageResponse>(await this.callApi(params, req, runtime), new RecoveryOriginImageResponse({}));
   }
 
   async recoveryOriginImage(request: RecoveryOriginImageRequest): Promise<RecoveryOriginImageResponse> {
@@ -5335,10 +6799,38 @@ export default class Client extends OpenApi {
 
   async rectVerticalWithOptions(request: RectVerticalRequest, runtime: $Util.RuntimeOptions): Promise<RectVerticalResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<RectVerticalResponse>(await this.doRPCRequest("RectVertical", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RectVerticalResponse({}));
+    let params = new $OpenApi.Params({
+      action: "RectVertical",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<RectVerticalResponse>(await this.callApi(params, req, runtime), new RectVerticalResponse({}));
   }
 
   async rectVertical(request: RectVerticalRequest): Promise<RectVerticalResponse> {
@@ -5348,10 +6840,30 @@ export default class Client extends OpenApi {
 
   async rectifyImageWithOptions(request: RectifyImageRequest, runtime: $Util.RuntimeOptions): Promise<RectifyImageResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.cameraHeight)) {
+      query["CameraHeight"] = request.cameraHeight;
+    }
+
+    if (!Util.isUnset(request.url)) {
+      query["Url"] = request.url;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "RectifyImage",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<RectifyImageResponse>(await this.doRPCRequest("RectifyImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RectifyImageResponse({}));
+    return $tea.cast<RectifyImageResponse>(await this.callApi(params, req, runtime), new RectifyImageResponse({}));
   }
 
   async rectifyImage(request: RectifyImageRequest): Promise<RectifyImageResponse> {
@@ -5361,10 +6873,26 @@ export default class Client extends OpenApi {
 
   async rollbackSubSceneWithOptions(request: RollbackSubSceneRequest, runtime: $Util.RuntimeOptions): Promise<RollbackSubSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<RollbackSubSceneResponse>(await this.doRPCRequest("RollbackSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RollbackSubSceneResponse({}));
+    let params = new $OpenApi.Params({
+      action: "RollbackSubScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<RollbackSubSceneResponse>(await this.callApi(params, req, runtime), new RollbackSubSceneResponse({}));
   }
 
   async rollbackSubScene(request: RollbackSubSceneRequest): Promise<RollbackSubSceneResponse> {
@@ -5374,10 +6902,30 @@ export default class Client extends OpenApi {
 
   async saveHotspotConfigWithOptions(request: SaveHotspotConfigRequest, runtime: $Util.RuntimeOptions): Promise<SaveHotspotConfigResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.paramTag)) {
+      query["ParamTag"] = request.paramTag;
+    }
+
+    if (!Util.isUnset(request.previewToken)) {
+      query["PreviewToken"] = request.previewToken;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "SaveHotspotConfig",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<SaveHotspotConfigResponse>(await this.doRPCRequest("SaveHotspotConfig", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new SaveHotspotConfigResponse({}));
+    return $tea.cast<SaveHotspotConfigResponse>(await this.callApi(params, req, runtime), new SaveHotspotConfigResponse({}));
   }
 
   async saveHotspotConfig(request: SaveHotspotConfigRequest): Promise<SaveHotspotConfigResponse> {
@@ -5387,10 +6935,30 @@ export default class Client extends OpenApi {
 
   async saveHotspotTagWithOptions(request: SaveHotspotTagRequest, runtime: $Util.RuntimeOptions): Promise<SaveHotspotTagResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.paramTag)) {
+      query["ParamTag"] = request.paramTag;
+    }
+
+    if (!Util.isUnset(request.subSceneUuid)) {
+      query["SubSceneUuid"] = request.subSceneUuid;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<SaveHotspotTagResponse>(await this.doRPCRequest("SaveHotspotTag", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new SaveHotspotTagResponse({}));
+    let params = new $OpenApi.Params({
+      action: "SaveHotspotTag",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<SaveHotspotTagResponse>(await this.callApi(params, req, runtime), new SaveHotspotTagResponse({}));
   }
 
   async saveHotspotTag(request: SaveHotspotTagRequest): Promise<SaveHotspotTagResponse> {
@@ -5400,10 +6968,26 @@ export default class Client extends OpenApi {
 
   async scenePublishWithOptions(request: ScenePublishRequest, runtime: $Util.RuntimeOptions): Promise<ScenePublishResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ScenePublish",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ScenePublishResponse>(await this.doRPCRequest("ScenePublish", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ScenePublishResponse({}));
+    return $tea.cast<ScenePublishResponse>(await this.callApi(params, req, runtime), new ScenePublishResponse({}));
   }
 
   async scenePublish(request: ScenePublishRequest): Promise<ScenePublishResponse> {
@@ -5413,10 +6997,26 @@ export default class Client extends OpenApi {
 
   async tempPreviewWithOptions(request: TempPreviewRequest, runtime: $Util.RuntimeOptions): Promise<TempPreviewResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<TempPreviewResponse>(await this.doRPCRequest("TempPreview", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new TempPreviewResponse({}));
+    let params = new $OpenApi.Params({
+      action: "TempPreview",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<TempPreviewResponse>(await this.callApi(params, req, runtime), new TempPreviewResponse({}));
   }
 
   async tempPreview(request: TempPreviewRequest): Promise<TempPreviewResponse> {
@@ -5426,10 +7026,26 @@ export default class Client extends OpenApi {
 
   async tempPreviewStatusWithOptions(request: TempPreviewStatusRequest, runtime: $Util.RuntimeOptions): Promise<TempPreviewStatusResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "TempPreviewStatus",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<TempPreviewStatusResponse>(await this.doRPCRequest("TempPreviewStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new TempPreviewStatusResponse({}));
+    return $tea.cast<TempPreviewStatusResponse>(await this.callApi(params, req, runtime), new TempPreviewStatusResponse({}));
   }
 
   async tempPreviewStatus(request: TempPreviewStatusRequest): Promise<TempPreviewStatusResponse> {
@@ -5439,10 +7055,30 @@ export default class Client extends OpenApi {
 
   async updateConnDataWithOptions(request: UpdateConnDataRequest, runtime: $Util.RuntimeOptions): Promise<UpdateConnDataResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.connData)) {
+      query["ConnData"] = request.connData;
+    }
+
+    if (!Util.isUnset(request.sceneId)) {
+      query["SceneId"] = request.sceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<UpdateConnDataResponse>(await this.doRPCRequest("UpdateConnData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateConnDataResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpdateConnData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateConnDataResponse>(await this.callApi(params, req, runtime), new UpdateConnDataResponse({}));
   }
 
   async updateConnData(request: UpdateConnDataRequest): Promise<UpdateConnDataResponse> {
@@ -5452,10 +7088,30 @@ export default class Client extends OpenApi {
 
   async updateLayoutDataWithOptions(request: UpdateLayoutDataRequest, runtime: $Util.RuntimeOptions): Promise<UpdateLayoutDataResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.layoutData)) {
+      query["LayoutData"] = request.layoutData;
+    }
+
+    if (!Util.isUnset(request.subSceneId)) {
+      query["SubSceneId"] = request.subSceneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UpdateLayoutData",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<UpdateLayoutDataResponse>(await this.doRPCRequest("UpdateLayoutData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateLayoutDataResponse({}));
+    return $tea.cast<UpdateLayoutDataResponse>(await this.callApi(params, req, runtime), new UpdateLayoutDataResponse({}));
   }
 
   async updateLayoutData(request: UpdateLayoutDataRequest): Promise<UpdateLayoutDataResponse> {
@@ -5465,10 +7121,34 @@ export default class Client extends OpenApi {
 
   async updateProjectWithOptions(request: UpdateProjectRequest, runtime: $Util.RuntimeOptions): Promise<UpdateProjectResponse> {
     Util.validateModel(request);
+    let 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;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<UpdateProjectResponse>(await this.doRPCRequest("UpdateProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateProjectResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpdateProject",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateProjectResponse>(await this.callApi(params, req, runtime), new UpdateProjectResponse({}));
   }
 
   async updateProject(request: UpdateProjectRequest): Promise<UpdateProjectResponse> {
@@ -5478,10 +7158,30 @@ export default class Client extends OpenApi {
 
   async updateSceneWithOptions(request: UpdateSceneRequest, runtime: $Util.RuntimeOptions): Promise<UpdateSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
+    if (!Util.isUnset(request.name)) {
+      query["Name"] = request.name;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UpdateScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<UpdateSceneResponse>(await this.doRPCRequest("UpdateScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateSceneResponse({}));
+    return $tea.cast<UpdateSceneResponse>(await this.callApi(params, req, runtime), new UpdateSceneResponse({}));
   }
 
   async updateScene(request: UpdateSceneRequest): Promise<UpdateSceneResponse> {
@@ -5491,10 +7191,30 @@ export default class Client extends OpenApi {
 
   async updateSubSceneWithOptions(request: UpdateSubSceneRequest, runtime: $Util.RuntimeOptions): Promise<UpdateSubSceneResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.id)) {
+      query["Id"] = request.id;
+    }
+
+    if (!Util.isUnset(request.name)) {
+      query["Name"] = request.name;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UpdateSubScene",
+      version: "2020-01-01",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<UpdateSubSceneResponse>(await this.doRPCRequest("UpdateSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateSubSceneResponse({}));
+    return $tea.cast<UpdateSubSceneResponse>(await this.callApi(params, req, runtime), new UpdateSubSceneResponse({}));
   }
 
   async updateSubScene(request: UpdateSubSceneRequest): Promise<UpdateSubSceneResponse> {