@qingflow-tech/qingflow-cli 1.1.2 → 1.1.34

package/src/qingflow_mcp/builder_facade/models.py

@@ -203,6 +203,10 @@ 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"
@@ -243,6 +247,116 @@ class ViewFilterOperator(str, Enum):
     not_empty = "not_empty"
 
 
+_PUBLIC_CONDITION_OPERATOR_ALIASES: dict[str, str] = {
+    "eq": "eq",
+    "equal": "eq",
+    "equals": "eq",
+    "=": "eq",
+    "==": "eq",
+    "neq": "neq",
+    "ne": "neq",
+    "not_eq": "neq",
+    "not_equal": "neq",
+    "not_equals": "neq",
+    "noteq": "neq",
+    "notequal": "neq",
+    "notequals": "neq",
+    "!=": "neq",
+    "in": "in",
+    "any": "in",
+    "any_of": "in",
+    "anyof": "in",
+    "one_of": "in",
+    "oneof": "in",
+    "between_any": "in",
+    "betweenany": "in",
+    "equal_any": "in",
+    "equalany": "in",
+    "any_match": "in",
+    "anymatch": "in",
+    "contains": "contains",
+    "contain": "contains",
+    "include": "contains",
+    "includes": "contains",
+    "like": "contains",
+    "fuzzy": "contains",
+    "fuzzy_match": "contains",
+    "fuzzymatch": "contains",
+    "gte": "gte",
+    "ge": "gte",
+    ">=": "gte",
+    "greater_or_equal": "gte",
+    "greaterorequal": "gte",
+    "greater_than_or_equal": "gte",
+    "greaterthanorequal": "gte",
+    "lte": "lte",
+    "le": "lte",
+    "<=": "lte",
+    "less_or_equal": "lte",
+    "lessorequal": "lte",
+    "less_than_or_equal": "lte",
+    "lessthanorequal": "lte",
+    "is_empty": "is_empty",
+    "isempty": "is_empty",
+    "empty": "is_empty",
+    "blank": "is_empty",
+    "is_blank": "is_empty",
+    "isblank": "is_empty",
+    "null": "is_empty",
+    "is_null": "is_empty",
+    "isnull": "is_empty",
+    "not_empty": "not_empty",
+    "notempty": "not_empty",
+    "is_not_empty": "not_empty",
+    "isnotempty": "not_empty",
+    "not_blank": "not_empty",
+    "notblank": "not_empty",
+    "not_null": "not_empty",
+    "notnull": "not_empty",
+    "is_not_null": "not_empty",
+    "isnotnull": "not_empty",
+}
+
+
+def normalize_public_condition_operator(raw_operator: Any, *, extra_aliases: dict[str, str] | None = None) -> Any:
+    if not isinstance(raw_operator, str):
+        return raw_operator
+    text = raw_operator.strip().lower()
+    if not text:
+        return text
+    lookup = dict(_PUBLIC_CONDITION_OPERATOR_ALIASES)
+    if extra_aliases:
+        lookup.update(extra_aliases)
+    candidates = [
+        text,
+        re.sub(r"[\s-]+", "_", text),
+        re.sub(r"[\s_-]+", "", text),
+    ]
+    for candidate in candidates:
+        if candidate in lookup:
+            return lookup[candidate]
+    return text
+
+
+def _normalize_public_condition_payload(value: Any) -> Any:
+    if not isinstance(value, dict):
+        return value
+    payload = dict(value)
+    if "value" in payload and "values" not in payload:
+        raw_value = payload.pop("value")
+        payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
+    elif "values" in payload and not isinstance(payload.get("values"), list):
+        payload["values"] = [payload.get("values")]
+    raw_operator = payload.get("operator", payload.get("op"))
+    if raw_operator is None:
+        payload["operator"] = "eq"
+        raw_operator = "eq"
+    if isinstance(raw_operator, str):
+        payload["operator"] = normalize_public_condition_operator(raw_operator)
+    payload.pop("op", None)
+    return payload
+
+
 class FlowAssigneePatch(StrictModel):
     role_ids: list[int] = Field(default_factory=list)
     role_names: list[str] = Field(default_factory=list)
@@ -258,45 +372,13 @@ class FlowNodePermissionsPatch(StrictModel):
 
 class FlowConditionRulePatch(StrictModel):
     field_name: str = Field(validation_alias=AliasChoices("field_name", "fieldName", "field", "name"))
-    operator: FlowConditionOperator = Field(validation_alias=AliasChoices("operator", "op"))
+    operator: FlowConditionOperator = Field(default=FlowConditionOperator.eq, validation_alias=AliasChoices("operator", "op"))
     values: list[Any] = Field(default_factory=list)
 
     @model_validator(mode="before")
     @classmethod
     def normalize_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if "value" in payload and "values" not in payload:
-            raw_value = payload.pop("value")
-            payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
-        raw_operator = payload.get("operator", payload.get("op"))
-        if isinstance(raw_operator, str):
-            normalized = raw_operator.strip().lower()
-            operator_aliases = {
-                "equals": FlowConditionOperator.eq.value,
-                "equal": FlowConditionOperator.eq.value,
-                "=": FlowConditionOperator.eq.value,
-                "not_equals": FlowConditionOperator.neq.value,
-                "not_equal": FlowConditionOperator.neq.value,
-                "!=": FlowConditionOperator.neq.value,
-                ">=": FlowConditionOperator.gte.value,
-                "<=": FlowConditionOperator.lte.value,
-                "any_of": FlowConditionOperator.in_.value,
-                "one_of": FlowConditionOperator.in_.value,
-                "between_any": FlowConditionOperator.in_.value,
-                "empty": FlowConditionOperator.is_empty.value,
-                "is blank": FlowConditionOperator.is_empty.value,
-                "blank": FlowConditionOperator.is_empty.value,
-                "not_empty": FlowConditionOperator.not_empty.value,
-                "not blank": FlowConditionOperator.not_empty.value,
-            }
-            if normalized in operator_aliases:
-                payload["operator"] = operator_aliases[normalized]
-            elif "operator" not in payload:
-                payload["operator"] = normalized
-        payload.pop("op", None)
-        return payload
+        return _normalize_public_condition_payload(value)
 
     @model_validator(mode="after")
     def validate_shape(self) -> "FlowConditionRulePatch":
@@ -310,45 +392,13 @@ class FlowConditionRulePatch(StrictModel):
 
 class ViewFilterRulePatch(StrictModel):
     field_name: str = Field(validation_alias=AliasChoices("field_name", "fieldName", "field", "name"))
-    operator: ViewFilterOperator = Field(validation_alias=AliasChoices("operator", "op"))
+    operator: ViewFilterOperator = Field(default=ViewFilterOperator.eq, validation_alias=AliasChoices("operator", "op"))
     values: list[Any] = Field(default_factory=list)
 
     @model_validator(mode="before")
     @classmethod
     def normalize_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if "value" in payload and "values" not in payload:
-            raw_value = payload.pop("value")
-            payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
-        raw_operator = payload.get("operator", payload.get("op"))
-        if isinstance(raw_operator, str):
-            normalized = raw_operator.strip().lower()
-            operator_aliases = {
-                "equals": ViewFilterOperator.eq.value,
-                "equal": ViewFilterOperator.eq.value,
-                "=": ViewFilterOperator.eq.value,
-                "not_equals": ViewFilterOperator.neq.value,
-                "not_equal": ViewFilterOperator.neq.value,
-                "!=": ViewFilterOperator.neq.value,
-                ">=": ViewFilterOperator.gte.value,
-                "<=": ViewFilterOperator.lte.value,
-                "any_of": ViewFilterOperator.in_.value,
-                "one_of": ViewFilterOperator.in_.value,
-                "between_any": ViewFilterOperator.in_.value,
-                "empty": ViewFilterOperator.is_empty.value,
-                "is blank": ViewFilterOperator.is_empty.value,
-                "blank": ViewFilterOperator.is_empty.value,
-                "not_empty": ViewFilterOperator.not_empty.value,
-                "not blank": ViewFilterOperator.not_empty.value,
-            }
-            if normalized in operator_aliases:
-                payload["operator"] = operator_aliases[normalized]
-            elif "operator" not in payload:
-                payload["operator"] = normalized
-        payload.pop("op", None)
-        return payload
+        return _normalize_public_condition_payload(value)
 
     @model_validator(mode="after")
     def validate_shape(self) -> "ViewFilterRulePatch":
@@ -1101,6 +1151,91 @@ 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"))
@@ -1112,6 +1247,8 @@ 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(
@@ -1161,6 +1298,12 @@ 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()
@@ -1182,6 +1325,10 @@ 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
 
 
@@ -1207,6 +1354,76 @@ 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
@@ -1275,32 +1492,39 @@ 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", "field_name", "fieldName", "name"))
     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"))
+    value: Any | None = Field(default=None, validation_alias=AliasChoices("value", "values", "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:
+    def normalize_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]
+        if "values" in payload and "value" not in payload:
+            raw_values = payload.pop("values")
+            if isinstance(raw_values, list) and len(raw_values) == 1:
+                payload["value"] = raw_values[0]
             else:
-                payload["value"] = values
+                payload["value"] = raw_values
+        raw_operator = payload.get("operator", payload.get("op", payload.get("judge_type", payload.get("judgeType"))))
+        if isinstance(raw_operator, str):
+            payload["operator"] = normalize_public_condition_operator(
+                raw_operator,
+                extra_aliases={"include_any": "include_any", "includes_any": "include_any", "includeany": "include_any"},
+            )
+        for alias in ("op", "judge_type", "judgeType"):
+            payload.pop(alias, None)
         return payload
 
     @model_validator(mode="after")
     def validate_shape(self) -> "FieldMatchMappingPatch":
+        if str(self.operator or "").strip().lower() in {"is_empty", "not_empty"}:
+            self.source_field = None
+            self.value = None
+            return self
         has_source = self.source_field is not None and str(self.source_field).strip() != ""
         has_value = self.value is not None
         if has_source == has_value:
@@ -1762,45 +1986,13 @@ class ViewButtonBindingPatch(StrictModel):
 
 class ChartFilterRulePatch(StrictModel):
     field_name: str = Field(validation_alias=AliasChoices("field_name", "fieldName", "field", "name"))
-    operator: ViewFilterOperator = Field(validation_alias=AliasChoices("operator", "op"))
+    operator: ViewFilterOperator = Field(default=ViewFilterOperator.eq, validation_alias=AliasChoices("operator", "op"))
     values: list[Any] = Field(default_factory=list)
 
     @model_validator(mode="before")
     @classmethod
     def normalize_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if "value" in payload and "values" not in payload:
-            raw_value = payload.pop("value")
-            payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
-        raw_operator = payload.get("operator", payload.get("op"))
-        if isinstance(raw_operator, str):
-            normalized = raw_operator.strip().lower()
-            operator_aliases = {
-                "equals": ViewFilterOperator.eq.value,
-                "equal": ViewFilterOperator.eq.value,
-                "=": ViewFilterOperator.eq.value,
-                "not_equals": ViewFilterOperator.neq.value,
-                "not_equal": ViewFilterOperator.neq.value,
-                "!=": ViewFilterOperator.neq.value,
-                ">=": ViewFilterOperator.gte.value,
-                "<=": ViewFilterOperator.lte.value,
-                "any_of": ViewFilterOperator.in_.value,
-                "one_of": ViewFilterOperator.in_.value,
-                "between_any": ViewFilterOperator.in_.value,
-                "empty": ViewFilterOperator.is_empty.value,
-                "is blank": ViewFilterOperator.is_empty.value,
-                "blank": ViewFilterOperator.is_empty.value,
-                "not_empty": ViewFilterOperator.not_empty.value,
-                "not blank": ViewFilterOperator.not_empty.value,
-            }
-            if normalized in operator_aliases:
-                payload["operator"] = operator_aliases[normalized]
-            elif "operator" not in payload:
-                payload["operator"] = normalized
-        payload.pop("op", None)
-        return payload
+        return _normalize_public_condition_payload(value)
 
     @model_validator(mode="after")
     def validate_shape(self) -> "ChartFilterRulePatch":
@@ -2089,6 +2281,22 @@ 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"))
@@ -2133,14 +2341,36 @@ class PortalComponentPositionPatch(StrictModel):
 
 
 class PortalChartRefPatch(StrictModel):
-    app_key: str
+    app_key: str | None = None
     chart_id: 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 "chartId" in payload and "chart_id" not in payload:
+            payload["chart_id"] = payload.pop("chartId")
+        if "chart_key" in payload and "chart_id" not in payload:
+            payload["chart_id"] = payload.pop("chart_key")
+        if "chartKey" in payload and "chart_id" not in payload:
+            payload["chart_id"] = payload.pop("chartKey")
+        if "chartName" in payload and "chart_name" not in payload:
+            payload["chart_name"] = payload.pop("chartName")
+        if "name" in payload and "chart_name" not in payload:
+            payload["chart_name"] = payload.pop("name")
+        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")
         return self
 
 
@@ -2171,6 +2401,7 @@ class PortalSectionPatch(StrictModel):
     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_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
@@ -2189,6 +2420,27 @@ class PortalSectionPatch(StrictModel):
             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")
+        raw_chart = payload.get("chart")
+        if isinstance(raw_chart, dict):
+            chart_payload = dict(raw_chart)
+            has_ref_id = any(key in chart_payload for key in ("chart_id", "chartId", "chart_key", "chartKey"))
+            has_chart_type = any(key in chart_payload for key in ("chart_type", "chartType"))
+            has_create_config = has_chart_type or any(
+                key in chart_payload
+                for key in ("metric", "metrics", "group_by", "groupBy", "where", "filters", "dimensions")
+            )
+            has_ref_name = any(key in chart_payload for key in ("chart_name", "chartName", "name"))
+            if has_ref_id or (has_ref_name and not has_create_config):
+                payload["chart_ref"] = chart_payload
+                payload.pop("chart", None)
         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:
@@ -2200,8 +2452,8 @@ 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:
-            raise ValueError("chart section requires chart_ref")
+        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.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:
@@ -2338,6 +2590,7 @@ AppReadSummaryResponse = AppGetResponse
 AppFieldsReadResponse = AppGetFieldsResponse
 AppLayoutReadResponse = AppGetLayoutResponse
 AppViewsReadResponse = AppGetViewsResponse
+AppFlowReadResponse = AppGetFlowResponse
 AppChartsReadResponse = AppGetChartsResponse
 
 
@@ -2404,7 +2657,6 @@ 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)
@@ -2427,6 +2679,40 @@ 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)
@@ -2454,6 +2740,14 @@ 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: