alibabacloud-aimiaobi20230801 1.36.5__py3-none-any.whl → 1.37.1__py3-none-any.whl

alibabacloud_aimiaobi20230801/models.py

@@ -1412,13 +1412,88 @@ class AsyncCreateClipsTaskRequestColorWords(TeaModel):
         return self
 
 
+class AsyncCreateClipsTaskRequestStickers(TeaModel):
+    def __init__(
+        self,
+        duration: int = None,
+        dync_frames: int = None,
+        height: int = None,
+        timeline_in: int = None,
+        url: str = None,
+        width: int = None,
+        x: float = None,
+        y: float = None,
+    ):
+        self.duration = duration
+        self.dync_frames = dync_frames
+        self.height = height
+        self.timeline_in = timeline_in
+        self.url = url
+        self.width = width
+        self.x = x
+        self.y = y
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.duration is not None:
+            result['Duration'] = self.duration
+        if self.dync_frames is not None:
+            result['DyncFrames'] = self.dync_frames
+        if self.height is not None:
+            result['Height'] = self.height
+        if self.timeline_in is not None:
+            result['TimelineIn'] = self.timeline_in
+        if self.url is not None:
+            result['Url'] = self.url
+        if self.width is not None:
+            result['Width'] = self.width
+        if self.x is not None:
+            result['X'] = self.x
+        if self.y is not None:
+            result['Y'] = self.y
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Duration') is not None:
+            self.duration = m.get('Duration')
+        if m.get('DyncFrames') is not None:
+            self.dync_frames = m.get('DyncFrames')
+        if m.get('Height') is not None:
+            self.height = m.get('Height')
+        if m.get('TimelineIn') is not None:
+            self.timeline_in = m.get('TimelineIn')
+        if m.get('Url') is not None:
+            self.url = m.get('Url')
+        if m.get('Width') is not None:
+            self.width = m.get('Width')
+        if m.get('X') is not None:
+            self.x = m.get('X')
+        if m.get('Y') is not None:
+            self.y = m.get('Y')
+        return self
+
+
 class AsyncCreateClipsTaskRequest(TeaModel):
     def __init__(
         self,
+        close_music: bool = None,
+        close_subtitle: bool = None,
+        close_voice: bool = None,
         color_words: List[AsyncCreateClipsTaskRequestColorWords] = None,
+        custom_voice_url: str = None,
+        custom_voice_volume: int = None,
         height: int = None,
         music_url: str = None,
         music_volume: int = None,
+        stickers: List[AsyncCreateClipsTaskRequestStickers] = None,
         subtitle_font_size: int = None,
         task_id: str = None,
         voice_style: str = None,
@@ -1426,10 +1501,16 @@ class AsyncCreateClipsTaskRequest(TeaModel):
         width: int = None,
         workspace_id: str = None,
     ):
+        self.close_music = close_music
+        self.close_subtitle = close_subtitle
+        self.close_voice = close_voice
         self.color_words = color_words
+        self.custom_voice_url = custom_voice_url
+        self.custom_voice_volume = custom_voice_volume
         self.height = height
         self.music_url = music_url
         self.music_volume = music_volume
+        self.stickers = stickers
         self.subtitle_font_size = subtitle_font_size
         # This parameter is required.
         self.task_id = task_id
@@ -1444,6 +1525,10 @@ class AsyncCreateClipsTaskRequest(TeaModel):
             for k in self.color_words:
                 if k:
                     k.validate()
+        if self.stickers:
+            for k in self.stickers:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -1451,16 +1536,30 @@ class AsyncCreateClipsTaskRequest(TeaModel):
             return _map
 
         result = dict()
+        if self.close_music is not None:
+            result['CloseMusic'] = self.close_music
+        if self.close_subtitle is not None:
+            result['CloseSubtitle'] = self.close_subtitle
+        if self.close_voice is not None:
+            result['CloseVoice'] = self.close_voice
         result['ColorWords'] = []
         if self.color_words is not None:
             for k in self.color_words:
                 result['ColorWords'].append(k.to_map() if k else None)
+        if self.custom_voice_url is not None:
+            result['CustomVoiceUrl'] = self.custom_voice_url
+        if self.custom_voice_volume is not None:
+            result['CustomVoiceVolume'] = self.custom_voice_volume
         if self.height is not None:
             result['Height'] = self.height
         if self.music_url is not None:
             result['MusicUrl'] = self.music_url
         if self.music_volume is not None:
             result['MusicVolume'] = self.music_volume
+        result['Stickers'] = []
+        if self.stickers is not None:
+            for k in self.stickers:
+                result['Stickers'].append(k.to_map() if k else None)
         if self.subtitle_font_size is not None:
             result['SubtitleFontSize'] = self.subtitle_font_size
         if self.task_id is not None:
@@ -1477,17 +1576,32 @@ class AsyncCreateClipsTaskRequest(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('CloseMusic') is not None:
+            self.close_music = m.get('CloseMusic')
+        if m.get('CloseSubtitle') is not None:
+            self.close_subtitle = m.get('CloseSubtitle')
+        if m.get('CloseVoice') is not None:
+            self.close_voice = m.get('CloseVoice')
         self.color_words = []
         if m.get('ColorWords') is not None:
             for k in m.get('ColorWords'):
                 temp_model = AsyncCreateClipsTaskRequestColorWords()
                 self.color_words.append(temp_model.from_map(k))
+        if m.get('CustomVoiceUrl') is not None:
+            self.custom_voice_url = m.get('CustomVoiceUrl')
+        if m.get('CustomVoiceVolume') is not None:
+            self.custom_voice_volume = m.get('CustomVoiceVolume')
         if m.get('Height') is not None:
             self.height = m.get('Height')
         if m.get('MusicUrl') is not None:
             self.music_url = m.get('MusicUrl')
         if m.get('MusicVolume') is not None:
             self.music_volume = m.get('MusicVolume')
+        self.stickers = []
+        if m.get('Stickers') is not None:
+            for k in m.get('Stickers'):
+                temp_model = AsyncCreateClipsTaskRequestStickers()
+                self.stickers.append(temp_model.from_map(k))
         if m.get('SubtitleFontSize') is not None:
             self.subtitle_font_size = m.get('SubtitleFontSize')
         if m.get('TaskId') is not None:
@@ -1506,10 +1620,16 @@ class AsyncCreateClipsTaskRequest(TeaModel):
 class AsyncCreateClipsTaskShrinkRequest(TeaModel):
     def __init__(
         self,
+        close_music: bool = None,
+        close_subtitle: bool = None,
+        close_voice: bool = None,
         color_words_shrink: str = None,
+        custom_voice_url: str = None,
+        custom_voice_volume: int = None,
         height: int = None,
         music_url: str = None,
         music_volume: int = None,
+        stickers_shrink: str = None,
         subtitle_font_size: int = None,
         task_id: str = None,
         voice_style: str = None,
@@ -1517,10 +1637,16 @@ class AsyncCreateClipsTaskShrinkRequest(TeaModel):
         width: int = None,
         workspace_id: str = None,
     ):
+        self.close_music = close_music
+        self.close_subtitle = close_subtitle
+        self.close_voice = close_voice
         self.color_words_shrink = color_words_shrink
+        self.custom_voice_url = custom_voice_url
+        self.custom_voice_volume = custom_voice_volume
         self.height = height
         self.music_url = music_url
         self.music_volume = music_volume
+        self.stickers_shrink = stickers_shrink
         self.subtitle_font_size = subtitle_font_size
         # This parameter is required.
         self.task_id = task_id
@@ -1539,14 +1665,26 @@ class AsyncCreateClipsTaskShrinkRequest(TeaModel):
             return _map
 
         result = dict()
+        if self.close_music is not None:
+            result['CloseMusic'] = self.close_music
+        if self.close_subtitle is not None:
+            result['CloseSubtitle'] = self.close_subtitle
+        if self.close_voice is not None:
+            result['CloseVoice'] = self.close_voice
         if self.color_words_shrink is not None:
             result['ColorWords'] = self.color_words_shrink
+        if self.custom_voice_url is not None:
+            result['CustomVoiceUrl'] = self.custom_voice_url
+        if self.custom_voice_volume is not None:
+            result['CustomVoiceVolume'] = self.custom_voice_volume
         if self.height is not None:
             result['Height'] = self.height
         if self.music_url is not None:
             result['MusicUrl'] = self.music_url
         if self.music_volume is not None:
             result['MusicVolume'] = self.music_volume
+        if self.stickers_shrink is not None:
+            result['Stickers'] = self.stickers_shrink
         if self.subtitle_font_size is not None:
             result['SubtitleFontSize'] = self.subtitle_font_size
         if self.task_id is not None:
@@ -1563,14 +1701,26 @@ class AsyncCreateClipsTaskShrinkRequest(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('CloseMusic') is not None:
+            self.close_music = m.get('CloseMusic')
+        if m.get('CloseSubtitle') is not None:
+            self.close_subtitle = m.get('CloseSubtitle')
+        if m.get('CloseVoice') is not None:
+            self.close_voice = m.get('CloseVoice')
         if m.get('ColorWords') is not None:
             self.color_words_shrink = m.get('ColorWords')
+        if m.get('CustomVoiceUrl') is not None:
+            self.custom_voice_url = m.get('CustomVoiceUrl')
+        if m.get('CustomVoiceVolume') is not None:
+            self.custom_voice_volume = m.get('CustomVoiceVolume')
         if m.get('Height') is not None:
             self.height = m.get('Height')
         if m.get('MusicUrl') is not None:
             self.music_url = m.get('MusicUrl')
         if m.get('MusicVolume') is not None:
             self.music_volume = m.get('MusicVolume')
+        if m.get('Stickers') is not None:
+            self.stickers_shrink = m.get('Stickers')
         if m.get('SubtitleFontSize') is not None:
             self.subtitle_font_size = m.get('SubtitleFontSize')
         if m.get('TaskId') is not None:
@@ -2497,20 +2647,108 @@ class AsyncUploadVideoRequestSourceVideos(TeaModel):
         return self
 
 
+class AsyncUploadVideoRequestVideoRolesRoleUrls(TeaModel):
+    def __init__(
+        self,
+        role_file_name: str = None,
+        role_file_url: str = None,
+    ):
+        self.role_file_name = role_file_name
+        self.role_file_url = role_file_url
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.role_file_name is not None:
+            result['RoleFileName'] = self.role_file_name
+        if self.role_file_url is not None:
+            result['RoleFileUrl'] = self.role_file_url
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('RoleFileName') is not None:
+            self.role_file_name = m.get('RoleFileName')
+        if m.get('RoleFileUrl') is not None:
+            self.role_file_url = m.get('RoleFileUrl')
+        return self
+
+
+class AsyncUploadVideoRequestVideoRoles(TeaModel):
+    def __init__(
+        self,
+        role_info: str = None,
+        role_name: str = None,
+        role_urls: List[AsyncUploadVideoRequestVideoRolesRoleUrls] = None,
+    ):
+        self.role_info = role_info
+        self.role_name = role_name
+        self.role_urls = role_urls
+
+    def validate(self):
+        if self.role_urls:
+            for k in self.role_urls:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.role_info is not None:
+            result['RoleInfo'] = self.role_info
+        if self.role_name is not None:
+            result['RoleName'] = self.role_name
+        result['RoleUrls'] = []
+        if self.role_urls is not None:
+            for k in self.role_urls:
+                result['RoleUrls'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('RoleInfo') is not None:
+            self.role_info = m.get('RoleInfo')
+        if m.get('RoleName') is not None:
+            self.role_name = m.get('RoleName')
+        self.role_urls = []
+        if m.get('RoleUrls') is not None:
+            for k in m.get('RoleUrls'):
+                temp_model = AsyncUploadVideoRequestVideoRolesRoleUrls()
+                self.role_urls.append(temp_model.from_map(k))
+        return self
+
+
 class AsyncUploadVideoRequest(TeaModel):
     def __init__(
         self,
         anlysis_prompt: str = None,
+        face_identity_similarity_min_score: float = None,
         reference_video: AsyncUploadVideoRequestReferenceVideo = None,
+        remove_subtitle: bool = None,
         source_videos: List[AsyncUploadVideoRequestSourceVideos] = None,
         split_interval: int = None,
+        video_roles: List[AsyncUploadVideoRequestVideoRoles] = None,
+        video_shot_face_identity_count: int = None,
         workspace_id: str = None,
     ):
         self.anlysis_prompt = anlysis_prompt
+        self.face_identity_similarity_min_score = face_identity_similarity_min_score
         self.reference_video = reference_video
+        self.remove_subtitle = remove_subtitle
         # This parameter is required.
         self.source_videos = source_videos
         self.split_interval = split_interval
+        self.video_roles = video_roles
+        self.video_shot_face_identity_count = video_shot_face_identity_count
         # This parameter is required.
         self.workspace_id = workspace_id
 
@@ -2521,6 +2759,10 @@ class AsyncUploadVideoRequest(TeaModel):
             for k in self.source_videos:
                 if k:
                     k.validate()
+        if self.video_roles:
+            for k in self.video_roles:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2530,14 +2772,24 @@ class AsyncUploadVideoRequest(TeaModel):
         result = dict()
         if self.anlysis_prompt is not None:
             result['AnlysisPrompt'] = self.anlysis_prompt
+        if self.face_identity_similarity_min_score is not None:
+            result['FaceIdentitySimilarityMinScore'] = self.face_identity_similarity_min_score
         if self.reference_video is not None:
             result['ReferenceVideo'] = self.reference_video.to_map()
+        if self.remove_subtitle is not None:
+            result['RemoveSubtitle'] = self.remove_subtitle
         result['SourceVideos'] = []
         if self.source_videos is not None:
             for k in self.source_videos:
                 result['SourceVideos'].append(k.to_map() if k else None)
         if self.split_interval is not None:
             result['SplitInterval'] = self.split_interval
+        result['VideoRoles'] = []
+        if self.video_roles is not None:
+            for k in self.video_roles:
+                result['VideoRoles'].append(k.to_map() if k else None)
+        if self.video_shot_face_identity_count is not None:
+            result['VideoShotFaceIdentityCount'] = self.video_shot_face_identity_count
         if self.workspace_id is not None:
             result['WorkspaceId'] = self.workspace_id
         return result
@@ -2546,9 +2798,13 @@ class AsyncUploadVideoRequest(TeaModel):
         m = m or dict()
         if m.get('AnlysisPrompt') is not None:
             self.anlysis_prompt = m.get('AnlysisPrompt')
+        if m.get('FaceIdentitySimilarityMinScore') is not None:
+            self.face_identity_similarity_min_score = m.get('FaceIdentitySimilarityMinScore')
         if m.get('ReferenceVideo') is not None:
             temp_model = AsyncUploadVideoRequestReferenceVideo()
             self.reference_video = temp_model.from_map(m['ReferenceVideo'])
+        if m.get('RemoveSubtitle') is not None:
+            self.remove_subtitle = m.get('RemoveSubtitle')
         self.source_videos = []
         if m.get('SourceVideos') is not None:
             for k in m.get('SourceVideos'):
@@ -2556,6 +2812,13 @@ class AsyncUploadVideoRequest(TeaModel):
                 self.source_videos.append(temp_model.from_map(k))
         if m.get('SplitInterval') is not None:
             self.split_interval = m.get('SplitInterval')
+        self.video_roles = []
+        if m.get('VideoRoles') is not None:
+            for k in m.get('VideoRoles'):
+                temp_model = AsyncUploadVideoRequestVideoRoles()
+                self.video_roles.append(temp_model.from_map(k))
+        if m.get('VideoShotFaceIdentityCount') is not None:
+            self.video_shot_face_identity_count = m.get('VideoShotFaceIdentityCount')
         if m.get('WorkspaceId') is not None:
             self.workspace_id = m.get('WorkspaceId')
         return self
@@ -2565,16 +2828,24 @@ class AsyncUploadVideoShrinkRequest(TeaModel):
     def __init__(
         self,
         anlysis_prompt: str = None,
+        face_identity_similarity_min_score: float = None,
         reference_video_shrink: str = None,
+        remove_subtitle: bool = None,
         source_videos_shrink: str = None,
         split_interval: int = None,
+        video_roles_shrink: str = None,
+        video_shot_face_identity_count: int = None,
         workspace_id: str = None,
     ):
         self.anlysis_prompt = anlysis_prompt
+        self.face_identity_similarity_min_score = face_identity_similarity_min_score
         self.reference_video_shrink = reference_video_shrink
+        self.remove_subtitle = remove_subtitle
         # This parameter is required.
         self.source_videos_shrink = source_videos_shrink
         self.split_interval = split_interval
+        self.video_roles_shrink = video_roles_shrink
+        self.video_shot_face_identity_count = video_shot_face_identity_count
         # This parameter is required.
         self.workspace_id = workspace_id
 
@@ -2589,12 +2860,20 @@ class AsyncUploadVideoShrinkRequest(TeaModel):
         result = dict()
         if self.anlysis_prompt is not None:
             result['AnlysisPrompt'] = self.anlysis_prompt
+        if self.face_identity_similarity_min_score is not None:
+            result['FaceIdentitySimilarityMinScore'] = self.face_identity_similarity_min_score
         if self.reference_video_shrink is not None:
             result['ReferenceVideo'] = self.reference_video_shrink
+        if self.remove_subtitle is not None:
+            result['RemoveSubtitle'] = self.remove_subtitle
         if self.source_videos_shrink is not None:
             result['SourceVideos'] = self.source_videos_shrink
         if self.split_interval is not None:
             result['SplitInterval'] = self.split_interval
+        if self.video_roles_shrink is not None:
+            result['VideoRoles'] = self.video_roles_shrink
+        if self.video_shot_face_identity_count is not None:
+            result['VideoShotFaceIdentityCount'] = self.video_shot_face_identity_count
         if self.workspace_id is not None:
             result['WorkspaceId'] = self.workspace_id
         return result
@@ -2603,12 +2882,20 @@ class AsyncUploadVideoShrinkRequest(TeaModel):
         m = m or dict()
         if m.get('AnlysisPrompt') is not None:
             self.anlysis_prompt = m.get('AnlysisPrompt')
+        if m.get('FaceIdentitySimilarityMinScore') is not None:
+            self.face_identity_similarity_min_score = m.get('FaceIdentitySimilarityMinScore')
         if m.get('ReferenceVideo') is not None:
             self.reference_video_shrink = m.get('ReferenceVideo')
+        if m.get('RemoveSubtitle') is not None:
+            self.remove_subtitle = m.get('RemoveSubtitle')
         if m.get('SourceVideos') is not None:
             self.source_videos_shrink = m.get('SourceVideos')
         if m.get('SplitInterval') is not None:
             self.split_interval = m.get('SplitInterval')
+        if m.get('VideoRoles') is not None:
+            self.video_roles_shrink = m.get('VideoRoles')
+        if m.get('VideoShotFaceIdentityCount') is not None:
+            self.video_shot_face_identity_count = m.get('VideoShotFaceIdentityCount')
         if m.get('WorkspaceId') is not None:
             self.workspace_id = m.get('WorkspaceId')
         return self
@@ -4496,6 +4783,193 @@ class CreateDatasetResponse(TeaModel):
         return self
 
 
+class CreateGeneralConfigRequest(TeaModel):
+    def __init__(
+        self,
+        config_key: str = None,
+        config_value: str = None,
+        workspace_id: str = None,
+    ):
+        # This parameter is required.
+        self.config_key = config_key
+        # This parameter is required.
+        self.config_value = config_value
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.config_value is not None:
+            result['ConfigValue'] = self.config_value
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('ConfigValue') is not None:
+            self.config_value = m.get('ConfigValue')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class CreateGeneralConfigResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        config_desc: str = None,
+        config_key: str = None,
+        config_value: str = None,
+        config_value_type: str = None,
+    ):
+        self.config_desc = config_desc
+        self.config_key = config_key
+        self.config_value = config_value
+        self.config_value_type = config_value_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.config_desc is not None:
+            result['ConfigDesc'] = self.config_desc
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.config_value is not None:
+            result['ConfigValue'] = self.config_value
+        if self.config_value_type is not None:
+            result['ConfigValueType'] = self.config_value_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConfigDesc') is not None:
+            self.config_desc = m.get('ConfigDesc')
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('ConfigValue') is not None:
+            self.config_value = m.get('ConfigValue')
+        if m.get('ConfigValueType') is not None:
+            self.config_value_type = m.get('ConfigValueType')
+        return self
+
+
+class CreateGeneralConfigResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: CreateGeneralConfigResponseBodyData = None,
+        http_status_code: int = None,
+        message: str = None,
+        request_id: str = None,
+        success: bool = None,
+    ):
+        self.code = code
+        self.data = data
+        self.http_status_code = http_status_code
+        self.message = message
+        self.request_id = request_id
+        self.success = success
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        if self.data is not None:
+            result['Data'] = self.data.to_map()
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.message is not None:
+            result['Message'] = self.message
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        if m.get('Data') is not None:
+            temp_model = CreateGeneralConfigResponseBodyData()
+            self.data = temp_model.from_map(m['Data'])
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
+        return self
+
+
+class CreateGeneralConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CreateGeneralConfigResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = CreateGeneralConfigResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateGeneratedContentRequest(TeaModel):
     def __init__(
         self,
@@ -6191,6 +6665,133 @@ class DeleteFactAuditUrlResponse(TeaModel):
         return self
 
 
+class DeleteGeneralConfigRequest(TeaModel):
+    def __init__(
+        self,
+        config_key: str = None,
+        workspace_id: str = None,
+    ):
+        # This parameter is required.
+        self.config_key = config_key
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class DeleteGeneralConfigResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        http_status_code: int = None,
+        message: str = None,
+        request_id: str = None,
+        success: bool = None,
+    ):
+        self.code = code
+        self.http_status_code = http_status_code
+        self.message = message
+        self.request_id = request_id
+        self.success = success
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.message is not None:
+            result['Message'] = self.message
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
+        return self
+
+
+class DeleteGeneralConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteGeneralConfigResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = DeleteGeneralConfigResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class DeleteGeneratedContentRequest(TeaModel):
     def __init__(
         self,
@@ -11291,6 +11892,75 @@ class GetAutoClipsTaskInfoResponseBodyDataColorWords(TeaModel):
         return self
 
 
+class GetAutoClipsTaskInfoResponseBodyDataStickers(TeaModel):
+    def __init__(
+        self,
+        duration: int = None,
+        dync_frames: int = None,
+        height: int = None,
+        timeline_in: int = None,
+        url: str = None,
+        width: int = None,
+        x: float = None,
+        y: float = None,
+    ):
+        self.duration = duration
+        self.dync_frames = dync_frames
+        self.height = height
+        self.timeline_in = timeline_in
+        self.url = url
+        self.width = width
+        self.x = x
+        self.y = y
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.duration is not None:
+            result['Duration'] = self.duration
+        if self.dync_frames is not None:
+            result['DyncFrames'] = self.dync_frames
+        if self.height is not None:
+            result['Height'] = self.height
+        if self.timeline_in is not None:
+            result['TimelineIn'] = self.timeline_in
+        if self.url is not None:
+            result['Url'] = self.url
+        if self.width is not None:
+            result['Width'] = self.width
+        if self.x is not None:
+            result['X'] = self.x
+        if self.y is not None:
+            result['Y'] = self.y
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Duration') is not None:
+            self.duration = m.get('Duration')
+        if m.get('DyncFrames') is not None:
+            self.dync_frames = m.get('DyncFrames')
+        if m.get('Height') is not None:
+            self.height = m.get('Height')
+        if m.get('TimelineIn') is not None:
+            self.timeline_in = m.get('TimelineIn')
+        if m.get('Url') is not None:
+            self.url = m.get('Url')
+        if m.get('Width') is not None:
+            self.width = m.get('Width')
+        if m.get('X') is not None:
+            self.x = m.get('X')
+        if m.get('Y') is not None:
+            self.y = m.get('Y')
+        return self
+
+
 class GetAutoClipsTaskInfoResponseBodyDataTimelinesClips(TeaModel):
     def __init__(
         self,
@@ -11410,8 +12080,13 @@ class GetAutoClipsTaskInfoResponseBodyDataTimelines(TeaModel):
 class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
     def __init__(
         self,
+        close_music: bool = None,
+        close_subtitle: bool = None,
+        close_voice: bool = None,
         color_words: List[GetAutoClipsTaskInfoResponseBodyDataColorWords] = None,
         content: str = None,
+        custom_voice_url: str = None,
+        custom_voice_volume: int = None,
         error_message: str = None,
         media_cloud_timeline: str = None,
         music_style: str = None,
@@ -11420,14 +12095,20 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
         output_video_url: str = None,
         status: int = None,
         step: str = None,
+        stickers: List[GetAutoClipsTaskInfoResponseBodyDataStickers] = None,
         subtitle_font_size: int = None,
         task_id: str = None,
         timelines: List[GetAutoClipsTaskInfoResponseBodyDataTimelines] = None,
         voice_style: str = None,
         voice_volume: int = None,
     ):
+        self.close_music = close_music
+        self.close_subtitle = close_subtitle
+        self.close_voice = close_voice
         self.color_words = color_words
         self.content = content
+        self.custom_voice_url = custom_voice_url
+        self.custom_voice_volume = custom_voice_volume
         self.error_message = error_message
         self.media_cloud_timeline = media_cloud_timeline
         self.music_style = music_style
@@ -11436,6 +12117,7 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
         self.output_video_url = output_video_url
         self.status = status
         self.step = step
+        self.stickers = stickers
         self.subtitle_font_size = subtitle_font_size
         self.task_id = task_id
         self.timelines = timelines
@@ -11447,6 +12129,10 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
             for k in self.color_words:
                 if k:
                     k.validate()
+        if self.stickers:
+            for k in self.stickers:
+                if k:
+                    k.validate()
         if self.timelines:
             for k in self.timelines:
                 if k:
@@ -11458,12 +12144,22 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
             return _map
 
         result = dict()
+        if self.close_music is not None:
+            result['CloseMusic'] = self.close_music
+        if self.close_subtitle is not None:
+            result['CloseSubtitle'] = self.close_subtitle
+        if self.close_voice is not None:
+            result['CloseVoice'] = self.close_voice
         result['ColorWords'] = []
         if self.color_words is not None:
             for k in self.color_words:
                 result['ColorWords'].append(k.to_map() if k else None)
         if self.content is not None:
             result['Content'] = self.content
+        if self.custom_voice_url is not None:
+            result['CustomVoiceUrl'] = self.custom_voice_url
+        if self.custom_voice_volume is not None:
+            result['CustomVoiceVolume'] = self.custom_voice_volume
         if self.error_message is not None:
             result['ErrorMessage'] = self.error_message
         if self.media_cloud_timeline is not None:
@@ -11480,6 +12176,10 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
             result['Status'] = self.status
         if self.step is not None:
             result['Step'] = self.step
+        result['Stickers'] = []
+        if self.stickers is not None:
+            for k in self.stickers:
+                result['Stickers'].append(k.to_map() if k else None)
         if self.subtitle_font_size is not None:
             result['SubtitleFontSize'] = self.subtitle_font_size
         if self.task_id is not None:
@@ -11496,6 +12196,12 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('CloseMusic') is not None:
+            self.close_music = m.get('CloseMusic')
+        if m.get('CloseSubtitle') is not None:
+            self.close_subtitle = m.get('CloseSubtitle')
+        if m.get('CloseVoice') is not None:
+            self.close_voice = m.get('CloseVoice')
         self.color_words = []
         if m.get('ColorWords') is not None:
             for k in m.get('ColorWords'):
@@ -11503,6 +12209,10 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
                 self.color_words.append(temp_model.from_map(k))
         if m.get('Content') is not None:
             self.content = m.get('Content')
+        if m.get('CustomVoiceUrl') is not None:
+            self.custom_voice_url = m.get('CustomVoiceUrl')
+        if m.get('CustomVoiceVolume') is not None:
+            self.custom_voice_volume = m.get('CustomVoiceVolume')
         if m.get('ErrorMessage') is not None:
             self.error_message = m.get('ErrorMessage')
         if m.get('MediaCloudTimeline') is not None:
@@ -11519,6 +12229,11 @@ class GetAutoClipsTaskInfoResponseBodyData(TeaModel):
             self.status = m.get('Status')
         if m.get('Step') is not None:
             self.step = m.get('Step')
+        self.stickers = []
+        if m.get('Stickers') is not None:
+            for k in m.get('Stickers'):
+                temp_model = GetAutoClipsTaskInfoResponseBodyDataStickers()
+                self.stickers.append(temp_model.from_map(k))
         if m.get('SubtitleFontSize') is not None:
             self.subtitle_font_size = m.get('SubtitleFontSize')
         if m.get('TaskId') is not None:
@@ -16033,16 +16748,16 @@ class GetFileContentLengthResponse(TeaModel):
         return self
 
 
-class GetGeneratedContentRequest(TeaModel):
+class GetGeneralConfigRequest(TeaModel):
     def __init__(
         self,
-        agent_key: str = None,
-        id: int = None,
+        config_key: str = None,
+        workspace_id: str = None,
     ):
         # This parameter is required.
-        self.agent_key = agent_key
+        self.config_key = config_key
         # This parameter is required.
-        self.id = id
+        self.workspace_id = workspace_id
 
     def validate(self):
         pass
@@ -16053,57 +16768,33 @@ class GetGeneratedContentRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.agent_key is not None:
-            result['AgentKey'] = self.agent_key
-        if self.id is not None:
-            result['Id'] = self.id
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('AgentKey') is not None:
-            self.agent_key = m.get('AgentKey')
-        if m.get('Id') is not None:
-            self.id = m.get('Id')
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
         return self
 
 
-class GetGeneratedContentResponseBodyData(TeaModel):
+class GetGeneralConfigResponseBodyData(TeaModel):
     def __init__(
         self,
-        content: str = None,
-        content_domain: str = None,
-        content_text: str = None,
-        create_time: str = None,
-        create_user: str = None,
-        device_id: str = None,
-        id: int = None,
-        ignore_content_audit_words: str = None,
-        keyword_list: List[str] = None,
-        keywords: str = None,
-        prompt: str = None,
-        task_id: str = None,
-        title: str = None,
-        update_time: str = None,
-        update_user: str = None,
-        uuid: str = None,
+        config_desc: str = None,
+        config_key: str = None,
+        config_value: str = None,
+        config_value_type: str = None,
     ):
-        self.content = content
-        self.content_domain = content_domain
-        self.content_text = content_text
-        self.create_time = create_time
-        self.create_user = create_user
-        self.device_id = device_id
-        self.id = id
-        self.ignore_content_audit_words = ignore_content_audit_words
-        self.keyword_list = keyword_list
-        self.keywords = keywords
-        self.prompt = prompt
-        self.task_id = task_id
-        self.title = title
-        self.update_time = update_time
-        self.update_user = update_user
-        self.uuid = uuid
+        self.config_desc = config_desc
+        self.config_key = config_key
+        self.config_value = config_value
+        self.config_value_type = config_value_type
 
     def validate(self):
         pass
@@ -16114,82 +16805,286 @@ class GetGeneratedContentResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.content is not None:
-            result['Content'] = self.content
-        if self.content_domain is not None:
-            result['ContentDomain'] = self.content_domain
-        if self.content_text is not None:
-            result['ContentText'] = self.content_text
-        if self.create_time is not None:
-            result['CreateTime'] = self.create_time
-        if self.create_user is not None:
-            result['CreateUser'] = self.create_user
-        if self.device_id is not None:
-            result['DeviceId'] = self.device_id
-        if self.id is not None:
-            result['Id'] = self.id
-        if self.ignore_content_audit_words is not None:
-            result['IgnoreContentAuditWords'] = self.ignore_content_audit_words
-        if self.keyword_list is not None:
-            result['KeywordList'] = self.keyword_list
-        if self.keywords is not None:
-            result['Keywords'] = self.keywords
-        if self.prompt is not None:
-            result['Prompt'] = self.prompt
-        if self.task_id is not None:
-            result['TaskId'] = self.task_id
-        if self.title is not None:
-            result['Title'] = self.title
-        if self.update_time is not None:
-            result['UpdateTime'] = self.update_time
-        if self.update_user is not None:
-            result['UpdateUser'] = self.update_user
-        if self.uuid is not None:
-            result['Uuid'] = self.uuid
+        if self.config_desc is not None:
+            result['ConfigDesc'] = self.config_desc
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.config_value is not None:
+            result['ConfigValue'] = self.config_value
+        if self.config_value_type is not None:
+            result['ConfigValueType'] = self.config_value_type
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Content') is not None:
-            self.content = m.get('Content')
-        if m.get('ContentDomain') is not None:
-            self.content_domain = m.get('ContentDomain')
-        if m.get('ContentText') is not None:
-            self.content_text = m.get('ContentText')
-        if m.get('CreateTime') is not None:
-            self.create_time = m.get('CreateTime')
-        if m.get('CreateUser') is not None:
-            self.create_user = m.get('CreateUser')
-        if m.get('DeviceId') is not None:
-            self.device_id = m.get('DeviceId')
-        if m.get('Id') is not None:
-            self.id = m.get('Id')
-        if m.get('IgnoreContentAuditWords') is not None:
-            self.ignore_content_audit_words = m.get('IgnoreContentAuditWords')
-        if m.get('KeywordList') is not None:
-            self.keyword_list = m.get('KeywordList')
-        if m.get('Keywords') is not None:
-            self.keywords = m.get('Keywords')
-        if m.get('Prompt') is not None:
-            self.prompt = m.get('Prompt')
-        if m.get('TaskId') is not None:
-            self.task_id = m.get('TaskId')
-        if m.get('Title') is not None:
-            self.title = m.get('Title')
-        if m.get('UpdateTime') is not None:
-            self.update_time = m.get('UpdateTime')
-        if m.get('UpdateUser') is not None:
-            self.update_user = m.get('UpdateUser')
-        if m.get('Uuid') is not None:
-            self.uuid = m.get('Uuid')
+        if m.get('ConfigDesc') is not None:
+            self.config_desc = m.get('ConfigDesc')
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('ConfigValue') is not None:
+            self.config_value = m.get('ConfigValue')
+        if m.get('ConfigValueType') is not None:
+            self.config_value_type = m.get('ConfigValueType')
         return self
 
 
-class GetGeneratedContentResponseBody(TeaModel):
+class GetGeneralConfigResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: GetGeneratedContentResponseBodyData = None,
+        data: GetGeneralConfigResponseBodyData = None,
+        http_status_code: int = None,
+        message: str = None,
+        request_id: str = None,
+        success: bool = None,
+    ):
+        self.code = code
+        self.data = data
+        self.http_status_code = http_status_code
+        self.message = message
+        self.request_id = request_id
+        self.success = success
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        if self.data is not None:
+            result['Data'] = self.data.to_map()
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.message is not None:
+            result['Message'] = self.message
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        if m.get('Data') is not None:
+            temp_model = GetGeneralConfigResponseBodyData()
+            self.data = temp_model.from_map(m['Data'])
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
+        return self
+
+
+class GetGeneralConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetGeneralConfigResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetGeneralConfigResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetGeneratedContentRequest(TeaModel):
+    def __init__(
+        self,
+        agent_key: str = None,
+        id: int = None,
+    ):
+        # This parameter is required.
+        self.agent_key = agent_key
+        # This parameter is required.
+        self.id = id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.agent_key is not None:
+            result['AgentKey'] = self.agent_key
+        if self.id is not None:
+            result['Id'] = self.id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AgentKey') is not None:
+            self.agent_key = m.get('AgentKey')
+        if m.get('Id') is not None:
+            self.id = m.get('Id')
+        return self
+
+
+class GetGeneratedContentResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        content: str = None,
+        content_domain: str = None,
+        content_text: str = None,
+        create_time: str = None,
+        create_user: str = None,
+        device_id: str = None,
+        id: int = None,
+        ignore_content_audit_words: str = None,
+        keyword_list: List[str] = None,
+        keywords: str = None,
+        prompt: str = None,
+        task_id: str = None,
+        title: str = None,
+        update_time: str = None,
+        update_user: str = None,
+        uuid: str = None,
+    ):
+        self.content = content
+        self.content_domain = content_domain
+        self.content_text = content_text
+        self.create_time = create_time
+        self.create_user = create_user
+        self.device_id = device_id
+        self.id = id
+        self.ignore_content_audit_words = ignore_content_audit_words
+        self.keyword_list = keyword_list
+        self.keywords = keywords
+        self.prompt = prompt
+        self.task_id = task_id
+        self.title = title
+        self.update_time = update_time
+        self.update_user = update_user
+        self.uuid = uuid
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.content is not None:
+            result['Content'] = self.content
+        if self.content_domain is not None:
+            result['ContentDomain'] = self.content_domain
+        if self.content_text is not None:
+            result['ContentText'] = self.content_text
+        if self.create_time is not None:
+            result['CreateTime'] = self.create_time
+        if self.create_user is not None:
+            result['CreateUser'] = self.create_user
+        if self.device_id is not None:
+            result['DeviceId'] = self.device_id
+        if self.id is not None:
+            result['Id'] = self.id
+        if self.ignore_content_audit_words is not None:
+            result['IgnoreContentAuditWords'] = self.ignore_content_audit_words
+        if self.keyword_list is not None:
+            result['KeywordList'] = self.keyword_list
+        if self.keywords is not None:
+            result['Keywords'] = self.keywords
+        if self.prompt is not None:
+            result['Prompt'] = self.prompt
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.title is not None:
+            result['Title'] = self.title
+        if self.update_time is not None:
+            result['UpdateTime'] = self.update_time
+        if self.update_user is not None:
+            result['UpdateUser'] = self.update_user
+        if self.uuid is not None:
+            result['Uuid'] = self.uuid
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Content') is not None:
+            self.content = m.get('Content')
+        if m.get('ContentDomain') is not None:
+            self.content_domain = m.get('ContentDomain')
+        if m.get('ContentText') is not None:
+            self.content_text = m.get('ContentText')
+        if m.get('CreateTime') is not None:
+            self.create_time = m.get('CreateTime')
+        if m.get('CreateUser') is not None:
+            self.create_user = m.get('CreateUser')
+        if m.get('DeviceId') is not None:
+            self.device_id = m.get('DeviceId')
+        if m.get('Id') is not None:
+            self.id = m.get('Id')
+        if m.get('IgnoreContentAuditWords') is not None:
+            self.ignore_content_audit_words = m.get('IgnoreContentAuditWords')
+        if m.get('KeywordList') is not None:
+            self.keyword_list = m.get('KeywordList')
+        if m.get('Keywords') is not None:
+            self.keywords = m.get('Keywords')
+        if m.get('Prompt') is not None:
+            self.prompt = m.get('Prompt')
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('Title') is not None:
+            self.title = m.get('Title')
+        if m.get('UpdateTime') is not None:
+            self.update_time = m.get('UpdateTime')
+        if m.get('UpdateUser') is not None:
+            self.update_user = m.get('UpdateUser')
+        if m.get('Uuid') is not None:
+            self.uuid = m.get('Uuid')
+        return self
+
+
+class GetGeneratedContentResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: GetGeneratedContentResponseBodyData = None,
         http_status_code: int = None,
         message: str = None,
         request_id: str = None,
@@ -26629,23 +27524,37 @@ class ListDocsResponse(TeaModel):
         return self
 
 
-class ListFreshViewPointsRequest(TeaModel):
+class ListDocumentRetrieveRequest(TeaModel):
     def __init__(
         self,
-        agent_key: str = None,
+        content_type: str = None,
+        element_scope: str = None,
+        end_date: str = None,
         max_results: int = None,
         next_token: str = None,
-        topic: str = None,
-        topic_source: str = None,
+        office: str = None,
+        query: str = None,
+        region: str = None,
+        source: str = None,
+        start_date: str = None,
+        sub_content_type: str = None,
+        word_size: str = None,
+        workspace_id: str = None,
     ):
-        # This parameter is required.
-        self.agent_key = agent_key
+        self.content_type = content_type
+        self.element_scope = element_scope
+        self.end_date = end_date
         self.max_results = max_results
         self.next_token = next_token
+        self.office = office
+        self.query = query
+        self.region = region
+        self.source = source
+        self.start_date = start_date
+        self.sub_content_type = sub_content_type
+        self.word_size = word_size
         # This parameter is required.
-        self.topic = topic
-        # This parameter is required.
-        self.topic_source = topic_source
+        self.workspace_id = workspace_id
 
     def validate(self):
         pass
@@ -26656,41 +27565,79 @@ class ListFreshViewPointsRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.agent_key is not None:
-            result['AgentKey'] = self.agent_key
+        if self.content_type is not None:
+            result['ContentType'] = self.content_type
+        if self.element_scope is not None:
+            result['ElementScope'] = self.element_scope
+        if self.end_date is not None:
+            result['EndDate'] = self.end_date
         if self.max_results is not None:
             result['MaxResults'] = self.max_results
         if self.next_token is not None:
             result['NextToken'] = self.next_token
-        if self.topic is not None:
-            result['Topic'] = self.topic
-        if self.topic_source is not None:
-            result['TopicSource'] = self.topic_source
+        if self.office is not None:
+            result['Office'] = self.office
+        if self.query is not None:
+            result['Query'] = self.query
+        if self.region is not None:
+            result['Region'] = self.region
+        if self.source is not None:
+            result['Source'] = self.source
+        if self.start_date is not None:
+            result['StartDate'] = self.start_date
+        if self.sub_content_type is not None:
+            result['SubContentType'] = self.sub_content_type
+        if self.word_size is not None:
+            result['WordSize'] = self.word_size
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('AgentKey') is not None:
-            self.agent_key = m.get('AgentKey')
+        if m.get('ContentType') is not None:
+            self.content_type = m.get('ContentType')
+        if m.get('ElementScope') is not None:
+            self.element_scope = m.get('ElementScope')
+        if m.get('EndDate') is not None:
+            self.end_date = m.get('EndDate')
         if m.get('MaxResults') is not None:
             self.max_results = m.get('MaxResults')
         if m.get('NextToken') is not None:
             self.next_token = m.get('NextToken')
-        if m.get('Topic') is not None:
-            self.topic = m.get('Topic')
-        if m.get('TopicSource') is not None:
-            self.topic_source = m.get('TopicSource')
+        if m.get('Office') is not None:
+            self.office = m.get('Office')
+        if m.get('Query') is not None:
+            self.query = m.get('Query')
+        if m.get('Region') is not None:
+            self.region = m.get('Region')
+        if m.get('Source') is not None:
+            self.source = m.get('Source')
+        if m.get('StartDate') is not None:
+            self.start_date = m.get('StartDate')
+        if m.get('SubContentType') is not None:
+            self.sub_content_type = m.get('SubContentType')
+        if m.get('WordSize') is not None:
+            self.word_size = m.get('WordSize')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
         return self
 
 
-class ListFreshViewPointsResponseBodyDataOutlines(TeaModel):
+class ListDocumentRetrieveResponseBodyData(TeaModel):
     def __init__(
         self,
-        outline: str = None,
-        summary: str = None,
+        essay: str = None,
+        issuing_authority: str = None,
+        link: str = None,
+        publication_date: str = None,
+        title: str = None,
     ):
-        self.outline = outline
-        self.summary = summary
+        self.essay = essay
+        self.issuing_authority = issuing_authority
+        self.link = link
+        self.publication_date = publication_date
+        self.title = title
 
     def validate(self):
         pass
@@ -26701,73 +27648,297 @@ class ListFreshViewPointsResponseBodyDataOutlines(TeaModel):
             return _map
 
         result = dict()
-        if self.outline is not None:
-            result['Outline'] = self.outline
-        if self.summary is not None:
-            result['Summary'] = self.summary
-        return result
-
-    def from_map(self, m: dict = None):
-        m = m or dict()
-        if m.get('Outline') is not None:
-            self.outline = m.get('Outline')
-        if m.get('Summary') is not None:
-            self.summary = m.get('Summary')
-        return self
-
-
-class ListFreshViewPointsResponseBodyData(TeaModel):
-    def __init__(
-        self,
-        outlines: List[ListFreshViewPointsResponseBodyDataOutlines] = None,
-        point: str = None,
-        summary: str = None,
-    ):
-        self.outlines = outlines
-        self.point = point
-        self.summary = summary
-
-    def validate(self):
-        if self.outlines:
-            for k in self.outlines:
-                if k:
-                    k.validate()
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        result['Outlines'] = []
-        if self.outlines is not None:
-            for k in self.outlines:
-                result['Outlines'].append(k.to_map() if k else None)
-        if self.point is not None:
-            result['Point'] = self.point
-        if self.summary is not None:
-            result['Summary'] = self.summary
+        if self.essay is not None:
+            result['Essay'] = self.essay
+        if self.issuing_authority is not None:
+            result['IssuingAuthority'] = self.issuing_authority
+        if self.link is not None:
+            result['Link'] = self.link
+        if self.publication_date is not None:
+            result['PublicationDate'] = self.publication_date
+        if self.title is not None:
+            result['Title'] = self.title
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        self.outlines = []
-        if m.get('Outlines') is not None:
-            for k in m.get('Outlines'):
-                temp_model = ListFreshViewPointsResponseBodyDataOutlines()
-                self.outlines.append(temp_model.from_map(k))
-        if m.get('Point') is not None:
-            self.point = m.get('Point')
-        if m.get('Summary') is not None:
-            self.summary = m.get('Summary')
+        if m.get('Essay') is not None:
+            self.essay = m.get('Essay')
+        if m.get('IssuingAuthority') is not None:
+            self.issuing_authority = m.get('IssuingAuthority')
+        if m.get('Link') is not None:
+            self.link = m.get('Link')
+        if m.get('PublicationDate') is not None:
+            self.publication_date = m.get('PublicationDate')
+        if m.get('Title') is not None:
+            self.title = m.get('Title')
         return self
 
 
-class ListFreshViewPointsResponseBody(TeaModel):
+class ListDocumentRetrieveResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: List[ListFreshViewPointsResponseBodyData] = None,
+        data: List[ListDocumentRetrieveResponseBodyData] = None,
+        http_status_code: int = None,
+        max_results: int = None,
+        message: str = None,
+        next_token: str = None,
+        request_id: str = None,
+        success: bool = None,
+        total_count: int = None,
+    ):
+        self.code = code
+        self.data = data
+        self.http_status_code = http_status_code
+        self.max_results = max_results
+        self.message = message
+        self.next_token = next_token
+        # Id of the request
+        self.request_id = request_id
+        self.success = success
+        self.total_count = total_count
+
+    def validate(self):
+        if self.data:
+            for k in self.data:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        result['Data'] = []
+        if self.data is not None:
+            for k in self.data:
+                result['Data'].append(k.to_map() if k else None)
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.max_results is not None:
+            result['MaxResults'] = self.max_results
+        if self.message is not None:
+            result['Message'] = self.message
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
+        if self.total_count is not None:
+            result['TotalCount'] = self.total_count
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        self.data = []
+        if m.get('Data') is not None:
+            for k in m.get('Data'):
+                temp_model = ListDocumentRetrieveResponseBodyData()
+                self.data.append(temp_model.from_map(k))
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('MaxResults') is not None:
+            self.max_results = m.get('MaxResults')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('NextToken') is not None:
+            self.next_token = m.get('NextToken')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
+        if m.get('TotalCount') is not None:
+            self.total_count = m.get('TotalCount')
+        return self
+
+
+class ListDocumentRetrieveResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListDocumentRetrieveResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListDocumentRetrieveResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListFreshViewPointsRequest(TeaModel):
+    def __init__(
+        self,
+        agent_key: str = None,
+        max_results: int = None,
+        next_token: str = None,
+        topic: str = None,
+        topic_source: str = None,
+    ):
+        # This parameter is required.
+        self.agent_key = agent_key
+        self.max_results = max_results
+        self.next_token = next_token
+        # This parameter is required.
+        self.topic = topic
+        # This parameter is required.
+        self.topic_source = topic_source
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.agent_key is not None:
+            result['AgentKey'] = self.agent_key
+        if self.max_results is not None:
+            result['MaxResults'] = self.max_results
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
+        if self.topic is not None:
+            result['Topic'] = self.topic
+        if self.topic_source is not None:
+            result['TopicSource'] = self.topic_source
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AgentKey') is not None:
+            self.agent_key = m.get('AgentKey')
+        if m.get('MaxResults') is not None:
+            self.max_results = m.get('MaxResults')
+        if m.get('NextToken') is not None:
+            self.next_token = m.get('NextToken')
+        if m.get('Topic') is not None:
+            self.topic = m.get('Topic')
+        if m.get('TopicSource') is not None:
+            self.topic_source = m.get('TopicSource')
+        return self
+
+
+class ListFreshViewPointsResponseBodyDataOutlines(TeaModel):
+    def __init__(
+        self,
+        outline: str = None,
+        summary: str = None,
+    ):
+        self.outline = outline
+        self.summary = summary
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.outline is not None:
+            result['Outline'] = self.outline
+        if self.summary is not None:
+            result['Summary'] = self.summary
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Outline') is not None:
+            self.outline = m.get('Outline')
+        if m.get('Summary') is not None:
+            self.summary = m.get('Summary')
+        return self
+
+
+class ListFreshViewPointsResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        outlines: List[ListFreshViewPointsResponseBodyDataOutlines] = None,
+        point: str = None,
+        summary: str = None,
+    ):
+        self.outlines = outlines
+        self.point = point
+        self.summary = summary
+
+    def validate(self):
+        if self.outlines:
+            for k in self.outlines:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        result['Outlines'] = []
+        if self.outlines is not None:
+            for k in self.outlines:
+                result['Outlines'].append(k.to_map() if k else None)
+        if self.point is not None:
+            result['Point'] = self.point
+        if self.summary is not None:
+            result['Summary'] = self.summary
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        self.outlines = []
+        if m.get('Outlines') is not None:
+            for k in m.get('Outlines'):
+                temp_model = ListFreshViewPointsResponseBodyDataOutlines()
+                self.outlines.append(temp_model.from_map(k))
+        if m.get('Point') is not None:
+            self.point = m.get('Point')
+        if m.get('Summary') is not None:
+            self.summary = m.get('Summary')
+        return self
+
+
+class ListFreshViewPointsResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: List[ListFreshViewPointsResponseBodyData] = None,
         http_status_code: int = None,
         max_results: int = None,
         message: str = None,
@@ -26887,6 +28058,215 @@ class ListFreshViewPointsResponse(TeaModel):
         return self
 
 
+class ListGeneralConfigsRequest(TeaModel):
+    def __init__(
+        self,
+        page_number: int = None,
+        page_size: int = None,
+        workspace_id: str = None,
+    ):
+        self.page_number = page_number
+        self.page_size = page_size
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.page_number is not None:
+            result['PageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['PageSize'] = self.page_size
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('PageNumber') is not None:
+            self.page_number = m.get('PageNumber')
+        if m.get('PageSize') is not None:
+            self.page_size = m.get('PageSize')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class ListGeneralConfigsResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        config_desc: str = None,
+        config_key: str = None,
+        config_value: str = None,
+        config_value_type: str = None,
+    ):
+        self.config_desc = config_desc
+        self.config_key = config_key
+        self.config_value = config_value
+        self.config_value_type = config_value_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.config_desc is not None:
+            result['ConfigDesc'] = self.config_desc
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.config_value is not None:
+            result['ConfigValue'] = self.config_value
+        if self.config_value_type is not None:
+            result['ConfigValueType'] = self.config_value_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConfigDesc') is not None:
+            self.config_desc = m.get('ConfigDesc')
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('ConfigValue') is not None:
+            self.config_value = m.get('ConfigValue')
+        if m.get('ConfigValueType') is not None:
+            self.config_value_type = m.get('ConfigValueType')
+        return self
+
+
+class ListGeneralConfigsResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: List[ListGeneralConfigsResponseBodyData] = None,
+        http_status_code: int = None,
+        message: str = None,
+        page_number: int = None,
+        page_size: int = None,
+        request_id: str = None,
+        success: bool = None,
+        total_count: int = None,
+    ):
+        self.code = code
+        self.data = data
+        self.http_status_code = http_status_code
+        self.message = message
+        self.page_number = page_number
+        self.page_size = page_size
+        self.request_id = request_id
+        self.success = success
+        self.total_count = total_count
+
+    def validate(self):
+        if self.data:
+            for k in self.data:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        result['Data'] = []
+        if self.data is not None:
+            for k in self.data:
+                result['Data'].append(k.to_map() if k else None)
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.message is not None:
+            result['Message'] = self.message
+        if self.page_number is not None:
+            result['PageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['PageSize'] = self.page_size
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
+        if self.total_count is not None:
+            result['TotalCount'] = self.total_count
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        self.data = []
+        if m.get('Data') is not None:
+            for k in m.get('Data'):
+                temp_model = ListGeneralConfigsResponseBodyData()
+                self.data.append(temp_model.from_map(k))
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('PageNumber') is not None:
+            self.page_number = m.get('PageNumber')
+        if m.get('PageSize') is not None:
+            self.page_size = m.get('PageSize')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
+        if m.get('TotalCount') is not None:
+            self.total_count = m.get('TotalCount')
+        return self
+
+
+class ListGeneralConfigsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListGeneralConfigsResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListGeneralConfigsResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class ListGeneratedContentsRequest(TeaModel):
     def __init__(
         self,
@@ -41995,6 +43375,459 @@ class RunMultiDocIntroductionResponse(TeaModel):
         return self
 
 
+class RunQuickWritingRequestArticles(TeaModel):
+    def __init__(
+        self,
+        content: str = None,
+        title: str = None,
+        url: str = None,
+    ):
+        self.content = content
+        self.title = title
+        self.url = url
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.content is not None:
+            result['Content'] = self.content
+        if self.title is not None:
+            result['Title'] = self.title
+        if self.url is not None:
+            result['Url'] = self.url
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Content') is not None:
+            self.content = m.get('Content')
+        if m.get('Title') is not None:
+            self.title = m.get('Title')
+        if m.get('Url') is not None:
+            self.url = m.get('Url')
+        return self
+
+
+class RunQuickWritingRequestSearchSources(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        dataset_name: str = None,
+    ):
+        self.code = code
+        self.dataset_name = dataset_name
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        if self.dataset_name is not None:
+            result['DatasetName'] = self.dataset_name
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        if m.get('DatasetName') is not None:
+            self.dataset_name = m.get('DatasetName')
+        return self
+
+
+class RunQuickWritingRequest(TeaModel):
+    def __init__(
+        self,
+        articles: List[RunQuickWritingRequestArticles] = None,
+        prompt: str = None,
+        search_sources: List[RunQuickWritingRequestSearchSources] = None,
+        task_id: str = None,
+        workspace_id: str = None,
+    ):
+        self.articles = articles
+        # This parameter is required.
+        self.prompt = prompt
+        self.search_sources = search_sources
+        self.task_id = task_id
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        if self.articles:
+            for k in self.articles:
+                if k:
+                    k.validate()
+        if self.search_sources:
+            for k in self.search_sources:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        result['Articles'] = []
+        if self.articles is not None:
+            for k in self.articles:
+                result['Articles'].append(k.to_map() if k else None)
+        if self.prompt is not None:
+            result['Prompt'] = self.prompt
+        result['SearchSources'] = []
+        if self.search_sources is not None:
+            for k in self.search_sources:
+                result['SearchSources'].append(k.to_map() if k else None)
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        self.articles = []
+        if m.get('Articles') is not None:
+            for k in m.get('Articles'):
+                temp_model = RunQuickWritingRequestArticles()
+                self.articles.append(temp_model.from_map(k))
+        if m.get('Prompt') is not None:
+            self.prompt = m.get('Prompt')
+        self.search_sources = []
+        if m.get('SearchSources') is not None:
+            for k in m.get('SearchSources'):
+                temp_model = RunQuickWritingRequestSearchSources()
+                self.search_sources.append(temp_model.from_map(k))
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class RunQuickWritingShrinkRequest(TeaModel):
+    def __init__(
+        self,
+        articles_shrink: str = None,
+        prompt: str = None,
+        search_sources_shrink: str = None,
+        task_id: str = None,
+        workspace_id: str = None,
+    ):
+        self.articles_shrink = articles_shrink
+        # This parameter is required.
+        self.prompt = prompt
+        self.search_sources_shrink = search_sources_shrink
+        self.task_id = task_id
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.articles_shrink is not None:
+            result['Articles'] = self.articles_shrink
+        if self.prompt is not None:
+            result['Prompt'] = self.prompt
+        if self.search_sources_shrink is not None:
+            result['SearchSources'] = self.search_sources_shrink
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Articles') is not None:
+            self.articles_shrink = m.get('Articles')
+        if m.get('Prompt') is not None:
+            self.prompt = m.get('Prompt')
+        if m.get('SearchSources') is not None:
+            self.search_sources_shrink = m.get('SearchSources')
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class RunQuickWritingResponseBodyHeader(TeaModel):
+    def __init__(
+        self,
+        error_code: str = None,
+        error_message: str = None,
+        event: str = None,
+        session_id: str = None,
+        status_code: int = None,
+        task_id: str = None,
+        trace_id: str = None,
+    ):
+        self.error_code = error_code
+        self.error_message = error_message
+        self.event = event
+        self.session_id = session_id
+        self.status_code = status_code
+        self.task_id = task_id
+        self.trace_id = trace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.error_code is not None:
+            result['ErrorCode'] = self.error_code
+        if self.error_message is not None:
+            result['ErrorMessage'] = self.error_message
+        if self.event is not None:
+            result['Event'] = self.event
+        if self.session_id is not None:
+            result['SessionId'] = self.session_id
+        if self.status_code is not None:
+            result['StatusCode'] = self.status_code
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.trace_id is not None:
+            result['TraceId'] = self.trace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ErrorCode') is not None:
+            self.error_code = m.get('ErrorCode')
+        if m.get('ErrorMessage') is not None:
+            self.error_message = m.get('ErrorMessage')
+        if m.get('Event') is not None:
+            self.event = m.get('Event')
+        if m.get('SessionId') is not None:
+            self.session_id = m.get('SessionId')
+        if m.get('StatusCode') is not None:
+            self.status_code = m.get('StatusCode')
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('TraceId') is not None:
+            self.trace_id = m.get('TraceId')
+        return self
+
+
+class RunQuickWritingResponseBodyPayloadOutput(TeaModel):
+    def __init__(
+        self,
+        text: str = None,
+    ):
+        self.text = text
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.text is not None:
+            result['Text'] = self.text
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Text') is not None:
+            self.text = m.get('Text')
+        return self
+
+
+class RunQuickWritingResponseBodyPayloadUsage(TeaModel):
+    def __init__(
+        self,
+        input_tokens: int = None,
+        output_tokens: int = None,
+        total_tokens: int = None,
+    ):
+        self.input_tokens = input_tokens
+        self.output_tokens = output_tokens
+        self.total_tokens = total_tokens
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.input_tokens is not None:
+            result['InputTokens'] = self.input_tokens
+        if self.output_tokens is not None:
+            result['OutputTokens'] = self.output_tokens
+        if self.total_tokens is not None:
+            result['TotalTokens'] = self.total_tokens
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('InputTokens') is not None:
+            self.input_tokens = m.get('InputTokens')
+        if m.get('OutputTokens') is not None:
+            self.output_tokens = m.get('OutputTokens')
+        if m.get('TotalTokens') is not None:
+            self.total_tokens = m.get('TotalTokens')
+        return self
+
+
+class RunQuickWritingResponseBodyPayload(TeaModel):
+    def __init__(
+        self,
+        output: RunQuickWritingResponseBodyPayloadOutput = None,
+        usage: RunQuickWritingResponseBodyPayloadUsage = None,
+    ):
+        self.output = output
+        self.usage = usage
+
+    def validate(self):
+        if self.output:
+            self.output.validate()
+        if self.usage:
+            self.usage.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.output is not None:
+            result['Output'] = self.output.to_map()
+        if self.usage is not None:
+            result['Usage'] = self.usage.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Output') is not None:
+            temp_model = RunQuickWritingResponseBodyPayloadOutput()
+            self.output = temp_model.from_map(m['Output'])
+        if m.get('Usage') is not None:
+            temp_model = RunQuickWritingResponseBodyPayloadUsage()
+            self.usage = temp_model.from_map(m['Usage'])
+        return self
+
+
+class RunQuickWritingResponseBody(TeaModel):
+    def __init__(
+        self,
+        end: bool = None,
+        header: RunQuickWritingResponseBodyHeader = None,
+        payload: RunQuickWritingResponseBodyPayload = None,
+        request_id: str = None,
+    ):
+        self.end = end
+        self.header = header
+        self.payload = payload
+        self.request_id = request_id
+
+    def validate(self):
+        if self.header:
+            self.header.validate()
+        if self.payload:
+            self.payload.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.end is not None:
+            result['End'] = self.end
+        if self.header is not None:
+            result['Header'] = self.header.to_map()
+        if self.payload is not None:
+            result['Payload'] = self.payload.to_map()
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('End') is not None:
+            self.end = m.get('End')
+        if m.get('Header') is not None:
+            temp_model = RunQuickWritingResponseBodyHeader()
+            self.header = temp_model.from_map(m['Header'])
+        if m.get('Payload') is not None:
+            temp_model = RunQuickWritingResponseBodyPayload()
+            self.payload = temp_model.from_map(m['Payload'])
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class RunQuickWritingResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: RunQuickWritingResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = RunQuickWritingResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class RunSearchGenerationRequestAgentContextBizContextMultimodalMediaSelectionTextSearchResultSearchResult(TeaModel):
     def __init__(
         self,
@@ -48868,20 +50701,319 @@ class RunStyleFeatureAnalysisResponseBodyPayload(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('Output') is not None:
-            temp_model = RunStyleFeatureAnalysisResponseBodyPayloadOutput()
+            temp_model = RunStyleFeatureAnalysisResponseBodyPayloadOutput()
+            self.output = temp_model.from_map(m['Output'])
+        if m.get('Usage') is not None:
+            temp_model = RunStyleFeatureAnalysisResponseBodyPayloadUsage()
+            self.usage = temp_model.from_map(m['Usage'])
+        return self
+
+
+class RunStyleFeatureAnalysisResponseBody(TeaModel):
+    def __init__(
+        self,
+        end: bool = None,
+        header: RunStyleFeatureAnalysisResponseBodyHeader = None,
+        payload: RunStyleFeatureAnalysisResponseBodyPayload = None,
+        request_id: str = None,
+    ):
+        self.end = end
+        self.header = header
+        self.payload = payload
+        self.request_id = request_id
+
+    def validate(self):
+        if self.header:
+            self.header.validate()
+        if self.payload:
+            self.payload.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.end is not None:
+            result['End'] = self.end
+        if self.header is not None:
+            result['Header'] = self.header.to_map()
+        if self.payload is not None:
+            result['Payload'] = self.payload.to_map()
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('End') is not None:
+            self.end = m.get('End')
+        if m.get('Header') is not None:
+            temp_model = RunStyleFeatureAnalysisResponseBodyHeader()
+            self.header = temp_model.from_map(m['Header'])
+        if m.get('Payload') is not None:
+            temp_model = RunStyleFeatureAnalysisResponseBodyPayload()
+            self.payload = temp_model.from_map(m['Payload'])
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class RunStyleFeatureAnalysisResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: RunStyleFeatureAnalysisResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = RunStyleFeatureAnalysisResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class RunSummaryGenerateRequest(TeaModel):
+    def __init__(
+        self,
+        content: str = None,
+        prompt: str = None,
+        workspace_id: str = None,
+    ):
+        # This parameter is required.
+        self.content = content
+        self.prompt = prompt
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.content is not None:
+            result['Content'] = self.content
+        if self.prompt is not None:
+            result['Prompt'] = self.prompt
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Content') is not None:
+            self.content = m.get('Content')
+        if m.get('Prompt') is not None:
+            self.prompt = m.get('Prompt')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class RunSummaryGenerateResponseBodyHeader(TeaModel):
+    def __init__(
+        self,
+        error_code: str = None,
+        error_message: str = None,
+        event: str = None,
+        event_info: str = None,
+        session_id: str = None,
+        task_id: str = None,
+        trace_id: str = None,
+    ):
+        self.error_code = error_code
+        self.error_message = error_message
+        self.event = event
+        self.event_info = event_info
+        self.session_id = session_id
+        self.task_id = task_id
+        self.trace_id = trace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.error_code is not None:
+            result['ErrorCode'] = self.error_code
+        if self.error_message is not None:
+            result['ErrorMessage'] = self.error_message
+        if self.event is not None:
+            result['Event'] = self.event
+        if self.event_info is not None:
+            result['EventInfo'] = self.event_info
+        if self.session_id is not None:
+            result['SessionId'] = self.session_id
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.trace_id is not None:
+            result['TraceId'] = self.trace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ErrorCode') is not None:
+            self.error_code = m.get('ErrorCode')
+        if m.get('ErrorMessage') is not None:
+            self.error_message = m.get('ErrorMessage')
+        if m.get('Event') is not None:
+            self.event = m.get('Event')
+        if m.get('EventInfo') is not None:
+            self.event_info = m.get('EventInfo')
+        if m.get('SessionId') is not None:
+            self.session_id = m.get('SessionId')
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('TraceId') is not None:
+            self.trace_id = m.get('TraceId')
+        return self
+
+
+class RunSummaryGenerateResponseBodyPayloadOutput(TeaModel):
+    def __init__(
+        self,
+        text: str = None,
+    ):
+        self.text = text
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.text is not None:
+            result['Text'] = self.text
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Text') is not None:
+            self.text = m.get('Text')
+        return self
+
+
+class RunSummaryGenerateResponseBodyPayloadUsage(TeaModel):
+    def __init__(
+        self,
+        input_tokens: int = None,
+        output_tokens: int = None,
+        total_tokens: int = None,
+    ):
+        self.input_tokens = input_tokens
+        self.output_tokens = output_tokens
+        self.total_tokens = total_tokens
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.input_tokens is not None:
+            result['InputTokens'] = self.input_tokens
+        if self.output_tokens is not None:
+            result['OutputTokens'] = self.output_tokens
+        if self.total_tokens is not None:
+            result['TotalTokens'] = self.total_tokens
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('InputTokens') is not None:
+            self.input_tokens = m.get('InputTokens')
+        if m.get('OutputTokens') is not None:
+            self.output_tokens = m.get('OutputTokens')
+        if m.get('TotalTokens') is not None:
+            self.total_tokens = m.get('TotalTokens')
+        return self
+
+
+class RunSummaryGenerateResponseBodyPayload(TeaModel):
+    def __init__(
+        self,
+        output: RunSummaryGenerateResponseBodyPayloadOutput = None,
+        usage: RunSummaryGenerateResponseBodyPayloadUsage = None,
+    ):
+        self.output = output
+        self.usage = usage
+
+    def validate(self):
+        if self.output:
+            self.output.validate()
+        if self.usage:
+            self.usage.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.output is not None:
+            result['Output'] = self.output.to_map()
+        if self.usage is not None:
+            result['Usage'] = self.usage.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Output') is not None:
+            temp_model = RunSummaryGenerateResponseBodyPayloadOutput()
             self.output = temp_model.from_map(m['Output'])
         if m.get('Usage') is not None:
-            temp_model = RunStyleFeatureAnalysisResponseBodyPayloadUsage()
+            temp_model = RunSummaryGenerateResponseBodyPayloadUsage()
             self.usage = temp_model.from_map(m['Usage'])
         return self
 
 
-class RunStyleFeatureAnalysisResponseBody(TeaModel):
+class RunSummaryGenerateResponseBody(TeaModel):
     def __init__(
         self,
         end: bool = None,
-        header: RunStyleFeatureAnalysisResponseBodyHeader = None,
-        payload: RunStyleFeatureAnalysisResponseBodyPayload = None,
+        header: RunSummaryGenerateResponseBodyHeader = None,
+        payload: RunSummaryGenerateResponseBodyPayload = None,
         request_id: str = None,
     ):
         self.end = end
@@ -48916,22 +51048,22 @@ class RunStyleFeatureAnalysisResponseBody(TeaModel):
         if m.get('End') is not None:
             self.end = m.get('End')
         if m.get('Header') is not None:
-            temp_model = RunStyleFeatureAnalysisResponseBodyHeader()
+            temp_model = RunSummaryGenerateResponseBodyHeader()
             self.header = temp_model.from_map(m['Header'])
         if m.get('Payload') is not None:
-            temp_model = RunStyleFeatureAnalysisResponseBodyPayload()
+            temp_model = RunSummaryGenerateResponseBodyPayload()
             self.payload = temp_model.from_map(m['Payload'])
         if m.get('RequestId') is not None:
             self.request_id = m.get('RequestId')
         return self
 
 
-class RunStyleFeatureAnalysisResponse(TeaModel):
+class RunSummaryGenerateResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: RunStyleFeatureAnalysisResponseBody = None,
+        body: RunSummaryGenerateResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -48962,12 +51094,12 @@ class RunStyleFeatureAnalysisResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = RunStyleFeatureAnalysisResponseBody()
+            temp_model = RunSummaryGenerateResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class RunSummaryGenerateRequest(TeaModel):
+class RunTextPolishingRequest(TeaModel):
     def __init__(
         self,
         content: str = None,
@@ -49008,13 +51140,13 @@ class RunSummaryGenerateRequest(TeaModel):
         return self
 
 
-class RunSummaryGenerateResponseBodyHeader(TeaModel):
+class RunTextPolishingResponseBodyHeader(TeaModel):
     def __init__(
         self,
         error_code: str = None,
         error_message: str = None,
         event: str = None,
-        event_info: str = None,
+        origin_session_id: str = None,
         session_id: str = None,
         task_id: str = None,
         trace_id: str = None,
@@ -49022,7 +51154,7 @@ class RunSummaryGenerateResponseBodyHeader(TeaModel):
         self.error_code = error_code
         self.error_message = error_message
         self.event = event
-        self.event_info = event_info
+        self.origin_session_id = origin_session_id
         self.session_id = session_id
         self.task_id = task_id
         self.trace_id = trace_id
@@ -49042,8 +51174,8 @@ class RunSummaryGenerateResponseBodyHeader(TeaModel):
             result['ErrorMessage'] = self.error_message
         if self.event is not None:
             result['Event'] = self.event
-        if self.event_info is not None:
-            result['EventInfo'] = self.event_info
+        if self.origin_session_id is not None:
+            result['OriginSessionId'] = self.origin_session_id
         if self.session_id is not None:
             result['SessionId'] = self.session_id
         if self.task_id is not None:
@@ -49060,8 +51192,8 @@ class RunSummaryGenerateResponseBodyHeader(TeaModel):
             self.error_message = m.get('ErrorMessage')
         if m.get('Event') is not None:
             self.event = m.get('Event')
-        if m.get('EventInfo') is not None:
-            self.event_info = m.get('EventInfo')
+        if m.get('OriginSessionId') is not None:
+            self.origin_session_id = m.get('OriginSessionId')
         if m.get('SessionId') is not None:
             self.session_id = m.get('SessionId')
         if m.get('TaskId') is not None:
@@ -49071,7 +51203,7 @@ class RunSummaryGenerateResponseBodyHeader(TeaModel):
         return self
 
 
-class RunSummaryGenerateResponseBodyPayloadOutput(TeaModel):
+class RunTextPolishingResponseBodyPayloadOutput(TeaModel):
     def __init__(
         self,
         text: str = None,
@@ -49098,7 +51230,7 @@ class RunSummaryGenerateResponseBodyPayloadOutput(TeaModel):
         return self
 
 
-class RunSummaryGenerateResponseBodyPayloadUsage(TeaModel):
+class RunTextPolishingResponseBodyPayloadUsage(TeaModel):
     def __init__(
         self,
         input_tokens: int = None,
@@ -49137,11 +51269,11 @@ class RunSummaryGenerateResponseBodyPayloadUsage(TeaModel):
         return self
 
 
-class RunSummaryGenerateResponseBodyPayload(TeaModel):
+class RunTextPolishingResponseBodyPayload(TeaModel):
     def __init__(
         self,
-        output: RunSummaryGenerateResponseBodyPayloadOutput = None,
-        usage: RunSummaryGenerateResponseBodyPayloadUsage = None,
+        output: RunTextPolishingResponseBodyPayloadOutput = None,
+        usage: RunTextPolishingResponseBodyPayloadUsage = None,
     ):
         self.output = output
         self.usage = usage
@@ -49167,23 +51299,21 @@ class RunSummaryGenerateResponseBodyPayload(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('Output') is not None:
-            temp_model = RunSummaryGenerateResponseBodyPayloadOutput()
+            temp_model = RunTextPolishingResponseBodyPayloadOutput()
             self.output = temp_model.from_map(m['Output'])
         if m.get('Usage') is not None:
-            temp_model = RunSummaryGenerateResponseBodyPayloadUsage()
+            temp_model = RunTextPolishingResponseBodyPayloadUsage()
             self.usage = temp_model.from_map(m['Usage'])
         return self
 
 
-class RunSummaryGenerateResponseBody(TeaModel):
+class RunTextPolishingResponseBody(TeaModel):
     def __init__(
         self,
-        end: bool = None,
-        header: RunSummaryGenerateResponseBodyHeader = None,
-        payload: RunSummaryGenerateResponseBodyPayload = None,
+        header: RunTextPolishingResponseBodyHeader = None,
+        payload: RunTextPolishingResponseBodyPayload = None,
         request_id: str = None,
     ):
-        self.end = end
         self.header = header
         self.payload = payload
         self.request_id = request_id
@@ -49200,8 +51330,6 @@ class RunSummaryGenerateResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.end is not None:
-            result['End'] = self.end
         if self.header is not None:
             result['Header'] = self.header.to_map()
         if self.payload is not None:
@@ -49212,25 +51340,23 @@ class RunSummaryGenerateResponseBody(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('End') is not None:
-            self.end = m.get('End')
         if m.get('Header') is not None:
-            temp_model = RunSummaryGenerateResponseBodyHeader()
+            temp_model = RunTextPolishingResponseBodyHeader()
             self.header = temp_model.from_map(m['Header'])
         if m.get('Payload') is not None:
-            temp_model = RunSummaryGenerateResponseBodyPayload()
+            temp_model = RunTextPolishingResponseBodyPayload()
             self.payload = temp_model.from_map(m['Payload'])
         if m.get('RequestId') is not None:
             self.request_id = m.get('RequestId')
         return self
 
 
-class RunSummaryGenerateResponse(TeaModel):
+class RunTextPolishingResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: RunSummaryGenerateResponseBody = None,
+        body: RunTextPolishingResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -49261,21 +51387,108 @@ class RunSummaryGenerateResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = RunSummaryGenerateResponseBody()
+            temp_model = RunTextPolishingResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class RunTextPolishingRequest(TeaModel):
+class RunTitleGenerationRequestReferenceData(TeaModel):
     def __init__(
         self,
-        content: str = None,
-        prompt: str = None,
+        contents: List[str] = None,
+    ):
+        # This parameter is required.
+        self.contents = contents
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.contents is not None:
+            result['Contents'] = self.contents
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Contents') is not None:
+            self.contents = m.get('Contents')
+        return self
+
+
+class RunTitleGenerationRequest(TeaModel):
+    def __init__(
+        self,
+        deduplicated_titles: List[str] = None,
+        reference_data: RunTitleGenerationRequestReferenceData = None,
+        task_id: str = None,
+        title_count: str = None,
         workspace_id: str = None,
     ):
+        self.deduplicated_titles = deduplicated_titles
         # This parameter is required.
-        self.content = content
-        self.prompt = prompt
+        self.reference_data = reference_data
+        self.task_id = task_id
+        self.title_count = title_count
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        if self.reference_data:
+            self.reference_data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.deduplicated_titles is not None:
+            result['DeduplicatedTitles'] = self.deduplicated_titles
+        if self.reference_data is not None:
+            result['ReferenceData'] = self.reference_data.to_map()
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.title_count is not None:
+            result['TitleCount'] = self.title_count
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('DeduplicatedTitles') is not None:
+            self.deduplicated_titles = m.get('DeduplicatedTitles')
+        if m.get('ReferenceData') is not None:
+            temp_model = RunTitleGenerationRequestReferenceData()
+            self.reference_data = temp_model.from_map(m['ReferenceData'])
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('TitleCount') is not None:
+            self.title_count = m.get('TitleCount')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class RunTitleGenerationShrinkRequest(TeaModel):
+    def __init__(
+        self,
+        deduplicated_titles_shrink: str = None,
+        reference_data_shrink: str = None,
+        task_id: str = None,
+        title_count: str = None,
+        workspace_id: str = None,
+    ):
+        self.deduplicated_titles_shrink = deduplicated_titles_shrink
+        # This parameter is required.
+        self.reference_data_shrink = reference_data_shrink
+        self.task_id = task_id
+        self.title_count = title_count
         # This parameter is required.
         self.workspace_id = workspace_id
 
@@ -49288,41 +51501,49 @@ class RunTextPolishingRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.content is not None:
-            result['Content'] = self.content
-        if self.prompt is not None:
-            result['Prompt'] = self.prompt
+        if self.deduplicated_titles_shrink is not None:
+            result['DeduplicatedTitles'] = self.deduplicated_titles_shrink
+        if self.reference_data_shrink is not None:
+            result['ReferenceData'] = self.reference_data_shrink
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.title_count is not None:
+            result['TitleCount'] = self.title_count
         if self.workspace_id is not None:
             result['WorkspaceId'] = self.workspace_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Content') is not None:
-            self.content = m.get('Content')
-        if m.get('Prompt') is not None:
-            self.prompt = m.get('Prompt')
+        if m.get('DeduplicatedTitles') is not None:
+            self.deduplicated_titles_shrink = m.get('DeduplicatedTitles')
+        if m.get('ReferenceData') is not None:
+            self.reference_data_shrink = m.get('ReferenceData')
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('TitleCount') is not None:
+            self.title_count = m.get('TitleCount')
         if m.get('WorkspaceId') is not None:
             self.workspace_id = m.get('WorkspaceId')
         return self
 
 
-class RunTextPolishingResponseBodyHeader(TeaModel):
+class RunTitleGenerationResponseBodyHeader(TeaModel):
     def __init__(
         self,
         error_code: str = None,
         error_message: str = None,
         event: str = None,
-        origin_session_id: str = None,
         session_id: str = None,
+        status_code: int = None,
         task_id: str = None,
         trace_id: str = None,
     ):
         self.error_code = error_code
         self.error_message = error_message
         self.event = event
-        self.origin_session_id = origin_session_id
         self.session_id = session_id
+        self.status_code = status_code
         self.task_id = task_id
         self.trace_id = trace_id
 
@@ -49341,10 +51562,10 @@ class RunTextPolishingResponseBodyHeader(TeaModel):
             result['ErrorMessage'] = self.error_message
         if self.event is not None:
             result['Event'] = self.event
-        if self.origin_session_id is not None:
-            result['OriginSessionId'] = self.origin_session_id
         if self.session_id is not None:
             result['SessionId'] = self.session_id
+        if self.status_code is not None:
+            result['StatusCode'] = self.status_code
         if self.task_id is not None:
             result['TaskId'] = self.task_id
         if self.trace_id is not None:
@@ -49359,10 +51580,10 @@ class RunTextPolishingResponseBodyHeader(TeaModel):
             self.error_message = m.get('ErrorMessage')
         if m.get('Event') is not None:
             self.event = m.get('Event')
-        if m.get('OriginSessionId') is not None:
-            self.origin_session_id = m.get('OriginSessionId')
         if m.get('SessionId') is not None:
             self.session_id = m.get('SessionId')
+        if m.get('StatusCode') is not None:
+            self.status_code = m.get('StatusCode')
         if m.get('TaskId') is not None:
             self.task_id = m.get('TaskId')
         if m.get('TraceId') is not None:
@@ -49370,7 +51591,7 @@ class RunTextPolishingResponseBodyHeader(TeaModel):
         return self
 
 
-class RunTextPolishingResponseBodyPayloadOutput(TeaModel):
+class RunTitleGenerationResponseBodyPayloadOutput(TeaModel):
     def __init__(
         self,
         text: str = None,
@@ -49397,7 +51618,7 @@ class RunTextPolishingResponseBodyPayloadOutput(TeaModel):
         return self
 
 
-class RunTextPolishingResponseBodyPayloadUsage(TeaModel):
+class RunTitleGenerationResponseBodyPayloadUsage(TeaModel):
     def __init__(
         self,
         input_tokens: int = None,
@@ -49436,11 +51657,11 @@ class RunTextPolishingResponseBodyPayloadUsage(TeaModel):
         return self
 
 
-class RunTextPolishingResponseBodyPayload(TeaModel):
+class RunTitleGenerationResponseBodyPayload(TeaModel):
     def __init__(
         self,
-        output: RunTextPolishingResponseBodyPayloadOutput = None,
-        usage: RunTextPolishingResponseBodyPayloadUsage = None,
+        output: RunTitleGenerationResponseBodyPayloadOutput = None,
+        usage: RunTitleGenerationResponseBodyPayloadUsage = None,
     ):
         self.output = output
         self.usage = usage
@@ -49466,24 +51687,32 @@ class RunTextPolishingResponseBodyPayload(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('Output') is not None:
-            temp_model = RunTextPolishingResponseBodyPayloadOutput()
+            temp_model = RunTitleGenerationResponseBodyPayloadOutput()
             self.output = temp_model.from_map(m['Output'])
         if m.get('Usage') is not None:
-            temp_model = RunTextPolishingResponseBodyPayloadUsage()
+            temp_model = RunTitleGenerationResponseBodyPayloadUsage()
             self.usage = temp_model.from_map(m['Usage'])
         return self
 
 
-class RunTextPolishingResponseBody(TeaModel):
+class RunTitleGenerationResponseBody(TeaModel):
     def __init__(
         self,
-        header: RunTextPolishingResponseBodyHeader = None,
-        payload: RunTextPolishingResponseBodyPayload = None,
+        code: str = None,
+        header: RunTitleGenerationResponseBodyHeader = None,
+        http_status_code: str = None,
+        message: str = None,
+        payload: RunTitleGenerationResponseBodyPayload = None,
         request_id: str = None,
+        success: bool = None,
     ):
+        self.code = code
         self.header = header
+        self.http_status_code = http_status_code
+        self.message = message
         self.payload = payload
         self.request_id = request_id
+        self.success = success
 
     def validate(self):
         if self.header:
@@ -49497,33 +51726,49 @@ class RunTextPolishingResponseBody(TeaModel):
             return _map
 
         result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
         if self.header is not None:
             result['Header'] = self.header.to_map()
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.message is not None:
+            result['Message'] = self.message
         if self.payload is not None:
             result['Payload'] = self.payload.to_map()
         if self.request_id is not None:
             result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
         if m.get('Header') is not None:
-            temp_model = RunTextPolishingResponseBodyHeader()
+            temp_model = RunTitleGenerationResponseBodyHeader()
             self.header = temp_model.from_map(m['Header'])
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
         if m.get('Payload') is not None:
-            temp_model = RunTextPolishingResponseBodyPayload()
+            temp_model = RunTitleGenerationResponseBodyPayload()
             self.payload = temp_model.from_map(m['Payload'])
         if m.get('RequestId') is not None:
             self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
         return self
 
 
-class RunTextPolishingResponse(TeaModel):
+class RunTitleGenerationResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: RunTextPolishingResponseBody = None,
+        body: RunTitleGenerationResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -49554,59 +51799,29 @@ class RunTextPolishingResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = RunTextPolishingResponseBody()
+            temp_model = RunTitleGenerationResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class RunTitleGenerationRequestReferenceData(TeaModel):
-    def __init__(
-        self,
-        contents: List[str] = None,
-    ):
-        # This parameter is required.
-        self.contents = contents
-
-    def validate(self):
-        pass
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        if self.contents is not None:
-            result['Contents'] = self.contents
-        return result
-
-    def from_map(self, m: dict = None):
-        m = m or dict()
-        if m.get('Contents') is not None:
-            self.contents = m.get('Contents')
-        return self
-
-
-class RunTitleGenerationRequest(TeaModel):
+class RunTopicSelectionMergeRequest(TeaModel):
     def __init__(
         self,
-        deduplicated_titles: List[str] = None,
-        reference_data: RunTitleGenerationRequestReferenceData = None,
-        task_id: str = None,
-        title_count: str = None,
+        prompt: str = None,
+        topics: List[TopicSelection] = None,
         workspace_id: str = None,
     ):
-        self.deduplicated_titles = deduplicated_titles
+        self.prompt = prompt
         # This parameter is required.
-        self.reference_data = reference_data
-        self.task_id = task_id
-        self.title_count = title_count
+        self.topics = topics
         # This parameter is required.
         self.workspace_id = workspace_id
 
     def validate(self):
-        if self.reference_data:
-            self.reference_data.validate()
+        if self.topics:
+            for k in self.topics:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -49614,48 +51829,40 @@ class RunTitleGenerationRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.deduplicated_titles is not None:
-            result['DeduplicatedTitles'] = self.deduplicated_titles
-        if self.reference_data is not None:
-            result['ReferenceData'] = self.reference_data.to_map()
-        if self.task_id is not None:
-            result['TaskId'] = self.task_id
-        if self.title_count is not None:
-            result['TitleCount'] = self.title_count
+        if self.prompt is not None:
+            result['Prompt'] = self.prompt
+        result['Topics'] = []
+        if self.topics is not None:
+            for k in self.topics:
+                result['Topics'].append(k.to_map() if k else None)
         if self.workspace_id is not None:
             result['WorkspaceId'] = self.workspace_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('DeduplicatedTitles') is not None:
-            self.deduplicated_titles = m.get('DeduplicatedTitles')
-        if m.get('ReferenceData') is not None:
-            temp_model = RunTitleGenerationRequestReferenceData()
-            self.reference_data = temp_model.from_map(m['ReferenceData'])
-        if m.get('TaskId') is not None:
-            self.task_id = m.get('TaskId')
-        if m.get('TitleCount') is not None:
-            self.title_count = m.get('TitleCount')
+        if m.get('Prompt') is not None:
+            self.prompt = m.get('Prompt')
+        self.topics = []
+        if m.get('Topics') is not None:
+            for k in m.get('Topics'):
+                temp_model = TopicSelection()
+                self.topics.append(temp_model.from_map(k))
         if m.get('WorkspaceId') is not None:
             self.workspace_id = m.get('WorkspaceId')
         return self
 
 
-class RunTitleGenerationShrinkRequest(TeaModel):
+class RunTopicSelectionMergeShrinkRequest(TeaModel):
     def __init__(
         self,
-        deduplicated_titles_shrink: str = None,
-        reference_data_shrink: str = None,
-        task_id: str = None,
-        title_count: str = None,
+        prompt: str = None,
+        topics_shrink: str = None,
         workspace_id: str = None,
     ):
-        self.deduplicated_titles_shrink = deduplicated_titles_shrink
+        self.prompt = prompt
         # This parameter is required.
-        self.reference_data_shrink = reference_data_shrink
-        self.task_id = task_id
-        self.title_count = title_count
+        self.topics_shrink = topics_shrink
         # This parameter is required.
         self.workspace_id = workspace_id
 
@@ -49668,39 +51875,32 @@ class RunTitleGenerationShrinkRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.deduplicated_titles_shrink is not None:
-            result['DeduplicatedTitles'] = self.deduplicated_titles_shrink
-        if self.reference_data_shrink is not None:
-            result['ReferenceData'] = self.reference_data_shrink
-        if self.task_id is not None:
-            result['TaskId'] = self.task_id
-        if self.title_count is not None:
-            result['TitleCount'] = self.title_count
+        if self.prompt is not None:
+            result['Prompt'] = self.prompt
+        if self.topics_shrink is not None:
+            result['Topics'] = self.topics_shrink
         if self.workspace_id is not None:
             result['WorkspaceId'] = self.workspace_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('DeduplicatedTitles') is not None:
-            self.deduplicated_titles_shrink = m.get('DeduplicatedTitles')
-        if m.get('ReferenceData') is not None:
-            self.reference_data_shrink = m.get('ReferenceData')
-        if m.get('TaskId') is not None:
-            self.task_id = m.get('TaskId')
-        if m.get('TitleCount') is not None:
-            self.title_count = m.get('TitleCount')
+        if m.get('Prompt') is not None:
+            self.prompt = m.get('Prompt')
+        if m.get('Topics') is not None:
+            self.topics_shrink = m.get('Topics')
         if m.get('WorkspaceId') is not None:
             self.workspace_id = m.get('WorkspaceId')
         return self
 
 
-class RunTitleGenerationResponseBodyHeader(TeaModel):
+class RunTopicSelectionMergeResponseBodyHeader(TeaModel):
     def __init__(
         self,
         error_code: str = None,
         error_message: str = None,
         event: str = None,
+        origin_session_id: str = None,
         session_id: str = None,
         status_code: int = None,
         task_id: str = None,
@@ -49709,6 +51909,7 @@ class RunTitleGenerationResponseBodyHeader(TeaModel):
         self.error_code = error_code
         self.error_message = error_message
         self.event = event
+        self.origin_session_id = origin_session_id
         self.session_id = session_id
         self.status_code = status_code
         self.task_id = task_id
@@ -49729,6 +51930,8 @@ class RunTitleGenerationResponseBodyHeader(TeaModel):
             result['ErrorMessage'] = self.error_message
         if self.event is not None:
             result['Event'] = self.event
+        if self.origin_session_id is not None:
+            result['OriginSessionId'] = self.origin_session_id
         if self.session_id is not None:
             result['SessionId'] = self.session_id
         if self.status_code is not None:
@@ -49747,6 +51950,8 @@ class RunTitleGenerationResponseBodyHeader(TeaModel):
             self.error_message = m.get('ErrorMessage')
         if m.get('Event') is not None:
             self.event = m.get('Event')
+        if m.get('OriginSessionId') is not None:
+            self.origin_session_id = m.get('OriginSessionId')
         if m.get('SessionId') is not None:
             self.session_id = m.get('SessionId')
         if m.get('StatusCode') is not None:
@@ -49758,15 +51963,18 @@ class RunTitleGenerationResponseBodyHeader(TeaModel):
         return self
 
 
-class RunTitleGenerationResponseBodyPayloadOutput(TeaModel):
+class RunTopicSelectionMergeResponseBodyPayloadOutput(TeaModel):
     def __init__(
         self,
         text: str = None,
+        topic: TopicSelection = None,
     ):
         self.text = text
+        self.topic = topic
 
     def validate(self):
-        pass
+        if self.topic:
+            self.topic.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -49776,24 +51984,31 @@ class RunTitleGenerationResponseBodyPayloadOutput(TeaModel):
         result = dict()
         if self.text is not None:
             result['Text'] = self.text
+        if self.topic is not None:
+            result['Topic'] = self.topic.to_map()
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('Text') is not None:
             self.text = m.get('Text')
+        if m.get('Topic') is not None:
+            temp_model = TopicSelection()
+            self.topic = temp_model.from_map(m['Topic'])
         return self
 
 
-class RunTitleGenerationResponseBodyPayloadUsage(TeaModel):
+class RunTopicSelectionMergeResponseBodyPayloadUsage(TeaModel):
     def __init__(
         self,
         input_tokens: int = None,
         output_tokens: int = None,
+        token_map: Dict[str, int] = None,
         total_tokens: int = None,
     ):
         self.input_tokens = input_tokens
         self.output_tokens = output_tokens
+        self.token_map = token_map
         self.total_tokens = total_tokens
 
     def validate(self):
@@ -49809,6 +52024,8 @@ class RunTitleGenerationResponseBodyPayloadUsage(TeaModel):
             result['InputTokens'] = self.input_tokens
         if self.output_tokens is not None:
             result['OutputTokens'] = self.output_tokens
+        if self.token_map is not None:
+            result['TokenMap'] = self.token_map
         if self.total_tokens is not None:
             result['TotalTokens'] = self.total_tokens
         return result
@@ -49819,16 +52036,18 @@ class RunTitleGenerationResponseBodyPayloadUsage(TeaModel):
             self.input_tokens = m.get('InputTokens')
         if m.get('OutputTokens') is not None:
             self.output_tokens = m.get('OutputTokens')
+        if m.get('TokenMap') is not None:
+            self.token_map = m.get('TokenMap')
         if m.get('TotalTokens') is not None:
             self.total_tokens = m.get('TotalTokens')
         return self
 
 
-class RunTitleGenerationResponseBodyPayload(TeaModel):
+class RunTopicSelectionMergeResponseBodyPayload(TeaModel):
     def __init__(
         self,
-        output: RunTitleGenerationResponseBodyPayloadOutput = None,
-        usage: RunTitleGenerationResponseBodyPayloadUsage = None,
+        output: RunTopicSelectionMergeResponseBodyPayloadOutput = None,
+        usage: RunTopicSelectionMergeResponseBodyPayloadUsage = None,
     ):
         self.output = output
         self.usage = usage
@@ -49854,32 +52073,26 @@ class RunTitleGenerationResponseBodyPayload(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('Output') is not None:
-            temp_model = RunTitleGenerationResponseBodyPayloadOutput()
+            temp_model = RunTopicSelectionMergeResponseBodyPayloadOutput()
             self.output = temp_model.from_map(m['Output'])
         if m.get('Usage') is not None:
-            temp_model = RunTitleGenerationResponseBodyPayloadUsage()
+            temp_model = RunTopicSelectionMergeResponseBodyPayloadUsage()
             self.usage = temp_model.from_map(m['Usage'])
         return self
 
 
-class RunTitleGenerationResponseBody(TeaModel):
+class RunTopicSelectionMergeResponseBody(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        header: RunTitleGenerationResponseBodyHeader = None,
-        http_status_code: str = None,
-        message: str = None,
-        payload: RunTitleGenerationResponseBodyPayload = None,
+        end: bool = None,
+        header: RunTopicSelectionMergeResponseBodyHeader = None,
+        payload: RunTopicSelectionMergeResponseBodyPayload = None,
         request_id: str = None,
-        success: bool = None,
     ):
-        self.code = code
+        self.end = end
         self.header = header
-        self.http_status_code = http_status_code
-        self.message = message
         self.payload = payload
         self.request_id = request_id
-        self.success = success
 
     def validate(self):
         if self.header:
@@ -49893,49 +52106,37 @@ class RunTitleGenerationResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.code is not None:
-            result['Code'] = self.code
+        if self.end is not None:
+            result['End'] = self.end
         if self.header is not None:
             result['Header'] = self.header.to_map()
-        if self.http_status_code is not None:
-            result['HttpStatusCode'] = self.http_status_code
-        if self.message is not None:
-            result['Message'] = self.message
         if self.payload is not None:
             result['Payload'] = self.payload.to_map()
         if self.request_id is not None:
             result['RequestId'] = self.request_id
-        if self.success is not None:
-            result['Success'] = self.success
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Code') is not None:
-            self.code = m.get('Code')
+        if m.get('End') is not None:
+            self.end = m.get('End')
         if m.get('Header') is not None:
-            temp_model = RunTitleGenerationResponseBodyHeader()
+            temp_model = RunTopicSelectionMergeResponseBodyHeader()
             self.header = temp_model.from_map(m['Header'])
-        if m.get('HttpStatusCode') is not None:
-            self.http_status_code = m.get('HttpStatusCode')
-        if m.get('Message') is not None:
-            self.message = m.get('Message')
         if m.get('Payload') is not None:
-            temp_model = RunTitleGenerationResponseBodyPayload()
+            temp_model = RunTopicSelectionMergeResponseBodyPayload()
             self.payload = temp_model.from_map(m['Payload'])
         if m.get('RequestId') is not None:
             self.request_id = m.get('RequestId')
-        if m.get('Success') is not None:
-            self.success = m.get('Success')
         return self
 
 
-class RunTitleGenerationResponse(TeaModel):
+class RunTopicSelectionMergeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: RunTitleGenerationResponseBody = None,
+        body: RunTopicSelectionMergeResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -49966,7 +52167,7 @@ class RunTitleGenerationResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = RunTitleGenerationResponseBody()
+            temp_model = RunTopicSelectionMergeResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -60336,6 +62537,193 @@ class UpdateDatasetDocumentResponse(TeaModel):
         return self
 
 
+class UpdateGeneralConfigRequest(TeaModel):
+    def __init__(
+        self,
+        config_key: str = None,
+        config_value: str = None,
+        workspace_id: str = None,
+    ):
+        # This parameter is required.
+        self.config_key = config_key
+        # This parameter is required.
+        self.config_value = config_value
+        # This parameter is required.
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.config_value is not None:
+            result['ConfigValue'] = self.config_value
+        if self.workspace_id is not None:
+            result['WorkspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('ConfigValue') is not None:
+            self.config_value = m.get('ConfigValue')
+        if m.get('WorkspaceId') is not None:
+            self.workspace_id = m.get('WorkspaceId')
+        return self
+
+
+class UpdateGeneralConfigResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        config_desc: str = None,
+        config_key: str = None,
+        config_value: str = None,
+        config_value_type: str = None,
+    ):
+        self.config_desc = config_desc
+        self.config_key = config_key
+        self.config_value = config_value
+        self.config_value_type = config_value_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.config_desc is not None:
+            result['ConfigDesc'] = self.config_desc
+        if self.config_key is not None:
+            result['ConfigKey'] = self.config_key
+        if self.config_value is not None:
+            result['ConfigValue'] = self.config_value
+        if self.config_value_type is not None:
+            result['ConfigValueType'] = self.config_value_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConfigDesc') is not None:
+            self.config_desc = m.get('ConfigDesc')
+        if m.get('ConfigKey') is not None:
+            self.config_key = m.get('ConfigKey')
+        if m.get('ConfigValue') is not None:
+            self.config_value = m.get('ConfigValue')
+        if m.get('ConfigValueType') is not None:
+            self.config_value_type = m.get('ConfigValueType')
+        return self
+
+
+class UpdateGeneralConfigResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: UpdateGeneralConfigResponseBodyData = None,
+        http_status_code: int = None,
+        message: str = None,
+        request_id: str = None,
+        success: bool = None,
+    ):
+        self.code = code
+        self.data = data
+        self.http_status_code = http_status_code
+        self.message = message
+        self.request_id = request_id
+        self.success = success
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['Code'] = self.code
+        if self.data is not None:
+            result['Data'] = self.data.to_map()
+        if self.http_status_code is not None:
+            result['HttpStatusCode'] = self.http_status_code
+        if self.message is not None:
+            result['Message'] = self.message
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.success is not None:
+            result['Success'] = self.success
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Code') is not None:
+            self.code = m.get('Code')
+        if m.get('Data') is not None:
+            temp_model = UpdateGeneralConfigResponseBodyData()
+            self.data = temp_model.from_map(m['Data'])
+        if m.get('HttpStatusCode') is not None:
+            self.http_status_code = m.get('HttpStatusCode')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('Success') is not None:
+            self.success = m.get('Success')
+        return self
+
+
+class UpdateGeneralConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: UpdateGeneralConfigResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = UpdateGeneralConfigResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class UpdateGeneratedContentRequest(TeaModel):
     def __init__(
         self,