@alicloud/tdsr20200101 3.0.2 → 3.0.6

package/dist/client.js

@@ -16,6 +16,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const tea_util_1 = __importStar(require("@alicloud/tea-util")), $Util = tea_util_1;
 const openapi_client_1 = __importStar(require("@alicloud/openapi-client")), $OpenApi = openapi_client_1;
+const openapi_util_1 = __importDefault(require("@alicloud/openapi-util"));
 const endpoint_util_1 = __importDefault(require("@alicloud/endpoint-util"));
 const $tea = __importStar(require("@alicloud/tea-typescript"));
 class AddMosaicsRequest extends $tea.Model {
@@ -196,6 +197,64 @@ class AddRelativePositionResponse extends $tea.Model {
     }
 }
 exports.AddRelativePositionResponse = AddRelativePositionResponse;
+class AddRoomPlanRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            sceneId: 'SceneId',
+        };
+    }
+    static types() {
+        return {
+            sceneId: 'string',
+        };
+    }
+}
+exports.AddRoomPlanRequest = AddRoomPlanRequest;
+class AddRoomPlanResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            code: 'Code',
+            data: 'Data',
+            message: 'Message',
+            requestId: 'RequestId',
+            success: 'Success',
+        };
+    }
+    static types() {
+        return {
+            code: 'number',
+            data: AddRoomPlanResponseBodyData,
+            message: 'string',
+            requestId: 'string',
+            success: 'boolean',
+        };
+    }
+}
+exports.AddRoomPlanResponseBody = AddRoomPlanResponseBody;
+class AddRoomPlanResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: AddRoomPlanResponseBody,
+        };
+    }
+}
+exports.AddRoomPlanResponse = AddRoomPlanResponse;
 class AddSceneRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -266,12 +325,14 @@ class AddSubSceneRequest extends $tea.Model {
         return {
             name: 'Name',
             sceneId: 'SceneId',
+            uploadType: 'UploadType',
         };
     }
     static types() {
         return {
             name: 'string',
             sceneId: 'string',
+            uploadType: 'string',
         };
     }
 }
@@ -830,12 +891,16 @@ 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',
         };
     }
@@ -847,12 +912,16 @@ 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',
         };
     }
@@ -1668,6 +1737,70 @@ class GetSceneBuildTaskStatusResponse extends $tea.Model {
     }
 }
 exports.GetSceneBuildTaskStatusResponse = GetSceneBuildTaskStatusResponse;
+class GetScenePreviewDataRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            domain: 'Domain',
+            enabled: 'Enabled',
+            previewToken: 'PreviewToken',
+            showTag: 'ShowTag',
+        };
+    }
+    static types() {
+        return {
+            domain: 'string',
+            enabled: 'boolean',
+            previewToken: 'string',
+            showTag: 'boolean',
+        };
+    }
+}
+exports.GetScenePreviewDataRequest = GetScenePreviewDataRequest;
+class GetScenePreviewDataResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            code: 'Code',
+            data: 'Data',
+            message: 'Message',
+            requestId: 'RequestId',
+            success: 'Success',
+        };
+    }
+    static types() {
+        return {
+            code: 'number',
+            data: GetScenePreviewDataResponseBodyData,
+            message: 'string',
+            requestId: 'string',
+            success: 'boolean',
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBody = GetScenePreviewDataResponseBody;
+class GetScenePreviewDataResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: GetScenePreviewDataResponseBody,
+        };
+    }
+}
+exports.GetScenePreviewDataResponse = GetScenePreviewDataResponse;
 class GetScenePreviewInfoRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -2812,6 +2945,7 @@ class RectVerticalResponseBody extends $tea.Model {
             message: 'Message',
             requestId: 'RequestId',
             success: 'Success',
+            taskId: 'TaskId',
         };
     }
     static types() {
@@ -2820,6 +2954,7 @@ class RectVerticalResponseBody extends $tea.Model {
             message: 'string',
             requestId: 'string',
             success: 'boolean',
+            taskId: 'string',
         };
     }
 }
@@ -3540,6 +3675,34 @@ class UpdateSubSceneResponse extends $tea.Model {
     }
 }
 exports.UpdateSubSceneResponse = UpdateSubSceneResponse;
+class AddRoomPlanResponseBodyData extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            accessId: 'AccessId',
+            callback: 'Callback',
+            dir: 'Dir',
+            expire: 'Expire',
+            host: 'Host',
+            policy: 'Policy',
+            signature: 'Signature',
+        };
+    }
+    static types() {
+        return {
+            accessId: 'string',
+            callback: 'string',
+            dir: 'string',
+            expire: 'string',
+            host: 'string',
+            policy: 'string',
+            signature: 'string',
+        };
+    }
+}
+exports.AddRoomPlanResponseBodyData = AddRoomPlanResponseBodyData;
 class GetConnDataResponseBodyList extends $tea.Model {
     constructor(map) {
         super(map);
@@ -3582,6 +3745,196 @@ class GetHotspotSceneDataResponseBodyData extends $tea.Model {
     }
 }
 exports.GetHotspotSceneDataResponseBodyData = GetHotspotSceneDataResponseBodyData;
+class GetScenePreviewDataResponseBodyDataModelPanoListPosition extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            rotation: 'Rotation',
+            spot: 'Spot',
+            viewpoint: 'Viewpoint',
+        };
+    }
+    static types() {
+        return {
+            rotation: { 'type': 'array', 'itemType': 'number' },
+            spot: { 'type': 'array', 'itemType': 'number' },
+            viewpoint: { 'type': 'array', 'itemType': 'number' },
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyDataModelPanoListPosition = GetScenePreviewDataResponseBodyDataModelPanoListPosition;
+class GetScenePreviewDataResponseBodyDataModelPanoList extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            curRoomPicList: 'CurRoomPicList',
+            enabled: 'Enabled',
+            floorIdx: 'FloorIdx',
+            id: 'Id',
+            mainImage: 'MainImage',
+            neighbours: 'Neighbours',
+            position: 'Position',
+            rawName: 'RawName',
+            resource: 'Resource',
+            roomIdx: 'RoomIdx',
+            subSceneId: 'SubSceneId',
+            token: 'Token',
+            virtualId: 'VirtualId',
+            virtualName: 'VirtualName',
+        };
+    }
+    static types() {
+        return {
+            curRoomPicList: { 'type': 'array', 'itemType': 'string' },
+            enabled: 'boolean',
+            floorIdx: 'string',
+            id: 'string',
+            mainImage: 'boolean',
+            neighbours: { 'type': 'array', 'itemType': 'string' },
+            position: GetScenePreviewDataResponseBodyDataModelPanoListPosition,
+            rawName: 'string',
+            resource: 'string',
+            roomIdx: 'string',
+            subSceneId: 'string',
+            token: 'string',
+            virtualId: 'string',
+            virtualName: 'string',
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyDataModelPanoList = GetScenePreviewDataResponseBodyDataModelPanoList;
+class GetScenePreviewDataResponseBodyDataModel extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            modelPath: 'ModelPath',
+            panoList: 'PanoList',
+            textureModelPath: 'TextureModelPath',
+            texturePanoPath: 'TexturePanoPath',
+        };
+    }
+    static types() {
+        return {
+            modelPath: 'string',
+            panoList: { 'type': 'array', 'itemType': GetScenePreviewDataResponseBodyDataModelPanoList },
+            textureModelPath: 'string',
+            texturePanoPath: 'string',
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyDataModel = GetScenePreviewDataResponseBodyDataModel;
+class GetScenePreviewDataResponseBodyDataTagsConfigButtonConfig extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            customText: 'CustomText',
+            type: 'Type',
+        };
+    }
+    static types() {
+        return {
+            customText: 'string',
+            type: 'string',
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyDataTagsConfigButtonConfig = GetScenePreviewDataResponseBodyDataTagsConfigButtonConfig;
+class GetScenePreviewDataResponseBodyDataTagsConfig extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        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() {
+        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',
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyDataTagsConfig = GetScenePreviewDataResponseBodyDataTagsConfig;
+class GetScenePreviewDataResponseBodyDataTags extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            config: 'Config',
+            id: 'Id',
+            position: 'Position',
+            positionPanoCube: 'PositionPanoCube',
+            type: 'Type',
+        };
+    }
+    static types() {
+        return {
+            config: GetScenePreviewDataResponseBodyDataTagsConfig,
+            id: 'string',
+            position: { 'type': 'array', 'itemType': 'number' },
+            positionPanoCube: { 'type': 'array', 'itemType': 'number' },
+            type: 'string',
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyDataTags = GetScenePreviewDataResponseBodyDataTags;
+class GetScenePreviewDataResponseBodyData extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            model: 'Model',
+            tags: 'Tags',
+        };
+    }
+    static types() {
+        return {
+            model: GetScenePreviewDataResponseBodyDataModel,
+            tags: { 'type': 'array', 'itemType': GetScenePreviewDataResponseBodyDataTags },
+        };
+    }
+}
+exports.GetScenePreviewDataResponseBodyData = GetScenePreviewDataResponseBodyData;
 class GetScenePreviewInfoResponseBodyData extends $tea.Model {
     constructor(map) {
         super(map);
@@ -3747,6 +4100,7 @@ class ListSubSceneResponseBodyList extends $tea.Model {
             resourceId: 'ResourceId',
             resourceName: 'ResourceName',
             status: 'Status',
+            type: 'Type',
             url: 'Url',
         };
     }
@@ -3765,6 +4119,7 @@ class ListSubSceneResponseBodyList extends $tea.Model {
             resourceId: 'string',
             resourceName: 'string',
             status: 'number',
+            type: 'string',
             url: 'string',
         };
     }
@@ -3791,10 +4146,28 @@ class Client extends openapi_client_1.default {
     }
     async addMosaicsWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.markPosition)) {
+            query["MarkPosition"] = request.markPosition;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("AddMosaics", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddMosaicsResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new AddMosaicsResponse({}));
     }
     async addMosaics(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3802,10 +4175,28 @@ class Client extends openapi_client_1.default {
     }
     async addProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.businessId)) {
+            query["BusinessId"] = request.businessId;
+        }
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("AddProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddProjectResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new AddProjectResponse({}));
     }
     async addProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3813,21 +4204,86 @@ class Client extends openapi_client_1.default {
     }
     async addRelativePositionWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.relativePosition)) {
+            query["RelativePosition"] = request.relativePosition;
+        }
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new AddRelativePositionResponse({}));
     }
     async addRelativePosition(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.addRelativePositionWithOptions(request, runtime);
     }
+    async addRoomPlanWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new AddRoomPlanResponse({}));
+    }
+    async addRoomPlan(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.addRoomPlanWithOptions(request, runtime);
+    }
     async addSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
+        if (!tea_util_1.default.isUnset(request.projectId)) {
+            query["ProjectId"] = request.projectId;
+        }
+        if (!tea_util_1.default.isUnset(request.type)) {
+            query["Type"] = request.type;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new AddSceneResponse({}));
     }
     async addScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3835,10 +4291,31 @@ class Client extends openapi_client_1.default {
     }
     async addSubSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
+        if (!tea_util_1.default.isUnset(request.uploadType)) {
+            query["UploadType"] = request.uploadType;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("AddSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new AddSubSceneResponse({}));
+        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(await this.callApi(params, req, runtime), new AddSubSceneResponse({}));
     }
     async addSubScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3846,10 +4323,64 @@ class Client extends openapi_client_1.default {
     }
     async checkResourceWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.bid)) {
+            query["Bid"] = request.bid;
+        }
+        if (!tea_util_1.default.isUnset(request.country)) {
+            query["Country"] = request.country;
+        }
+        if (!tea_util_1.default.isUnset(request.gmtWakeup)) {
+            query["GmtWakeup"] = request.gmtWakeup;
+        }
+        if (!tea_util_1.default.isUnset(request.hid)) {
+            query["Hid"] = request.hid;
+        }
+        if (!tea_util_1.default.isUnset(request.interrupt)) {
+            query["Interrupt"] = request.interrupt;
+        }
+        if (!tea_util_1.default.isUnset(request.invoker)) {
+            query["Invoker"] = request.invoker;
+        }
+        if (!tea_util_1.default.isUnset(request.level)) {
+            query["Level"] = request.level;
+        }
+        if (!tea_util_1.default.isUnset(request.message)) {
+            query["Message"] = request.message;
+        }
+        if (!tea_util_1.default.isUnset(request.pk)) {
+            query["Pk"] = request.pk;
+        }
+        if (!tea_util_1.default.isUnset(request.prompt)) {
+            query["Prompt"] = request.prompt;
+        }
+        if (!tea_util_1.default.isUnset(request.success)) {
+            query["Success"] = request.success;
+        }
+        if (!tea_util_1.default.isUnset(request.taskExtraData)) {
+            query["TaskExtraData"] = request.taskExtraData;
+        }
+        if (!tea_util_1.default.isUnset(request.taskIdentifier)) {
+            query["TaskIdentifier"] = request.taskIdentifier;
+        }
+        if (!tea_util_1.default.isUnset(request.url)) {
+            query["Url"] = request.url;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("CheckResource", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new CheckResourceResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new CheckResourceResponse({}));
     }
     async checkResource(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3857,10 +4388,37 @@ class Client extends openapi_client_1.default {
     }
     async createProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.builderUserIdList)) {
+            query["BuilderUserIdList"] = request.builderUserIdList;
+        }
+        if (!tea_util_1.default.isUnset(request.businessId)) {
+            query["BusinessId"] = request.businessId;
+        }
+        if (!tea_util_1.default.isUnset(request.businessUserIdList)) {
+            query["BusinessUserIdList"] = request.businessUserIdList;
+        }
+        if (!tea_util_1.default.isUnset(request.gatherUserIdList)) {
+            query["GatherUserIdList"] = request.gatherUserIdList;
+        }
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("CreateProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new CreateProjectResponse({}));
+        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(await this.callApi(params, req, runtime), new CreateProjectResponse({}));
     }
     async createProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3868,10 +4426,28 @@ class Client extends openapi_client_1.default {
     }
     async createSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
+        if (!tea_util_1.default.isUnset(request.projectId)) {
+            query["ProjectId"] = request.projectId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("CreateScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new CreateSceneResponse({}));
+        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(await this.callApi(params, req, runtime), new CreateSceneResponse({}));
     }
     async createScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3879,10 +4455,28 @@ class Client extends openapi_client_1.default {
     }
     async deleteFileWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.paramFile)) {
+            query["ParamFile"] = request.paramFile;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneUuid)) {
+            query["SubSceneUuid"] = request.subSceneUuid;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("DeleteFile", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteFileResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new DeleteFileResponse({}));
     }
     async deleteFile(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3890,10 +4484,25 @@ class Client extends openapi_client_1.default {
     }
     async deleteProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.projectId)) {
+            query["ProjectId"] = request.projectId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("DeleteProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteProjectResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new DeleteProjectResponse({}));
     }
     async deleteProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3901,10 +4510,25 @@ class Client extends openapi_client_1.default {
     }
     async detailProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DetailProjectResponse({}));
     }
     async detailProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3912,10 +4536,25 @@ class Client extends openapi_client_1.default {
     }
     async detailSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("DetailScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DetailSceneResponse({}));
+        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(await this.callApi(params, req, runtime), new DetailSceneResponse({}));
     }
     async detailScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3923,10 +4562,25 @@ class Client extends openapi_client_1.default {
     }
     async detailSubSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DetailSubSceneResponse({}));
     }
     async detailSubScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3934,10 +4588,25 @@ class Client extends openapi_client_1.default {
     }
     async dropProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.projectId)) {
+            query["ProjectId"] = request.projectId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("DropProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DropProjectResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new DropProjectResponse({}));
     }
     async dropProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3945,10 +4614,25 @@ class Client extends openapi_client_1.default {
     }
     async dropSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("DropScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DropSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new DropSceneResponse({}));
     }
     async dropScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3956,10 +4640,25 @@ class Client extends openapi_client_1.default {
     }
     async dropSubSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("DropSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new DropSubSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new DropSubSceneResponse({}));
     }
     async dropSubScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3967,10 +4666,25 @@ class Client extends openapi_client_1.default {
     }
     async getConnDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("GetConnData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetConnDataResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetConnDataResponse({}));
     }
     async getConnData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3978,10 +4692,34 @@ class Client extends openapi_client_1.default {
     }
     async getHotspotConfigWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.domain)) {
+            query["Domain"] = request.domain;
+        }
+        if (!tea_util_1.default.isUnset(request.enabled)) {
+            query["Enabled"] = request.enabled;
+        }
+        if (!tea_util_1.default.isUnset(request.previewToken)) {
+            query["PreviewToken"] = request.previewToken;
+        }
+        if (!tea_util_1.default.isUnset(request.type)) {
+            query["Type"] = request.type;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("GetHotspotConfig", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetHotspotConfigResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetHotspotConfigResponse({}));
     }
     async getHotspotConfig(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -3989,10 +4727,34 @@ class Client extends openapi_client_1.default {
     }
     async getHotspotSceneDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.domain)) {
+            query["Domain"] = request.domain;
+        }
+        if (!tea_util_1.default.isUnset(request.enabled)) {
+            query["Enabled"] = request.enabled;
+        }
+        if (!tea_util_1.default.isUnset(request.previewToken)) {
+            query["PreviewToken"] = request.previewToken;
+        }
+        if (!tea_util_1.default.isUnset(request.type)) {
+            query["Type"] = request.type;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("GetHotspotSceneData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetHotspotSceneDataResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetHotspotSceneDataResponse({}));
     }
     async getHotspotSceneData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4000,10 +4762,37 @@ class Client extends openapi_client_1.default {
     }
     async getHotspotTagWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.domain)) {
+            query["Domain"] = request.domain;
+        }
+        if (!tea_util_1.default.isUnset(request.enabled)) {
+            query["Enabled"] = request.enabled;
+        }
+        if (!tea_util_1.default.isUnset(request.previewToken)) {
+            query["PreviewToken"] = request.previewToken;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneUuid)) {
+            query["SubSceneUuid"] = request.subSceneUuid;
+        }
+        if (!tea_util_1.default.isUnset(request.type)) {
+            query["Type"] = request.type;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("GetHotspotTag", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetHotspotTagResponse({}));
+        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(await this.callApi(params, req, runtime), new GetHotspotTagResponse({}));
     }
     async getHotspotTag(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4011,10 +4800,25 @@ class Client extends openapi_client_1.default {
     }
     async getLayoutDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new GetLayoutDataResponse({}));
     }
     async getLayoutData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4022,10 +4826,25 @@ class Client extends openapi_client_1.default {
     }
     async getOriginLayoutDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("GetOriginLayoutData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetOriginLayoutDataResponse({}));
+        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(await this.callApi(params, req, runtime), new GetOriginLayoutDataResponse({}));
     }
     async getOriginLayoutData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4033,10 +4852,25 @@ class Client extends openapi_client_1.default {
     }
     async getOssPolicyWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("GetOssPolicy", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetOssPolicyResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetOssPolicyResponse({}));
     }
     async getOssPolicy(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4044,10 +4878,28 @@ class Client extends openapi_client_1.default {
     }
     async getPolicyWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneUuid)) {
+            query["SubSceneUuid"] = request.subSceneUuid;
+        }
+        if (!tea_util_1.default.isUnset(request.type)) {
+            query["Type"] = request.type;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("GetPolicy", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetPolicyResponse({}));
+        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(await this.callApi(params, req, runtime), new GetPolicyResponse({}));
     }
     async getPolicy(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4055,10 +4907,25 @@ class Client extends openapi_client_1.default {
     }
     async getRectifyImageWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new GetRectifyImageResponse({}));
     }
     async getRectifyImage(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4066,21 +4933,92 @@ class Client extends openapi_client_1.default {
     }
     async getSceneBuildTaskStatusWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("GetSceneBuildTaskStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetSceneBuildTaskStatusResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetSceneBuildTaskStatusResponse({}));
     }
     async getSceneBuildTaskStatus(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.getSceneBuildTaskStatusWithOptions(request, runtime);
     }
+    async getScenePreviewDataWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.domain)) {
+            query["Domain"] = request.domain;
+        }
+        if (!tea_util_1.default.isUnset(request.enabled)) {
+            query["Enabled"] = request.enabled;
+        }
+        if (!tea_util_1.default.isUnset(request.previewToken)) {
+            query["PreviewToken"] = request.previewToken;
+        }
+        if (!tea_util_1.default.isUnset(request.showTag)) {
+            query["ShowTag"] = request.showTag;
+        }
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new GetScenePreviewDataResponse({}));
+    }
+    async getScenePreviewData(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.getScenePreviewDataWithOptions(request, runtime);
+    }
     async getScenePreviewInfoWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.domain)) {
+            query["Domain"] = request.domain;
+        }
+        if (!tea_util_1.default.isUnset(request.enabled)) {
+            query["Enabled"] = request.enabled;
+        }
+        if (!tea_util_1.default.isUnset(request.modelToken)) {
+            query["ModelToken"] = request.modelToken;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("GetScenePreviewInfo", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetScenePreviewInfoResponse({}));
+        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(await this.callApi(params, req, runtime), new GetScenePreviewInfoResponse({}));
     }
     async getScenePreviewInfo(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4088,10 +5026,25 @@ class Client extends openapi_client_1.default {
     }
     async getSingleConnDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new GetSingleConnDataResponse({}));
     }
     async getSingleConnData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4099,10 +5052,25 @@ class Client extends openapi_client_1.default {
     }
     async getSubSceneTaskStatusWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("GetSubSceneTaskStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetSubSceneTaskStatusResponse({}));
+        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(await this.callApi(params, req, runtime), new GetSubSceneTaskStatusResponse({}));
     }
     async getSubSceneTaskStatus(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4110,10 +5078,25 @@ class Client extends openapi_client_1.default {
     }
     async getTaskStatusWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.taskId)) {
+            query["TaskId"] = request.taskId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("GetTaskStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetTaskStatusResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetTaskStatusResponse({}));
     }
     async getTaskStatus(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4121,10 +5104,25 @@ class Client extends openapi_client_1.default {
     }
     async getWindowConfigWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.previewToken)) {
+            query["PreviewToken"] = request.previewToken;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("GetWindowConfig", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new GetWindowConfigResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new GetWindowConfigResponse({}));
     }
     async getWindowConfig(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4132,10 +5130,28 @@ class Client extends openapi_client_1.default {
     }
     async labelBuildWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.mode)) {
+            query["Mode"] = request.mode;
+        }
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new LabelBuildResponse({}));
     }
     async labelBuild(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4143,10 +5159,34 @@ class Client extends openapi_client_1.default {
     }
     async linkImageWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.cameraHeight)) {
+            query["CameraHeight"] = request.cameraHeight;
+        }
+        if (!tea_util_1.default.isUnset(request.fileName)) {
+            query["FileName"] = request.fileName;
+        }
+        if (!tea_util_1.default.isUnset(request.platform)) {
+            query["Platform"] = request.platform;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new LinkImageResponse({}));
     }
     async linkImage(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4154,10 +5194,31 @@ class Client extends openapi_client_1.default {
     }
     async listProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
+        if (!tea_util_1.default.isUnset(request.pageNum)) {
+            query["PageNum"] = request.pageNum;
+        }
+        if (!tea_util_1.default.isUnset(request.pageSize)) {
+            query["PageSize"] = request.pageSize;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("ListProject", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListProjectResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new ListProjectResponse({}));
     }
     async listProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4165,10 +5226,34 @@ class Client extends openapi_client_1.default {
     }
     async listSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
+        if (!tea_util_1.default.isUnset(request.pageNum)) {
+            query["PageNum"] = request.pageNum;
+        }
+        if (!tea_util_1.default.isUnset(request.pageSize)) {
+            query["PageSize"] = request.pageSize;
+        }
+        if (!tea_util_1.default.isUnset(request.projectId)) {
+            query["ProjectId"] = request.projectId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ListSceneResponse({}));
     }
     async listScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4176,10 +5261,28 @@ class Client extends openapi_client_1.default {
     }
     async listScenesWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.isPublishQuery)) {
+            query["IsPublishQuery"] = request.isPublishQuery;
+        }
+        if (!tea_util_1.default.isUnset(request.projectId)) {
+            query["ProjectId"] = request.projectId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("ListScenes", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListScenesResponse({}));
+        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(await this.callApi(params, req, runtime), new ListScenesResponse({}));
     }
     async listScenes(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4187,10 +5290,34 @@ class Client extends openapi_client_1.default {
     }
     async listSubSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.pageNum)) {
+            query["PageNum"] = request.pageNum;
+        }
+        if (!tea_util_1.default.isUnset(request.pageSize)) {
+            query["PageSize"] = request.pageSize;
+        }
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
+        if (!tea_util_1.default.isUnset(request.showLayoutData)) {
+            query["ShowLayoutData"] = request.showLayoutData;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("ListSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ListSubSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new ListSubSceneResponse({}));
     }
     async listSubScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4198,10 +5325,25 @@ class Client extends openapi_client_1.default {
     }
     async optimizeRightAngleWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("OptimizeRightAngle", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new OptimizeRightAngleResponse({}));
+        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(await this.callApi(params, req, runtime), new OptimizeRightAngleResponse({}));
     }
     async optimizeRightAngle(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4209,10 +5351,34 @@ class Client extends openapi_client_1.default {
     }
     async predImageWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.correctVertical)) {
+            query["CorrectVertical"] = request.correctVertical;
+        }
+        if (!tea_util_1.default.isUnset(request.countDetectDoor)) {
+            query["CountDetectDoor"] = request.countDetectDoor;
+        }
+        if (!tea_util_1.default.isUnset(request.detectDoor)) {
+            query["DetectDoor"] = request.detectDoor;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("PredImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PredImageResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new PredImageResponse({}));
     }
     async predImage(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4220,10 +5386,28 @@ class Client extends openapi_client_1.default {
     }
     async predictionWallLineWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.cameraHeight)) {
+            query["CameraHeight"] = request.cameraHeight;
+        }
+        if (!tea_util_1.default.isUnset(request.url)) {
+            query["Url"] = request.url;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("PredictionWallLine", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PredictionWallLineResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new PredictionWallLineResponse({}));
     }
     async predictionWallLine(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4231,10 +5415,28 @@ class Client extends openapi_client_1.default {
     }
     async publishHotspotWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.paramTag)) {
+            query["ParamTag"] = request.paramTag;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneUuid)) {
+            query["SubSceneUuid"] = request.subSceneUuid;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new PublishHotspotResponse({}));
     }
     async publishHotspot(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4242,10 +5444,25 @@ class Client extends openapi_client_1.default {
     }
     async publishSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("PublishScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PublishSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new PublishSceneResponse({}));
     }
     async publishScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4253,10 +5470,25 @@ class Client extends openapi_client_1.default {
     }
     async publishStatusWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("PublishStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new PublishStatusResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new PublishStatusResponse({}));
     }
     async publishStatus(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4264,10 +5496,25 @@ class Client extends openapi_client_1.default {
     }
     async recoveryOriginImageWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("RecoveryOriginImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RecoveryOriginImageResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new RecoveryOriginImageResponse({}));
     }
     async recoveryOriginImage(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4275,10 +5522,34 @@ class Client extends openapi_client_1.default {
     }
     async rectVerticalWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.countDetectDoor)) {
+            query["CountDetectDoor"] = request.countDetectDoor;
+        }
+        if (!tea_util_1.default.isUnset(request.detectDoor)) {
+            query["DetectDoor"] = request.detectDoor;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
+        if (!tea_util_1.default.isUnset(request.verticalRect)) {
+            query["VerticalRect"] = request.verticalRect;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("RectVertical", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RectVerticalResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new RectVerticalResponse({}));
     }
     async rectVertical(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4286,10 +5557,28 @@ class Client extends openapi_client_1.default {
     }
     async rectifyImageWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.cameraHeight)) {
+            query["CameraHeight"] = request.cameraHeight;
+        }
+        if (!tea_util_1.default.isUnset(request.url)) {
+            query["Url"] = request.url;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("RectifyImage", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RectifyImageResponse({}));
+        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(await this.callApi(params, req, runtime), new RectifyImageResponse({}));
     }
     async rectifyImage(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4297,10 +5586,25 @@ class Client extends openapi_client_1.default {
     }
     async rollbackSubSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("RollbackSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new RollbackSubSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new RollbackSubSceneResponse({}));
     }
     async rollbackSubScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4308,10 +5612,28 @@ class Client extends openapi_client_1.default {
     }
     async saveHotspotConfigWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.paramTag)) {
+            query["ParamTag"] = request.paramTag;
+        }
+        if (!tea_util_1.default.isUnset(request.previewToken)) {
+            query["PreviewToken"] = request.previewToken;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("SaveHotspotConfig", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new SaveHotspotConfigResponse({}));
+        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(await this.callApi(params, req, runtime), new SaveHotspotConfigResponse({}));
     }
     async saveHotspotConfig(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4319,10 +5641,28 @@ class Client extends openapi_client_1.default {
     }
     async saveHotspotTagWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.paramTag)) {
+            query["ParamTag"] = request.paramTag;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneUuid)) {
+            query["SubSceneUuid"] = request.subSceneUuid;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
+        });
+        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(await this.doRPCRequest("SaveHotspotTag", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new SaveHotspotTagResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new SaveHotspotTagResponse({}));
     }
     async saveHotspotTag(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4330,10 +5670,25 @@ class Client extends openapi_client_1.default {
     }
     async scenePublishWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("ScenePublish", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new ScenePublishResponse({}));
+        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(await this.callApi(params, req, runtime), new ScenePublishResponse({}));
     }
     async scenePublish(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4341,10 +5696,25 @@ class Client extends openapi_client_1.default {
     }
     async tempPreviewWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new TempPreviewResponse({}));
     }
     async tempPreview(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4352,10 +5722,25 @@ class Client extends openapi_client_1.default {
     }
     async tempPreviewStatusWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(await this.doRPCRequest("TempPreviewStatus", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new TempPreviewStatusResponse({}));
+        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(await this.callApi(params, req, runtime), new TempPreviewStatusResponse({}));
     }
     async tempPreviewStatus(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4363,10 +5748,28 @@ class Client extends openapi_client_1.default {
     }
     async updateConnDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.connData)) {
+            query["ConnData"] = request.connData;
+        }
+        if (!tea_util_1.default.isUnset(request.sceneId)) {
+            query["SceneId"] = request.sceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpdateConnDataResponse({}));
     }
     async updateConnData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4374,10 +5777,28 @@ class Client extends openapi_client_1.default {
     }
     async updateLayoutDataWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.layoutData)) {
+            query["LayoutData"] = request.layoutData;
+        }
+        if (!tea_util_1.default.isUnset(request.subSceneId)) {
+            query["SubSceneId"] = request.subSceneId;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("UpdateLayoutData", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateLayoutDataResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new UpdateLayoutDataResponse({}));
     }
     async updateLayoutData(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4385,10 +5806,31 @@ class Client extends openapi_client_1.default {
     }
     async updateProjectWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.businessId)) {
+            query["BusinessId"] = request.businessId;
+        }
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.query(query),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpdateProjectResponse({}));
     }
     async updateProject(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4396,10 +5838,28 @@ class Client extends openapi_client_1.default {
     }
     async updateSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("UpdateScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new UpdateSceneResponse({}));
     }
     async updateScene(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4407,10 +5867,28 @@ class Client extends openapi_client_1.default {
     }
     async updateSubSceneWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        if (!tea_util_1.default.isUnset(request.id)) {
+            query["Id"] = request.id;
+        }
+        if (!tea_util_1.default.isUnset(request.name)) {
+            query["Name"] = request.name;
+        }
         let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
+            query: openapi_util_1.default.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(await this.doRPCRequest("UpdateSubScene", "2020-01-01", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateSubSceneResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new UpdateSubSceneResponse({}));
     }
     async updateSubScene(request) {
         let runtime = new $Util.RuntimeOptions({});