@josephyan/qingflow-app-builder-mcp 1.1.25 → 1.1.26

package/src/qingflow_mcp/builder_facade/models.py

@@ -71,36 +71,17 @@ class PublicExternalVisibilityMode(str, Enum):
 
 
 FIELD_TYPE_ALIASES: dict[str, PublicFieldType] = {
-    "multiline": PublicFieldType.long_text,
-    "multiline_text": PublicFieldType.long_text,
-    "multi_line": PublicFieldType.long_text,
-    "multi_line_text": PublicFieldType.long_text,
     "textarea": PublicFieldType.long_text,
-    "longtext": PublicFieldType.long_text,
-    "long-text": PublicFieldType.long_text,
     "amount": PublicFieldType.amount,
     "currency": PublicFieldType.amount,
     "mobile": PublicFieldType.phone,
     "user": PublicFieldType.member,
     "users": PublicFieldType.member,
     "select": PublicFieldType.single_select,
-    "single_choice": PublicFieldType.single_select,
-    "single-choice": PublicFieldType.single_select,
-    "single choice": PublicFieldType.single_select,
-    "choice": PublicFieldType.single_select,
-    "dropdown": PublicFieldType.single_select,
     "radio": PublicFieldType.single_select,
     "checkbox": PublicFieldType.multi_select,
     "multi_select": PublicFieldType.multi_select,
     "multi-select": PublicFieldType.multi_select,
-    "multi select": PublicFieldType.multi_select,
-    "multiselect": PublicFieldType.multi_select,
-    "multi_choice": PublicFieldType.multi_select,
-    "multi-choice": PublicFieldType.multi_select,
-    "multi choice": PublicFieldType.multi_select,
-    "multiple_choice": PublicFieldType.multi_select,
-    "multiple-choice": PublicFieldType.multi_select,
-    "multiple choice": PublicFieldType.multi_select,
     "departments": PublicFieldType.department,
     "qlinker": PublicFieldType.q_linker,
     "q_linker": PublicFieldType.q_linker,
@@ -203,10 +184,6 @@ class LayoutPreset(str, Enum):
     single_section = "single_section"
 
 
-class FlowPreset(str, Enum):
-    basic_approval = "basic_approval"
-    basic_fill_then_approve = "basic_fill_then_approve"
-
 
 class ViewsPreset(str, Enum):
     default_table = "default_table"
@@ -1105,91 +1082,6 @@ class ViewAssociatedResourcesPatch(StrictModel):
     )
 
 
-class ViewActionButtonPatch(StrictModel):
-    button_id: int | None = Field(default=None, validation_alias=AliasChoices("button_id", "buttonId", "id"))
-    client_key: str | None = Field(default=None, validation_alias=AliasChoices("client_key", "clientKey"))
-    text: str = Field(validation_alias=AliasChoices("text", "button_text", "buttonText", "name"))
-    action: PublicButtonTriggerAction = Field(validation_alias=AliasChoices("action", "trigger_action", "triggerAction"))
-    url: str | None = Field(default=None, validation_alias=AliasChoices("url", "link_url", "linkUrl", "trigger_link_url", "triggerLinkUrl"))
-    target_app_key: str | None = Field(default=None, validation_alias=AliasChoices("target_app_key", "targetAppKey", "related_app_key", "relatedAppKey"))
-    target_app_name: str | None = Field(default=None, validation_alias=AliasChoices("target_app_name", "targetAppName", "related_app_name", "relatedAppName"))
-    field_mappings: list[dict[str, Any]] = Field(default_factory=list, validation_alias=AliasChoices("field_mappings", "fieldMappings", "mappings"))
-    default_values: dict[str, Any] = Field(default_factory=dict, validation_alias=AliasChoices("default_values", "defaultValues", "defaults"))
-    placement: PublicButtonPlacement = Field(default=PublicButtonPlacement.detail, validation_alias=AliasChoices("placement", "position"))
-    primary: bool = Field(default=False, validation_alias=AliasChoices("primary", "being_main", "beingMain"))
-    visible_when: list[list[ViewFilterRulePatch]] = Field(
-        default_factory=list,
-        validation_alias=AliasChoices("visible_when", "visibleWhen", "button_limit", "buttonLimit"),
-    )
-    button_formula: str | None = Field(default=None, validation_alias=AliasChoices("button_formula", "buttonFormula"))
-    button_formula_type: int = Field(default=1, validation_alias=AliasChoices("button_formula_type", "buttonFormulaType"))
-    print_tpls: list[Any] = Field(default_factory=list, validation_alias=AliasChoices("print_tpls", "printTpls"))
-    style_preset: str | None = Field(default=None, validation_alias=AliasChoices("style_preset", "stylePreset"))
-    background_color: str | None = Field(default=None, validation_alias=AliasChoices("background_color", "backgroundColor"))
-    text_color: str | None = Field(default=None, validation_alias=AliasChoices("text_color", "textColor"))
-    button_icon: str | None = Field(default=None, validation_alias=AliasChoices("button_icon", "buttonIcon"))
-    external_qrobot_config: dict[str, Any] | None = Field(
-        default=None,
-        validation_alias=AliasChoices(
-            "external_qrobot_config",
-            "externalQrobotConfig",
-            "externalQRobotConfig",
-            "custom_button_external_qrobot_relation_vo",
-            "customButtonExternalQRobotRelationVO",
-        ),
-    )
-    trigger_wings_config: dict[str, Any] | None = Field(default=None, validation_alias=AliasChoices("trigger_wings_config", "triggerWingsConfig"))
-
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        raw_action = payload.get("action", payload.get("trigger_action", payload.get("triggerAction")))
-        if isinstance(raw_action, str):
-            normalized = raw_action.strip()
-            aliases = {
-                "add_data": PublicButtonTriggerAction.add_data.value,
-                "add-data": PublicButtonTriggerAction.add_data.value,
-                "adddata": PublicButtonTriggerAction.add_data.value,
-                "addData": PublicButtonTriggerAction.add_data.value,
-                "link": PublicButtonTriggerAction.link.value,
-                "url": PublicButtonTriggerAction.link.value,
-                "qrobot": PublicButtonTriggerAction.qrobot.value,
-                "qRobot": PublicButtonTriggerAction.qrobot.value,
-                "wings": PublicButtonTriggerAction.wings.value,
-            }
-            payload["action"] = aliases.get(normalized, aliases.get(normalized.lower(), normalized))
-        raw_placement = payload.get("placement", payload.get("position", payload.get("config_type", payload.get("configType"))))
-        if isinstance(raw_placement, str):
-            normalized = raw_placement.strip().lower()
-            if normalized in {"top", "header"}:
-                payload["placement"] = PublicButtonPlacement.header.value
-            elif normalized in {"detail", "data_detail"}:
-                payload["placement"] = PublicButtonPlacement.detail.value
-            elif normalized in {"list", "row", "row_action", "inside"}:
-                payload["placement"] = PublicButtonPlacement.list.value
-        raw_limits = payload.get("visible_when", payload.get("visibleWhen", payload.get("button_limit", payload.get("buttonLimit"))))
-        if isinstance(raw_limits, list) and raw_limits and all(isinstance(item, dict) for item in raw_limits):
-            payload["visible_when"] = [raw_limits]
-        return payload
-
-    @model_validator(mode="after")
-    def validate_shape(self) -> "ViewActionButtonPatch":
-        if not str(self.text or "").strip():
-            raise ValueError("action_buttons[].text is required")
-        if self.action == PublicButtonTriggerAction.link and not str(self.url or "").strip():
-            raise ValueError("link action_buttons require url")
-        if self.action == PublicButtonTriggerAction.add_data and not str(self.target_app_key or "").strip():
-            raise ValueError("add_data action_buttons require target_app_key")
-        if self.action == PublicButtonTriggerAction.qrobot and self.external_qrobot_config is None:
-            raise ValueError("qRobot action_buttons require external_qrobot_config")
-        if self.action == PublicButtonTriggerAction.wings and self.trigger_wings_config is None:
-            raise ValueError("wings action_buttons require trigger_wings_config")
-        return self
-
-
 class ViewUpsertPatch(StrictModel):
     name: str
     view_key: str | None = Field(default=None, validation_alias=AliasChoices("view_key", "viewKey"))
@@ -1201,8 +1093,6 @@ class ViewUpsertPatch(StrictModel):
     end_field: str | None = Field(default=None, validation_alias=AliasChoices("end_field", "endField"))
     title_field: str | None = Field(default=None, validation_alias=AliasChoices("title_field", "titleField"))
     buttons: list["ViewButtonBindingPatch"] | None = None
-    action_buttons: list[ViewActionButtonPatch] | None = Field(default=None, validation_alias=AliasChoices("action_buttons", "actionButtons"))
-    action_buttons_mode: str = Field(default="merge", validation_alias=AliasChoices("action_buttons_mode", "actionButtonsMode", "button_mode", "buttonMode"))
     visibility: VisibilityPatch | None = None
     query_conditions: ViewQueryConditionsPatch | None = Field(default=None, validation_alias=AliasChoices("query_conditions", "queryConditions", "query_condition", "queryCondition"))
     associated_resources: ViewAssociatedResourcesPatch | None = Field(
@@ -1252,12 +1142,6 @@ class ViewUpsertPatch(StrictModel):
             payload["associated_resources"] = payload.pop("associatedReports")
         if "asosChartConfig" in payload and "associated_resources" not in payload:
             payload["associated_resources"] = payload.pop("asosChartConfig")
-        if "actionButtons" in payload and "action_buttons" not in payload:
-            payload["action_buttons"] = payload.pop("actionButtons")
-        if "actionButtonsMode" in payload and "action_buttons_mode" not in payload:
-            payload["action_buttons_mode"] = payload.pop("actionButtonsMode")
-        if "buttonMode" in payload and "action_buttons_mode" not in payload:
-            payload["action_buttons_mode"] = payload.pop("buttonMode")
         raw_type = payload.get("type")
         if isinstance(raw_type, str):
             normalized = raw_type.strip().lower()
@@ -1279,10 +1163,6 @@ class ViewUpsertPatch(StrictModel):
             raise ValueError("board view requires group_by")
         if self.type == PublicViewType.gantt and not (self.start_field and self.end_field):
             raise ValueError("gantt view requires start_field and end_field")
-        normalized_mode = str(self.action_buttons_mode or "merge").strip().lower()
-        if normalized_mode not in {"merge", "replace"}:
-            raise ValueError("action_buttons_mode must be merge or replace")
-        self.action_buttons_mode = normalized_mode
         return self
 
 
@@ -1308,76 +1188,6 @@ class ViewPartialPatch(StrictModel):
         return self
 
 
-def public_button_trigger_action_value(value: Any) -> str:
-    raw = value.value if isinstance(value, PublicButtonTriggerAction) else str(value or "").strip()
-    normalized = raw.lower()
-    if raw == PublicButtonTriggerAction.add_data.value or normalized in {"add_data", "add-data", "adddata"}:
-        return "add_data"
-    if normalized in {PublicButtonTriggerAction.link.value, "url"}:
-        return "link"
-    if raw == PublicButtonTriggerAction.qrobot.value or normalized == "qrobot":
-        return "qRobot"
-    if normalized == PublicButtonTriggerAction.wings.value:
-        return "wings"
-    return raw
-
-
-def _drop_empty_public_payload_values(payload: dict[str, Any]) -> dict[str, Any]:
-    compact: dict[str, Any] = {}
-    for key, item in payload.items():
-        if item is None or item == "" or item == [] or item == {}:
-            continue
-        if key == "primary" and item is False:
-            continue
-        compact[key] = item
-    return compact
-
-
-def public_view_action_button_payload(button: Any, *, compact: bool = False) -> dict[str, Any]:
-    if isinstance(button, ViewActionButtonPatch):
-        payload = button.model_dump(mode="json")
-    elif isinstance(button, dict):
-        payload = dict(button)
-    else:
-        return {}
-    raw_action = payload.get("action", payload.get("trigger_action", payload.get("triggerAction")))
-    if raw_action is not None:
-        payload["action"] = public_button_trigger_action_value(raw_action)
-        payload.pop("trigger_action", None)
-        payload.pop("triggerAction", None)
-    if compact:
-        return _drop_empty_public_payload_values(payload)
-    return payload
-
-
-def public_view_upsert_payload(view: ViewUpsertPatch) -> dict[str, Any]:
-    payload = view.model_dump(mode="json")
-    if view.action_buttons is not None:
-        payload["action_buttons"] = [
-            public_view_action_button_payload(button, compact=True)
-            for button in view.action_buttons
-        ]
-    return payload
-
-
-def public_view_partial_payload(patch: ViewPartialPatch) -> dict[str, Any]:
-    payload = patch.model_dump(mode="json")
-    patch_set = payload.get("set")
-    if isinstance(patch_set, dict):
-        raw_buttons = patch_set.get("action_buttons")
-        if raw_buttons is None:
-            raw_buttons = patch_set.get("actionButtons")
-        if isinstance(raw_buttons, list):
-            patch_set = dict(patch_set)
-            patch_set.pop("actionButtons", None)
-            patch_set["action_buttons"] = [
-                public_view_action_button_payload(button, compact=True)
-                for button in raw_buttons
-            ]
-            payload["set"] = patch_set
-    return payload
-
-
 class CustomButtonJudgeValuePatch(StrictModel):
     id: int | str | None = None
     value: Any | None = None
@@ -1446,30 +1256,11 @@ class CustomButtonFieldMappingPatch(StrictModel):
 
 
 class FieldMatchMappingPatch(StrictModel):
-    target_field: Any = Field(
-        validation_alias=AliasChoices("target_field", "targetField", "target", "field", "field_name", "fieldName")
-    )
+    target_field: Any = Field(validation_alias=AliasChoices("target_field", "targetField", "target", "field"))
     source_field: Any | None = Field(default=None, validation_alias=AliasChoices("source_field", "sourceField", "source"))
     value: Any | None = Field(default=None, validation_alias=AliasChoices("value", "static_value", "staticValue"))
     operator: str = Field(default="eq", validation_alias=AliasChoices("operator", "op", "judge_type", "judgeType"))
 
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_semantic_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        has_static_value = any(key in payload for key in ("value", "static_value", "staticValue"))
-        if "values" in payload:
-            values = payload.pop("values")
-            if has_static_value:
-                return payload
-            if isinstance(values, list) and len(values) == 1:
-                payload["value"] = values[0]
-            else:
-                payload["value"] = values
-        return payload
-
     @model_validator(mode="after")
     def validate_shape(self) -> "FieldMatchMappingPatch":
         has_source = self.source_field is not None and str(self.source_field).strip() != ""
@@ -1816,7 +1607,6 @@ class AssociatedResourcesApplyRequest(StrictModel):
         if not isinstance(value, dict):
             return value
         payload = dict(value)
-        default_target_app_key = str(payload.get("app_key", payload.get("appKey", "")) or "").strip()
         if "upsertResources" in payload and "upsert_resources" not in payload:
             payload["upsert_resources"] = payload.pop("upsertResources")
         if "patchResources" in payload and "patch_resources" not in payload:
@@ -1829,16 +1619,6 @@ class AssociatedResourcesApplyRequest(StrictModel):
             payload["reorder_associated_item_ids"] = payload.pop("reorderAssociatedItemIds")
         if "viewConfigs" in payload and "view_configs" not in payload:
             payload["view_configs"] = payload.pop("viewConfigs")
-        if default_target_app_key and isinstance(payload.get("upsert_resources"), list):
-            normalized_resources = []
-            for item in payload["upsert_resources"]:
-                if isinstance(item, dict) and not any(
-                    str(item.get(key) or "").strip()
-                    for key in ("target_app_key", "targetAppKey", "app_key", "appKey")
-                ):
-                    item = {**item, "target_app_key": default_target_app_key}
-                normalized_resources.append(item)
-            payload["upsert_resources"] = normalized_resources
         return payload
 
     @model_validator(mode="after")
@@ -1983,63 +1763,68 @@ class ChartFilterRulePatch(StrictModel):
         return self
 
 
-class ChartMetricPatch(StrictModel):
-    op: str = "count"
-    field_name: str | None = Field(default=None, validation_alias=AliasChoices("field", "field_name", "fieldName", "name"))
-    alias: str | None = None
+_CHART_METRIC_RE = re.compile(r"^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)\s*$")
 
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_metric(cls, value: Any) -> Any:
-        if isinstance(value, str):
-            raw = value.strip()
-            match = re.fullmatch(r"([A-Za-z_][A-Za-z0-9_]*)\s*\(\s*(.*?)\s*\)", raw)
-            if match:
-                op = match.group(1).strip().lower()
-                field = match.group(2).strip()
-                payload: dict[str, Any] = {"op": op}
-                if field and field != "*":
-                    payload["field_name"] = field
-                return payload
-            if raw:
-                return {"op": "sum", "field_name": raw}
-            return {"op": "count"}
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if "operation" in payload and "op" not in payload:
-            payload["op"] = payload.pop("operation")
-        if "agg" in payload and "op" not in payload:
-            payload["op"] = payload.pop("agg")
-        if "aggregate" in payload and "op" not in payload:
-            payload["op"] = payload.pop("aggregate")
-        if "aggregation" in payload and "op" not in payload:
-            payload["op"] = payload.pop("aggregation")
-        return payload
 
-    @model_validator(mode="after")
-    def validate_metric(self) -> "ChartMetricPatch":
-        normalized_op = str(self.op or "count").strip().lower()
-        op_aliases = {
-            "average": "avg",
-            "mean": "avg",
-            "total": "sum",
-            "cnt": "count",
-            "count_all": "count",
-        }
-        self.op = op_aliases.get(normalized_op, normalized_op)
-        if self.field_name is not None:
-            field_name = str(self.field_name).strip()
-            self.field_name = field_name or None
-        if self.alias is not None:
-            alias = str(self.alias).strip()
-            self.alias = alias or None
-        supported = {"count", "sum", "avg", "max", "min"}
-        if self.op not in supported:
-            raise ValueError(f"chart metric op must be one of {sorted(supported)}")
-        if self.op != "count" and not self.field_name:
-            raise ValueError(f"chart metric op '{self.op}' requires field")
-        return self
+def _normalize_chart_string_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, (list, tuple)):
+        return [str(item).strip() for item in value if item is not None and str(item).strip()]
+    raw = str(value).strip()
+    return [raw] if raw else []
+
+
+def _parse_chart_metric_item(value: Any) -> tuple[list[str], str | None]:
+    if value is None:
+        return [], None
+    if isinstance(value, dict):
+        op = str(value.get("op") or value.get("agg") or value.get("aggregate") or value.get("aggregation") or "").strip().lower()
+        field = value.get("field", value.get("field_name", value.get("name", value.get("selector"))))
+        selectors = _normalize_chart_string_list(field)
+        return selectors, op or ("count" if not selectors else None)
+    raw = str(value).strip()
+    if not raw:
+        return [], None
+    matched = _CHART_METRIC_RE.match(raw)
+    if matched:
+        op = matched.group(1).strip().lower()
+        field = matched.group(2).strip()
+        if field in {"*", ""}:
+            return [], op
+        return [field], op
+    if raw.lower() in {"count", "count(*)"}:
+        return [], "count"
+    return [raw], None
+
+
+def _apply_semantic_chart_metric_aliases(payload: dict[str, Any]) -> None:
+    raw_metrics: list[Any] = []
+    if "metric" in payload:
+        raw_metrics.append(payload.pop("metric"))
+    if "metrics" in payload:
+        metrics = payload.pop("metrics")
+        raw_metrics.extend(metrics if isinstance(metrics, list) else [metrics])
+    if not raw_metrics:
+        return
+    selectors: list[str] = []
+    aggregates: list[str] = []
+    for metric in raw_metrics:
+        metric_selectors, aggregate = _parse_chart_metric_item(metric)
+        selectors.extend(metric_selectors)
+        if aggregate:
+            aggregates.append(aggregate)
+    if selectors and "indicator_field_ids" not in payload:
+        payload["indicator_field_ids"] = selectors
+    if aggregates:
+        normalized_aggregate = aggregates[0]
+        config = payload.get("config")
+        if not isinstance(config, dict):
+            config = {}
+        else:
+            config = dict(config)
+        config.setdefault("aggregate", normalized_aggregate)
+        payload["config"] = config
 
 
 class ChartUpsertPatch(StrictModel):
@@ -2049,17 +1834,6 @@ class ChartUpsertPatch(StrictModel):
     dimension_field_ids: list[str] = Field(default_factory=list)
     indicator_field_ids: list[str] = Field(default_factory=list)
     filters: list[ChartFilterRulePatch] = Field(default_factory=list)
-    group_by: list[str] = Field(default_factory=list)
-    rows: list[str] = Field(default_factory=list)
-    columns: list[str] = Field(default_factory=list)
-    metric: ChartMetricPatch | None = None
-    metrics: list[ChartMetricPatch] = Field(default_factory=list)
-    x_metric: ChartMetricPatch | None = None
-    y_metric: ChartMetricPatch | None = None
-    left_metric: ChartMetricPatch | None = None
-    right_metric: ChartMetricPatch | None = None
-    value_metric: ChartMetricPatch | None = None
-    target_metric: ChartMetricPatch | None = None
     question_config: list[dict[str, Any]] = Field(default_factory=list)
     user_config: list[dict[str, Any]] = Field(default_factory=list)
     config: dict[str, Any] = Field(default_factory=dict)
@@ -2077,74 +1851,19 @@ class ChartUpsertPatch(StrictModel):
             payload["chart_type"] = payload.pop("type")
         if "dimension_fields" in payload and "dimension_field_ids" not in payload:
             payload["dimension_field_ids"] = payload.pop("dimension_fields")
-        if "dimensions" in payload and "dimension_field_ids" not in payload and "group_by" not in payload:
-            payload["group_by"] = payload.pop("dimensions")
-        if "groupBy" in payload and "group_by" not in payload:
-            payload["group_by"] = payload.pop("groupBy")
-        if "where" in payload and "filters" not in payload:
-            payload["filters"] = payload.pop("where")
-        if "filter_rules" in payload and "filters" not in payload:
-            payload["filters"] = payload.pop("filter_rules")
-        if "filterRules" in payload and "filters" not in payload:
-            payload["filters"] = payload.pop("filterRules")
         if "indicator_fields" in payload and "indicator_field_ids" not in payload:
             payload["indicator_field_ids"] = payload.pop("indicator_fields")
         if "metric_field_ids" in payload and "indicator_field_ids" not in payload:
             payload["indicator_field_ids"] = payload.pop("metric_field_ids")
-        metric_slots: list[Any] = []
-        generic_metric_keys = ("metric", "metrics")
-        axis_metric_keys = (
-            "x_metric",
-            "xMetric",
-            "y_metric",
-            "yMetric",
-            "left_metric",
-            "leftMetric",
-            "right_metric",
-            "rightMetric",
-            "value_metric",
-            "valueMetric",
-            "target_metric",
-            "targetMetric",
-        )
-
-        def has_metric_value(key: str) -> bool:
-            entry = payload.get(key)
-            return entry is not None and entry != "" and entry != []
-
-        if any(has_metric_value(key) for key in generic_metric_keys) and any(has_metric_value(key) for key in axis_metric_keys):
-            raise ValueError(
-                "chart metric input is ambiguous: use either metric/metrics or axis-specific "
-                "x_metric/y_metric, left_metric/right_metric, value_metric/target_metric, not both"
-            )
-        if "metric" in payload and "metrics" not in payload:
-            payload["metrics"] = [payload["metric"]]
-        for key in ("x_metric", "xMetric", "left_metric", "leftMetric", "value_metric", "valueMetric"):
-            if key in payload:
-                slot_value = payload.get(key)
-                if slot_value is not None:
-                    metric_slots.append(slot_value)
-                canonical = {
-                    "xMetric": "x_metric",
-                    "leftMetric": "left_metric",
-                    "valueMetric": "value_metric",
-                }.get(key)
-                if canonical and canonical not in payload:
-                    payload[canonical] = payload.pop(key)
-        for key in ("y_metric", "yMetric", "right_metric", "rightMetric", "target_metric", "targetMetric"):
-            if key in payload:
-                slot_value = payload.get(key)
-                if slot_value is not None:
-                    metric_slots.append(slot_value)
-                canonical = {
-                    "yMetric": "y_metric",
-                    "rightMetric": "right_metric",
-                    "targetMetric": "target_metric",
-                }.get(key)
-                if canonical and canonical not in payload:
-                    payload[canonical] = payload.pop(key)
-        if metric_slots and "metrics" not in payload:
-            payload["metrics"] = metric_slots
+        if "group_by" in payload and "dimension_field_ids" not in payload:
+            payload["dimension_field_ids"] = _normalize_chart_string_list(payload.pop("group_by"))
+        if "groupBy" in payload and "dimension_field_ids" not in payload:
+            payload["dimension_field_ids"] = _normalize_chart_string_list(payload.pop("groupBy"))
+        if "where" in payload and "filters" not in payload:
+            payload["filters"] = payload.pop("where")
+        else:
+            payload.pop("where", None)
+        _apply_semantic_chart_metric_aliases(payload)
         raw_type = payload.get("chart_type")
         if isinstance(raw_type, str):
             normalized = raw_type.strip().lower()
@@ -2171,31 +1890,8 @@ class ChartUpsertPatch(StrictModel):
             payload["dimension_field_ids"] = [str(item) for item in payload["dimension_field_ids"] if item is not None and str(item).strip()]
         if isinstance(payload.get("indicator_field_ids"), list):
             payload["indicator_field_ids"] = [str(item) for item in payload["indicator_field_ids"] if item is not None and str(item).strip()]
-        for key in ("group_by", "rows", "columns"):
-            if isinstance(payload.get(key), str):
-                payload[key] = [payload[key]]
-            if isinstance(payload.get(key), list):
-                payload[key] = [str(item) for item in payload[key] if item is not None and str(item).strip()]
         return payload
 
-    @model_validator(mode="after")
-    def apply_semantic_chart_fields(self) -> "ChartUpsertPatch":
-        if self.group_by and not self.dimension_field_ids:
-            self.dimension_field_ids = list(self.group_by)
-        if self.rows and not self.dimension_field_ids:
-            self.dimension_field_ids = list(self.rows)
-        semantic_metrics: list[ChartMetricPatch] = []
-        if self.metrics:
-            semantic_metrics.extend(self.metrics)
-        for metric in (self.x_metric, self.y_metric, self.left_metric, self.right_metric, self.value_metric, self.target_metric):
-            if metric is not None and metric not in semantic_metrics:
-                semantic_metrics.append(metric)
-        if semantic_metrics and not self.metrics:
-            self.metrics = semantic_metrics
-        if self.metrics and not self.metric:
-            self.metric = self.metrics[0]
-        return self
-
 
 class ChartPartialPatch(StrictModel):
     chart_id: str | None = None
@@ -2260,22 +1956,6 @@ class ChartApplyRequest(StrictModel):
         return self
 
 
-class PortalInlineChartPatch(ChartUpsertPatch):
-    app_key: str = Field(validation_alias=AliasChoices("app_key", "appKey"))
-
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_inline_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if "chart_name" in payload and "name" not in payload:
-            payload["name"] = payload.pop("chart_name")
-        if "chartName" in payload and "name" not in payload:
-            payload["name"] = payload.pop("chartName")
-        return payload
-
-
 class PortalComponentPositionPatch(StrictModel):
     pc_x: int = Field(default=0, validation_alias=AliasChoices("pc_x", "pcX", "x"))
     pc_y: int = Field(default=0, validation_alias=AliasChoices("pc_y", "pcY", "y"))
@@ -2322,14 +2002,33 @@ class PortalComponentPositionPatch(StrictModel):
 class PortalChartRefPatch(StrictModel):
     app_key: str | None = None
     chart_id: str | None = None
+    chart_key: str | None = None
     chart_name: str | None = None
 
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_aliases(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        payload = dict(value)
+        if "chartKey" in payload and "chart_key" not in payload:
+            payload["chart_key"] = payload.pop("chartKey")
+        if "chartId" in payload and "chart_id" not in payload:
+            payload["chart_id"] = payload.pop("chartId")
+        if "biChartId" in payload and "chart_id" not in payload:
+            payload["chart_id"] = payload.pop("biChartId")
+        if "chartName" in payload and "chart_name" not in payload:
+            payload["chart_name"] = payload.pop("chartName")
+        if "appKey" in payload and "app_key" not in payload:
+            payload["app_key"] = payload.pop("appKey")
+        return payload
+
     @model_validator(mode="after")
     def validate_target(self) -> "PortalChartRefPatch":
-        if not (self.chart_id or self.chart_name):
-            raise ValueError("chart_ref requires chart_id or chart_name")
-        if self.chart_name and not self.chart_id and not self.app_key:
-            raise ValueError("chart_ref.app_key is required when resolving by chart_name")
+        if not (self.chart_id or self.chart_key or self.chart_name):
+            raise ValueError("chart_ref requires chart_id, chart_key, or chart_name")
+        if self.chart_name and not self.app_key and not (self.chart_id or self.chart_key):
+            raise ValueError("chart_ref with chart_name requires app_key unless chart_id/chart_key is also provided")
         return self
 
 
@@ -2355,12 +2054,12 @@ class PortalViewRefPatch(StrictModel):
 class PortalSectionPatch(StrictModel):
     title: str
     source_type: str = Field(validation_alias=AliasChoices("source_type", "sourceType"))
-    role: str | None = Field(default=None, validation_alias=AliasChoices("role", "zone", "section_role", "sectionRole"))
+    role: str | None = None
     position: PortalComponentPositionPatch | None = None
     dash_style_config: dict[str, Any] | None = Field(default=None, validation_alias=AliasChoices("dash_style_config", "dashStyleConfigBO"))
     config: dict[str, Any] = Field(default_factory=dict)
+    chart: dict[str, Any] | None = None
     chart_ref: PortalChartRefPatch | None = None
-    chart: PortalInlineChartPatch | None = Field(default=None, validation_alias=AliasChoices("chart", "inline_chart", "inlineChart", "create_chart", "createChart"))
     view_ref: PortalViewRefPatch | None = None
     text: str | None = None
     url: str | None = None
@@ -2374,19 +2073,8 @@ class PortalSectionPatch(StrictModel):
         raw_type = payload.get("source_type", payload.get("sourceType"))
         if isinstance(raw_type, str):
             payload["source_type"] = raw_type.strip().lower()
-        raw_role = payload.get("role", payload.get("zone", payload.get("section_role", payload.get("sectionRole"))))
-        if isinstance(raw_role, str):
-            payload["role"] = raw_role.strip().lower()
         if "chartRef" in payload and "chart_ref" not in payload:
             payload["chart_ref"] = payload.pop("chartRef")
-        if "inlineChart" in payload and "chart" not in payload:
-            payload["chart"] = payload.pop("inlineChart")
-        if "inline_chart" in payload and "chart" not in payload:
-            payload["chart"] = payload.pop("inline_chart")
-        if "createChart" in payload and "chart" not in payload:
-            payload["chart"] = payload.pop("createChart")
-        if "create_chart" in payload and "chart" not in payload:
-            payload["chart"] = payload.pop("create_chart")
         if "viewRef" in payload and "view_ref" not in payload:
             payload["view_ref"] = payload.pop("viewRef")
         if "dashStyleConfigBO" in payload and "dash_style_config" not in payload:
@@ -2398,8 +2086,18 @@ class PortalSectionPatch(StrictModel):
         supported = {"chart", "view", "grid", "filter", "text", "link"}
         if self.source_type not in supported:
             raise ValueError(f"unsupported portal source_type '{self.source_type}'")
-        if self.source_type == "chart" and self.chart_ref is None and self.chart is None:
-            raise ValueError("chart section requires chart_ref or chart")
+        if self.role is not None:
+            normalized_role = str(self.role or "").strip().lower()
+            if normalized_role not in {"metric"}:
+                raise ValueError(f"unsupported portal section role '{self.role}'")
+            self.role = normalized_role
+            if self.source_type != "chart":
+                raise ValueError("portal section role is only supported for chart sections")
+        if self.source_type == "chart":
+            if self.chart is not None and self.chart_ref is not None:
+                raise ValueError("chart section accepts either chart or chart_ref, not both")
+            if self.chart is None and self.chart_ref is None:
+                raise ValueError("chart section requires chart or chart_ref")
         if self.source_type == "view" and self.view_ref is None:
             raise ValueError("view section requires view_ref")
         if self.source_type == "text" and self.text is None:
@@ -2536,7 +2234,6 @@ AppReadSummaryResponse = AppGetResponse
 AppFieldsReadResponse = AppGetFieldsResponse
 AppLayoutReadResponse = AppGetLayoutResponse
 AppViewsReadResponse = AppGetViewsResponse
-AppFlowReadResponse = AppGetFlowResponse
 AppChartsReadResponse = AppGetChartsResponse
 
 
@@ -2590,9 +2287,6 @@ class ChartGetResponse(StrictModel):
     chart_id: str
     base: dict[str, Any] = Field(default_factory=dict)
     visibility: dict[str, Any] = Field(default_factory=dict)
-    filters: list[list[dict[str, Any]]] = Field(default_factory=list)
-    group_by: list[str] = Field(default_factory=list)
-    metrics: list[dict[str, Any]] = Field(default_factory=list)
     config: dict[str, Any] = Field(default_factory=dict)
 
 
@@ -2603,6 +2297,7 @@ class SchemaPlanRequest(StrictModel):
     icon: str | None = None
     color: str | None = None
     visibility: VisibilityPatch | None = None
+    create_if_missing: bool = False
     add_fields: list[FieldPatch] = Field(default_factory=list)
     update_fields: list[FieldUpdatePatch] = Field(default_factory=list)
     remove_fields: list[FieldRemovePatch] = Field(default_factory=list)
@@ -2625,40 +2320,6 @@ class LayoutPlanRequest(StrictModel):
         return payload
 
 
-class FlowPlanRequest(StrictModel):
-    app_key: str
-    mode: str = "replace"
-    nodes: list[FlowNodePatch] = Field(default_factory=list)
-    transitions: list[FlowTransitionPatch] = Field(default_factory=list)
-    preset: FlowPreset | None = None
-
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_mode_alias(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if str(payload.get("mode") or "").strip().lower() == "overwrite":
-            payload["mode"] = "replace"
-        raw_preset = payload.get("preset")
-        if raw_preset is None and isinstance(payload.get("base_preset"), str):
-            raw_preset = payload["base_preset"]
-            payload["preset"] = raw_preset
-        if isinstance(raw_preset, str):
-            normalized_preset = raw_preset.strip().lower()
-            preset_aliases = {
-                "default_approval": FlowPreset.basic_approval.value,
-                "approval": FlowPreset.basic_approval.value,
-                "basic approval": FlowPreset.basic_approval.value,
-                "default_fill_then_approve": FlowPreset.basic_fill_then_approve.value,
-                "default-fill-then-approve": FlowPreset.basic_fill_then_approve.value,
-                "fill_then_approve": FlowPreset.basic_fill_then_approve.value,
-            }
-            if normalized_preset in preset_aliases:
-                payload["preset"] = preset_aliases[normalized_preset]
-        return payload
-
-
 class ViewsPlanRequest(StrictModel):
     app_key: str
     upsert_views: list[ViewUpsertPatch] = Field(default_factory=list)
@@ -2686,18 +2347,8 @@ def _normalize_field_payload(value: Any) -> Any:
     if not isinstance(value, dict):
         return value
     payload = dict(value)
-    if "data_title" in payload and "as_data_title" not in payload and "asDataTitle" not in payload:
-        payload["as_data_title"] = payload.pop("data_title")
-    if "dataTitle" in payload and "as_data_title" not in payload and "asDataTitle" not in payload:
-        payload["as_data_title"] = payload.pop("dataTitle")
-    if "data_cover" in payload and "as_data_cover" not in payload and "asDataCover" not in payload:
-        payload["as_data_cover"] = payload.pop("data_cover")
-    if "dataCover" in payload and "as_data_cover" not in payload and "asDataCover" not in payload:
-        payload["as_data_cover"] = payload.pop("dataCover")
     if "fields" in payload and "subfields" not in payload:
         payload["subfields"] = payload.pop("fields")
-    if "options" in payload:
-        payload["options"] = _normalize_field_options(payload.get("options"))
     raw_type = payload.get("type")
     if isinstance(raw_type, int):
         normalized_from_id = FIELD_TYPE_ID_ALIASES.get(raw_type)
@@ -2730,34 +2381,6 @@ def _normalize_field_payload(value: Any) -> Any:
     return payload
 
 
-def _normalize_field_options(value: Any) -> Any:
-    if not isinstance(value, list):
-        return value
-    normalized: list[str] = []
-    for item in value:
-        if isinstance(item, str):
-            normalized.append(item)
-            continue
-        if isinstance(item, (int, float, bool)):
-            normalized.append(str(item))
-            continue
-        if isinstance(item, dict):
-            label = (
-                item.get("label")
-                or item.get("name")
-                or item.get("title")
-                or item.get("value")
-                or item.get("text")
-                or item.get("optValue")
-                or item.get("optName")
-            )
-            if label is not None:
-                normalized.append(str(label))
-                continue
-        normalized.append(str(item))
-    return normalized
-
-
 def _slugify_title(title: str) -> str:
     normalized = "".join(ch.lower() if ch.isalnum() else "_" for ch in str(title or ""))
     collapsed = "_".join(part for part in normalized.split("_") if part)