invoke("print_table", attribute_dict: dict, head_content_or_cb: str, body_content_or_cb: str) -> str

def print_table(attribute_dict: dict, head_content_or_cb: str, body_content_or_cb: str) -> str:
"""打印记录表

    Args:
        attribute_dict: 记录表属性字典
        head_content_or_cb: 记录头内容或回调函数
        body_content_or_cb: 记录体内容或回调函数
        template_content: 模板内容
        template_file: 模板文件

    Returns:
        返回渲染后页片"""

invoke("print_td", attribute_dict: dict, content_or_cb: str) -> str

def print_td(attribute_dict: dict, content_or_cb: str) -> str:
"""打印表格头单元格

    示例:
        invoke('print_td', {}, 'aaa')  ==> aaa

    Args:
        attribute_dict: 属性字典
        content_or_cb: 内容或回调函数

    Returns:
        返回按钮组页片"""

invoke("print_th", attribute_dict: dict, content_or_cb: str) -> str

def print_th(attribute_dict: dict, content_or_cb: str) -> str:
"""打印表格头单元格

    示例:
        invoke('print_th', {}, 'aaa')  ==> aaa

    Args:
        attribute_dict: 属性字典
        content_or_cb: 内容或回调函数

    Returns:
        返回按钮组页片"""

invoke("print_timeline", attribute_dict: dict, item_content_or_cb_list: list) -> str

def print_timeline(attribute_dict: dict, item_content_or_cb_list: list) -> str:
"""打印timeline

    示例:

        label_content = invoke('print_timeline_label', {'class': 'bg-red'}, '10 Feb. 2014')
        item_content_list = [invoke('print_timeline_item_container', {'icon.class': 'fas fa-envelope bg-blue'}, '12:05', 'title', 'content', 'footer'),  #pylint: disable=line-too-long
                             invoke('print_timeline_item_container', {}, '', '', '', '')]
        invoke('print_timeline', {}, label_content, item_content_list)  ==>

            

                

                    10 Feb. 2014
                
                

                     
                    

                        12:05
                        
title
                        
content
                        
footer
                    
                
                

                     
                
            

    Args:
        attribute_dict: 属性字典
        item_content_or_cb_list: 项目内容或回调列表

    Returns:
        返回timeline-item容器"""

invoke("print_timeline_body", attribute_dict: dict, content_or_cb: str) -> str

def print_timeline_body(attribute_dict: dict, content_or_cb: str) -> str:
"""打印timeline-item的主体部件

    示例:
        invoke('print_timeline_body', {}, "主体")  ==>  
主体

    Args:
        attribute_dict: 属性字典
        content_or_cb: 文本内容或回调函数

    Returns:
        返回timeline-item的主体部件"""

invoke("print_timeline_footer", attribute_dict: dict, content_or_cb: str) -> str

def print_timeline_footer(attribute_dict: dict, content_or_cb: str) -> str:
"""打印timeline-item的底部件

    示例:
        invoke('print_timeline_footer', {}, "底部")  ==>  
底部

    Args:
        attribute_dict: 属性字典
        content_or_cb: 文本内容或回调函数

    Returns:
        返回timeline-item的底部件"""

invoke("print_timeline_header", attribute_dict: dict, content_or_cb: str) -> str

def print_timeline_header(attribute_dict: dict, content_or_cb: str) -> str:
"""打印timeline-item的标题部件

    示例:
        invoke('print_timeline_header', {}, "标题")  ==>  
标题

    Args:
        attribute_dict: 属性字典
        content_or_cb: 文本内容或回调函数

    Returns:
        返回timeline-item的标题部件"""

invoke("print_timeline_icon", attribute_dict: dict) -> str

def print_timeline_icon(attribute_dict: dict) -> str:
"""打印timeline的时间轴图标

    示例:
        print_timeline_icon({'class': 'fas fa-envelope bg-blue'})  ==>  

    Args:
        attribute_dict: 属性字典

    Returns:
        返回timeline的时间轴图标"""

invoke("print_timeline_item", attribute_dict: dict, content_or_cb: str) -> str

def print_timeline_item(attribute_dict: dict, content_or_cb: str) -> str:
"""打印timeline-item(内容可包括time、header、body、footer)

    示例:
        invoke('print_timeline_item_impl', {}, "item")  ==>  
item

    Args:
        attribute_dict: 属性字典
        content_or_cb: 文本内容或回调函数

    Returns:
        返回timeline-item"""

invoke("print_timeline_item_container", attribute_dict: dict, time_content_or_cb: str, header_content_or_cb: str, body_content_or_cb: str, footer_content_or_cb: str) -> str

def print_timeline_item_container(attribute_dict: dict, time_content_or_cb: str, header_content_or_cb: str, body_content_or_cb: str, footer_content_or_cb: str) -> str:
"""打印timeline-item容器(可包括icon、time、header、body、footer)

    示例:

        invoke('print_timeline_item_container', {'icon.class': 'fas fa-envelope bg-blue'}, '12:05', 'title', 'content', 'footer')  ==>

            

                 
                

                    12:05
                    
title
                    
content
                    
footer
                
            

    Args:
        attribute_dict: 属性字典
        time_content_or_cb: 时间内容或回调
        header_content_or_cb: 标题内容或回调
        body_content_or_cb: 主体内容或回调
        footer_content_or_cb: 底部内容或回调

    Returns:
        返回timeline-item容器"""

invoke("print_timeline_label", attribute_dict: dict, content_or_cb: str) -> str

def print_timeline_label(attribute_dict: dict, content_or_cb: str) -> str:
"""打印timeline文本

    示例:
        print_timeline_label({'class': 'bg-red'}, '10 Feb. 2014')  ==>

            

                10 Feb. 2014
            

    Args:
        attribute_dict: 属性字典
        content_or_cb: 文本内容或回调函数

    Returns:
        返回timeline文本"""

invoke("print_timeline_time", attribute_dict: dict, content_or_cb: str) -> str

def print_timeline_time(attribute_dict: dict, content_or_cb: str) -> str:
"""打印timeline-item的时间部件(右上角)

    示例:
        invvoke('print_timeline_time', {}, "两天前")  ==>  两天前

    Args:
        attribute_dict: 属性字典
        content_or_cb: 文本内容或回调函数

    Returns:
        返回timeline-item的时间部件"""

invoke("print_toolbar", toolbar_dict: dict, content_or_cb) -> str

def print_toolbar(toolbar_dict: dict, content_or_cb) -> str:
"""打印工具条部件

    示例:

        invoke('print_toolbar', {}, '提交')  ==>

            

                提交
            

    Args:
        toolbar_dict: 工具条部件属性字典
        content_or_cb: 工具条内容或回调函数

    Returns:
        返回工具条部件"""

invoke("print_tr", attribute_dict: dict, content_or_cb: str) -> str

def print_tr(attribute_dict: dict, content_or_cb: str) -> str:
"""打印表格行

    示例:
        invoke('print_tr', {}, 'hello')  ==>

            
                hello
            

    Args:
        attribute_dict: 属性字典
        content_or_cb: 内容或回调函数

    Returns:
        返回按钮组页片"""

invoke("print_widget", tag_name: str, attribute_dict_or_cb: dict, content_or_cb: str = None, attribute_dict_verify_cb: object = None) -> str

def print_widget(tag_name: str, attribute_dict_or_cb: dict, content_or_cb: str = None, attribute_dict_verify_cb: object = None) -> str:
"""打印部件

    Args:
        tag_name: 标签名(div, ...)
        attribute_dict_or_cb: 部件属性字典或回调
        content_or_cb: 部件内容或者回调
        attribute_dict_verify_cb: 部件属性字典验证回调函数(可用于补充部件属性): def _attribute_dict_cb(widget_attribute_dict) -> (True|False, {error_message})或None

    Returns:
        返回部件页片"""

invoke("read_file", path_name: str) -> bytes

def read_file(path_name: str) -> bytes:
"""读入文件内容.

    Args:
        path_name: 目标文件.

    Returns:
        返回文件内容,失败时返回None"""

invoke("record_list_to_dict_list", field_id_list: list, record_list: list)

def record_list_to_dict_list(field_id_list: list, record_list: list):
"""记录集合转换为字典列表

    Args:
        field_id_list: 字典id列表
        record_list: 记录列表

    Returns:
        返回对象字典列表"""

invoke("record_to_dict", field_id_list: list, record: list)

def record_to_dict(field_id_list: list, record: list):
"""记录转换为字典

    Args:
        field_id_list: 字段id列表
        record: 记录

    Returns:
        返回对象字典"""

invoke("register_named_object", name: str, named_object: object) -> None

def register_named_object(name: str, named_object: object) -> None:
"""注册命名资源对象.

    Args:
        name: 对象名称
        named_object: 命名对象"""

invoke("register_observer", type_name: str, action_type: str, func) -> None

def register_observer(type_name: str, action_type: str, func) -> None:
"""注册观察者.

    Args:
        type_name: 类型名称
        action_type: 行为名称
        func: 观察者函数"""

invoke("remove_accessory", accessory_id: str) -> tuple

def remove_accessory(accessory_id: str) -> tuple:
"""删除附件

    Args:
        accessory_id: 附件id

    Returns:
        返回(True, '')或者{False, {error_message})"""

invoke("render_error_in_dialog", caption: str, message: str, next_url: str = None) -> dict

def render_error_in_dialog(caption: str, message: str, next_url: str = None) -> dict:
"""渲染错误对话框

    Args:
        caption: 标题
        message: 信息
        next_url: 返回url

    Returns:
        返回错误对话框页面"""

invoke("render_error_in_page", caption: str, message: str, next_url: str = None) -> dict

def render_error_in_page(caption: str, message: str, next_url: str = None) -> dict:
"""渲染错误页面

    Args:
        caption: 标题
        message: 信息
        next_url: 返回url

    Returns:
        返回错误页面"""

invoke("render_named_string", xml_file: str, string_name: str) -> str

def render_named_string(xml_file: str, string_name: str) -> str:
"""渲染命名字符串

    Args:
        xml_file: xml文件
        string_name: 字符串名称

    Returns:
        返回字符串"""

invoke("render_named_value", template_content: str, now=None) -> str

def render_named_value(template_content: str, now=None) -> str:
"""渲染命名值.

    支持的命名值包括::

            {before_last_year}: 前年
            {last_year}: 去年
            {year}: 年
            {next_year}: 明年
            {after_next_year}: 后年
            {before_last_month}: 上上个月
            {last_month}: 上个月
            {month}: 月
            {next_month}: 下个月
            {after_next_month}: 下下个月
            {day}: 天
            {today}: 今天
            {now}: 现在
            {generate_uuid}': 生产uuid

    Args:
        template_content: 模板内容
        now: 当前时间

    Returns:
        返回渲染后的命名值"""

invoke("render_success_in_dialog", caption: str, message: str, next_url: str = None) -> dict

def render_success_in_dialog(caption: str, message: str, next_url: str = None) -> dict:
"""渲染成功对话框

    Args:
        caption: 标题
        message: 信息
        next_url: 返回url

    Returns:
        返回成功对话框"""

invoke("render_success_in_page", caption: str, message: str, next_url: str = None) -> dict

def render_success_in_page(caption: str, message: str, next_url: str = None) -> dict:
"""渲染成功页面

    Args:
        caption: 标题
        message: 信息
        next_url: 返回url

    Returns:
        返回成功页面"""

invoke("render_template", template_content_or_cb, render_dict_or_cb) -> str

def render_template(template_content_or_cb, render_dict_or_cb) -> str:
"""渲染模板

    Args:
        template_content_or_cb: 模板内容或回调函数
        render_dict_or_cb: 渲染字典或回调函数

    Returns:
        返回渲染结果"""

invoke("render_template_file", template_file_or_cb, render_dict_or_cb) -> str

def render_template_file(template_file_or_cb, render_dict_or_cb) -> str:
"""渲染模板文件

    Args:
        template_file_or_cb: 模板文件或回调函数
        render_dict_or_cb: 渲染字典或回调函数

    Returns:
        返回渲染结果"""

invoke("request_page", type_name: str, action_type: str, context_dict: dict = None) -> str

def request_page(type_name: str, action_type: str, context_dict: dict = None) -> str:
"""请求显示页面

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回显示页面(html)内容."""

invoke("run_event_loop") -> None

def run_event_loop() -> None:
"""运行消息循环"""

invoke("safe_get_named_object", name: str, default_value_cb: ) -> object

def safe_get_named_object(name: str, default_value_cb: ) -> object:
"""得到命名资源对象.

    Args:
        name: 对象名称
        default_value_cb: 得到缺省值回调函数

    Returns:
        返回命名对象或者None"""

invoke("scan_and_load_modules", application_path: str, root_path: str, module_name: str, filter_function: ) -> tuple

def scan_and_load_modules(application_path: str, root_path: str, module_name: str, filter_function: ) -> tuple:
"""扫描并加载模块集

    Args:
        application_path: 应用程序路径
        root_path: 扫描根路径
        module_name: 模块描述名
        filter_function: 过滤函数: def _filter_cb(file_path: str, file_name: str) -> bool

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("scan_and_load_service_modules", application_path: str, root_path: str) -> tuple

def scan_and_load_service_modules(application_path: str, root_path: str) -> tuple:
"""扫描并加载服务模块集

    Args:
        application_path: 应用程序路径
        root_path: 扫描根路径

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("scan_and_load_sub_views", views_py_path_name: str, sub_view_prefix: str = None) -> tuple

def scan_and_load_sub_views(views_py_path_name: str, sub_view_prefix: str = None) -> tuple:
"""扫描并加载指定目录下的子视图("view_xxx.py")

    用于每个app目录下的"views.py"模块加载同app目录下的子视图：

        invoke('scan_and_load_sub_views', __file__)

    Args:
        views_py_path_name: views.py全路径文件
        sub_view_prefix: 子视图前缀

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("scan_subclass_types", root_path: str, parent_class_type: object, module_name_prefix: str = '') -> tuple

def scan_subclass_types(root_path: str, parent_class_type: object, module_name_prefix: str = '') -> tuple:
"""从指定目录中扫描派生类型

    Args:
        root_path: 开始目录
        parent_class_type: 父类类型
        module_name_prefix: 模块名前缀(适用于从子目录开始导入模块)

    Returns:
        返回(True, {类型名称: 类})或(False, {error_message})"""

invoke("set_application_started", started: bool = True)

def set_application_started(started: bool = True):
"""设置程序已经开始

    Args:
        started: 是否已经开始"""

invoke("set_menu_root_element_dirty", update_now: bool = True) -> lxml.etree._Element

def set_menu_root_element_dirty(update_now: bool = True) -> lxml.etree._Element:
"""设置菜单根节点需要更新

    Args:
        update_now: 是否立即更新

    Returns:
        返回更新后的菜单根节点"""

invoke("set_project_path", project_path_name: str) -> None

def set_project_path(project_path_name: str) -> None:
"""设置项目路径.

    设置当前的项目路径.用于运行时指定项目路径，从而支持单一程序，多项目数据支持.

    Args:
        project_path_name: 项目数据目录"""

invoke("set_user_login", user_account: str, post_sn: str, response_: object) -> None

def set_user_login(user_account: str, post_sn: str, response_: object) -> None:
"""设置用户信息

    Args:
        user_account: 用户帐户
        post_sn: 岗位编号
        response_: bottle响应对象."""

invoke("set_user_logout", response_: object) -> None

def set_user_logout(response_: object) -> None:
"""设置用户为未登录状态

    Args:
        response_: bottle响应对象."""

invoke("set_user_password", user_account: str, user_password: str) -> tuple

def set_user_password(user_account: str, user_password: str) -> tuple:
"""设置密码

    Args:
        user_account: 用户帐户
        user_password: 密码

    Returns:
        返回(True, '')或者(False, {error_message})"""

invoke("set_widget_default_attributes", widget_attribute_dict: dict, default_attribute_dict: dict, class_radio_value_list: list = None) -> None

def set_widget_default_attributes(widget_attribute_dict: dict, default_attribute_dict: dict, class_radio_value_list: list = None) -> None:
"""设置部件缺省属性

    Args:
        widget_attribute_dict: 部件属性字典
        default_attribute_dict: 缺省属性字典
        class_radio_value_list: 类的单选择列表"""

invoke("sm_action_find_dict_list", type_name: str, state_value: int = 0) -> tuple

def sm_action_find_dict_list(type_name: str, state_value: int = 0) -> tuple:
"""查找状态机字典列表

    Args:
        type_name: 类型名称
        state_value: 状态值

    Returns:
        返回(True, [{状态机动作字典}, ...])或(False, {error_message})"""

invoke("sm_diagram_get_dict_list") -> tuple

def sm_diagram_get_dict_list() -> tuple:
"""得到流程字典列表

    Returns:
        返回(True, [{流程字典}, ...])或(False, {error_message})"""

invoke("sm_log_add", owner_type: str, owner_id: str, state_value: int, extra_state_bits_value: int, operate_comment: str = None, operator: str = None, operate_timestamp: str = None, note: str = None, context_dict: dict = None) -> tuple

def sm_log_add(owner_type: str, owner_id: str, state_value: int, extra_state_bits_value: int, operate_comment: str = None, operator: str = None, operate_timestamp: str = None, note: str = None, context_dict: dict = None) -> tuple:
"""添加日志

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        state_value: 状态值
        extra_state_bits_value: 附加状态值
        operate_comment: 日志注释
        operator: 操作人
        operate_timestamp: 操作时刻
        note: 备注
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("sm_log_add_by_dict", sm_log_dict: dict, context_dict: dict = None) -> tuple

def sm_log_add_by_dict(sm_log_dict: dict, context_dict: dict = None) -> tuple:
"""添加日志字典

    Args:
        sm_log_dict: 日志字典
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("sm_log_get_first", owner_type: str, owner_id: str) -> tuple

def sm_log_get_first(owner_type: str, owner_id: str) -> tuple:
"""得到第一个日志记录字典

    Args:
        owner_type: 物主类型
        owner_id: 物主id

    Returns:
        返回(True, {日志字典})或(False, {error_message})"""

invoke("sm_log_get_last", owner_type: str, owner_id: str) -> tuple

def sm_log_get_last(owner_type: str, owner_id: str) -> tuple:
"""得到最后一个日志记录字典

    Args:
        owner_type: 物主类型
        owner_id: 物主id

    Returns:
        返回(True, {日志字典})或(False, {error_message})"""

invoke("sm_log_get_log_detail_list", type_name: str, record_id: str) -> tuple

def sm_log_get_log_detail_list(type_name: str, record_id: str) -> tuple:
"""得到指定记录的工作流处理日志

    Args:
        type_name: 类型名称
        record_id: 记录id

    Returns:
        返回(True, [{处理日志}, ...])或(False, {error_message})"""

invoke("sm_log_get_next", owner_type: str, owner_id: str, operate_timestamp: str) -> tuple

def sm_log_get_next(owner_type: str, owner_id: str, operate_timestamp: str) -> tuple:
"""得到指定时刻的后一个日志

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        operate_timestamp: 日志时刻

    Returns:
        返回(True, ({后日志字典}))或(False, {error_message})"""

invoke("sm_log_get_prev", owner_type: str, owner_id: str, operate_timestamp: str) -> tuple

def sm_log_get_prev(owner_type: str, owner_id: str, operate_timestamp: str) -> tuple:
"""得到日志时刻前一个日志

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        operate_timestamp: 日志时刻

    Returns:
        返回(True, ({前日志字典}))或(False, {error_message})"""

invoke("sm_log_get_prev_list", owner_type: str, owner_id: str, operate_timestamp: str) -> tuple

def sm_log_get_prev_list(owner_type: str, owner_id: str, operate_timestamp: str) -> tuple:
"""得到指定时刻的前日志列表

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        operate_timestamp: 日志时刻

    Returns:
        返回(True, [{日志字典}, ...]))或(False, {error_message})"""

invoke("sm_log_get_proces_flow_prev_list", owner_type: str, owner_id: str, operate_timestamp: str, state_value: int) -> tuple

def sm_log_get_proces_flow_prev_list(owner_type: str, owner_id: str, operate_timestamp: str, state_value: int) -> tuple:
"""得到指定时刻前的处理流程日志列表(按照流程顺序, 不包含驳回处理日志)

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        operate_timestamp: 日志时刻
        state_value: 当前状态

    Returns:
        返回(True, [{日志字典}, ...]))或(False, {error_message})"""

invoke("sm_log_has", owner_type: str, owner_id: str) -> tuple

def sm_log_has(owner_type: str, owner_id: str) -> tuple:
"""是否有日志记录

    Args:
        owner_type: 物主类型
        owner_id: 物主id

    Returns:
        返回(True, {是否有记录})或(False, {error_message})"""

invoke("sm_log_has_next", owner_type: str, owner_id: str, operate_timestamp: str) -> tuple

def sm_log_has_next(owner_type: str, owner_id: str, operate_timestamp: str) -> tuple:
"""指定日志时刻前是否有后日志

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        operate_timestamp: 日志时刻

    Returns:
        返回(True, {是否有后日志})或(False, {error_message})"""

invoke("sm_log_has_prev", owner_type: str, owner_id: str, operate_timestamp: str) -> tuple

def sm_log_has_prev(owner_type: str, owner_id: str, operate_timestamp: str) -> tuple:
"""指定日志时刻前是否有前日志

    Args:
        owner_type: 物主类型
        owner_id: 物主id
        operate_timestamp: 日志时刻

    Returns:
        返回(True, {是否有前日志})或(False, {error_message})"""

invoke("sm_state_find_dict_list", type_name: str, state_value: int, extra_state_bits_value: int) -> tuple

def sm_state_find_dict_list(type_name: str, state_value: int, extra_state_bits_value: int) -> tuple:
"""得到指定类型的状态字典列表

    Args:
        type_name: 类型名称
        state_value: 当前状态值

    Returns:
        返回(True, [{状态字典}, ...])或(False, {error_message})"""

invoke("sm_state_get_closed_name") -> int

def sm_state_get_closed_name() -> int:
"""得到已闭合状态名

    Returns:
        返回已闭合状态名"""

invoke("sm_state_get_closed_value") -> int

def sm_state_get_closed_value() -> int:
"""得到已闭合状态值

    Returns:
        返回已闭合状态值"""

invoke("sm_state_get_completed_name", state_name: str) -> str

def sm_state_get_completed_name(state_name: str) -> str:
"""得到已完成状态名称

    Args:
        state_name: 原状态名称

    Returns:
        返回已完成状态名称"""

invoke("sm_state_get_dict_list", type_name: str) -> tuple

def sm_state_get_dict_list(type_name: str) -> tuple:
"""得到指定类型的状态字典列表

    Args:
        type_name: 类型名称

    Returns:
        返回(True, [{状态字典}, ...])或(False, {error_message})"""

invoke("sm_state_get_discard_name") -> str

def sm_state_get_discard_name() -> str:
"""得到废弃状态名

    Returns:
        返回废弃状态名"""

invoke("sm_state_get_discard_value") -> int

def sm_state_get_discard_value() -> int:
"""得到废弃状态值

    Returns:
        返回废弃状态值"""

invoke("sm_state_get_final_value", type_name: str) -> tuple

def sm_state_get_final_value(type_name: str) -> tuple:
"""得到指定类型的最终状态值

    Args:
        type_name: 类型名称

    Returns:
        返回(True, ({初始状态值}, {附加状态位}))或(False, {error_message})"""

invoke("sm_state_get_init_value", type_name: str) -> tuple

def sm_state_get_init_value(type_name: str) -> tuple:
"""得到指定类型的初始状态值

    Args:
        type_name: 类型名称

    Returns:
        返回(True, ({初始状态值}, {附加状态位}))或(False, {error_message})"""

invoke("sm_state_get_next", type_name: str, state_value: int) -> tuple

def sm_state_get_next(type_name: str, state_value: int) -> tuple:
"""得到指定类型的后状态

    Args:
        type_name: 类型名称
        state_value: 当前状态值

    Returns:
        返回(True, ({后状态字典}, {附加状态位}))或(False, {error_message})"""

invoke("sm_state_get_next_recommend_extra_bits_value", type_name: str) -> tuple

def sm_state_get_next_recommend_extra_bits_value(type_name: str) -> tuple:
"""查找指定类型的推荐附加状态位值

    Args:
        type_name: 类型名称

    Returns:
        返回(True, {指定类型的推荐附加状态位值})或(False, {error_message})"""

invoke("sm_state_get_next_recommend_name", type_name: str) -> str

def sm_state_get_next_recommend_name(type_name: str) -> str:
"""查找指定类型的推荐状态名称

    Args:
        type_name: 类型名称

    Returns:
        返回状态名称"""

invoke("sm_state_get_next_recommend_value", type_name: str) -> tuple

def sm_state_get_next_recommend_value(type_name: str) -> tuple:
"""查找指定类型的推荐状态值

    Args:
        type_name: 类型名称

    Returns:
        返回(True, {状态值})或(False, {error_message})"""

invoke("sm_state_get_next_value", type_name: str, state_value: int) -> tuple

def sm_state_get_next_value(type_name: str, state_value: int) -> tuple:
"""得到指定类型的后状态值

    Args:
        type_name: 类型名称
        state_value: 当前状态值

    Returns:
        返回(True, ({后状态值}, {附加状态位}))或(False, {error_message})"""

invoke("sm_state_get_pending_name", state_name: str) -> str

def sm_state_get_pending_name(state_name: str) -> str:
"""得到待处理状态名称

    Args:
        state_name: 原状态名称

    Returns:
        返回待处理状态名称"""

invoke("sm_state_get_prev", type_name: str, state_value: int, exclude_discard: bool = True) -> tuple

def sm_state_get_prev(type_name: str, state_value: int, exclude_discard: bool = True) -> tuple:
"""得到指定类型的前状态

    Args:
        type_name: 类型名称
        state_value: 当前状态值
        exclude_discard: 是否剔除废弃状态值

    Returns:
        返回(True, ({前状态字典}))或(False, {error_message})"""

invoke("sm_state_get_prev_value", type_name: str, state_value: int, exclude_discard: bool = True) -> tuple

def sm_state_get_prev_value(type_name: str, state_value: int, exclude_discard: bool = True) -> tuple:
"""得到指定类型的前状态值

    Args:
        type_name: 类型名称
        state_value: 当前状态值
        exclude_discard: 是否剔除废弃状态值

    Returns:
        返回(True, ({前状态值}, {附加状态位}))或(False, {error_message})"""

invoke("sm_state_get_process_flow_dict_list", type_name: str) -> tuple

def sm_state_get_process_flow_dict_list(type_name: str) -> tuple:
"""得到指定类型的处理流程字典列表(会签字典折叠)

    Args:
        type_name: 类型名称

    Returns:
        返回(True, [{状态字典}, ...])或(False, {error_message})"""

invoke("sm_state_get_reject_dict_list", type_name: str, state_value: int, extra_state_bits_value: int) -> tuple

def sm_state_get_reject_dict_list(type_name: str, state_value: int, extra_state_bits_value: int) -> tuple:
"""得到驳回状态字典列表

    Args:
        type_name: 类型名称
        state_value: 状态值
        extra_state_bits_value: 附加状态位值

    Returns:
        返回(True, [{状态字典}, ...])或(False, {error_message})"""

invoke("sm_state_get_reject_value", type_name: str, state_value: int, extra_state_bits_value: int) -> tuple

def sm_state_get_reject_value(type_name: str, state_value: int, extra_state_bits_value: int) -> tuple:
"""得到驳回后的状态值

    Args:
        type_name: 类型名称
        state_value: 状态值
        extra_state_bits_value: 附加状态位值

    Returns:
        返回(True, ({状态值}, {附加状态位值}))或(False, {error_message})"""

invoke("sm_state_get_task_name", state_name: str) -> str

def sm_state_get_task_name(state_name: str) -> str:
"""得到状态对应的任务名称

    Args:
        state_name: 状态名称

    Returns:
        返回状态对应的任务名称"""

invoke("sm_state_get_valid_dict_list", type_name: str) -> tuple

def sm_state_get_valid_dict_list(type_name: str) -> tuple:
"""得到指定类型的有效状态字典列表

    Args:
        type_name: 类型名称

    Returns:
        返回(True, [{状态字典}, ...])或(False, {error_message})"""

invoke("sm_state_has", type_name: str) -> tuple

def sm_state_has(type_name: str) -> tuple:
"""指定类型是否有状态元信息

    Args:
        type_name: 类型名称

    Returns:
        返回(True, {是否有状态元信息})或(False, {error_message})"""

invoke("sm_state_has_next", type_name: str, state_value: int) -> tuple

def sm_state_has_next(type_name: str, state_value: int) -> tuple:
"""指定类型的是否有后状态值

    Args:
        type_name: 类型名称
        state_value: 当前状态值

    Returns:
        返回(True, {是否有后状态值})或(False, {error_message})"""

invoke("sm_state_has_prev", type_name: str, state_value: int, exclude_discard: bool = True) -> tuple

def sm_state_has_prev(type_name: str, state_value: int, exclude_discard: bool = True) -> tuple:
"""指定类型的是否有前状态值

    Args:
        type_name: 类型名称
        state_value: 当前状态值
        exclude_discard: 是否剔除废弃状态值

    Returns:
        返回(True, {是否有前状态值})或(False, {error_message})"""

invoke("sm_state_is_closed_value", state_value: int) -> bool

def sm_state_is_closed_value(state_value: int) -> bool:
"""指定状态值是否为闭合状态值

    Args:
        state_value: 当前状态值

    Returns:
        返回是否为闭合状态值"""

invoke("sm_state_is_discard_value", state_value: int) -> bool

def sm_state_is_discard_value(state_value: int) -> bool:
"""指定状态值是否为废弃状态值

    Args:
        state_value: 当前状态值

    Returns:
        返回是否为废弃状态值"""

invoke("sm_state_is_final_value", type_name: str, state_value: int) -> tuple

def sm_state_is_final_value(type_name: str, state_value: int) -> tuple:
"""当前状态值是否为最终状态值

    Args:
        type_name: 类型名称
        state_value: 当前状态值

    Returns:
        返回(True, {是否为最终状态值})或(False, {error_message})"""

invoke("sm_state_is_init_value", type_name: str, state_value: int) -> tuple

def sm_state_is_init_value(type_name: str, state_value: int) -> tuple:
"""当前状态值是否为初始状态值

    Args:
        type_name: 类型名称
        state_value: 当前状态值

    Returns:
        返回(True, {是否为初始状态值})或(False, {error_message})"""

invoke("sm_state_is_rejectable", type_name: str, state_value: int, extra_state_bits_value: int) -> tuple

def sm_state_is_rejectable(type_name: str, state_value: int, extra_state_bits_value: int) -> tuple:
"""指定状态值是否可驳回

    Args:
        type_name: 类型名称
        state_value: 状态值
        extra_state_bits_value: 附加状态位值

    Returns:
        返回(True, {是否可驳回})或(False, {error_message})"""

invoke("sm_state_is_substate", extra_state_bits: int) -> bool

def sm_state_is_substate(extra_state_bits: int) -> bool:
"""是否为子状态（会签状态）

    Args:
        extra_state_bits: 附加状态位

    Returns:
        返回为子状态（会签状态）"""

invoke("sm_state_parent_from_substate", state_dict: dict) -> dict

def sm_state_parent_from_substate(state_dict: dict) -> dict:
"""状态字典转换为会签父字典

    Args:
        state_dict: 状态字典

    Returns:
        返回会签父状态字典"""

invoke("sm_state_process_flow_dict_visit", process_dict_list: list, visit_cb: ) -> object

def sm_state_process_flow_dict_visit(process_dict_list: list, visit_cb: ) -> object:
"""流程字典列表访问

    Args:
        process_dict_list: 流程字典列表
        visit_cb: 访问回调函数: def _visit_cb(process_flow_dict: dict) -> bool

    Returns:
        返回回调函数返回值或"""

invoke("sm_state_value_get_next_recommed", state_value: int, state_value_step: int = None) -> int

def sm_state_value_get_next_recommed(state_value: int, state_value_step: int = None) -> int:
"""得到下一个状态推荐值

    Args:
        state_value: 当前状态值
        state_value_step: 状态步进值

    Returns:
        返回下一个状态推荐值"""

invoke("sm_state_value_get_step_default") -> int

def sm_state_value_get_step_default() -> int:
"""得到状态缺省步进值

    Returns:
        返回状态缺省步进值"""

invoke("sm_substate_clear", extra_state_bits_value: int, extra_state_bits: int) -> int

def sm_substate_clear(extra_state_bits_value: int, extra_state_bits: int) -> int:
"""清除子状态位

    Args:
        extra_state_bits_value: 附加状态值
        extra_state_bits: 附加状态位

    Returns:
        返回清除胡子状态位的值"""

invoke("sm_substate_get_dict_list", type_name: str, state_value: int) -> tuple

def sm_substate_get_dict_list(type_name: str, state_value: int) -> tuple:
"""得到指定类型、指定状态的子状态字典列表

    Args:
        type_name: 类型名称
        state_value: 状态值

    Returns:
        返回(True, [{状态字典}, ...])或(False, {error_message})"""

invoke("sm_substate_get_extra_state_bits_list", type_name: str, state_value: int) -> tuple

def sm_substate_get_extra_state_bits_list(type_name: str, state_value: int) -> tuple:
"""得到指定类型、指定状态的附加状态位列表

    Args:
        type_name: 类型名称
        state_value: 状态值

    Returns:
        返回(True, [{附加状态位}, ...])或(False, {error_message})"""

invoke("sm_substate_get_next_task_name", type_name: str, state_value: int, extra_state_bits_value: int) -> tuple

def sm_substate_get_next_task_name(type_name: str, state_value: int, extra_state_bits_value: int) -> tuple:
"""得到下一个任务名称

    Args:
        type_name: 类型名称
        state_value: 状态值
        extra_state_bits_value: 附加状态位值

    Returns:
        返回(True, {任务名称})或(False, {error_message})"""

invoke("sm_substate_is_set", extra_state_bits_value: int, extra_state_bits: int) -> bool

def sm_substate_is_set(extra_state_bits_value: int, extra_state_bits: int) -> bool:
"""子状态值中是否设置子状态位

    Args:
        extra_state_bits_value: 附加状态值
        extra_state_bits: 附加状态位

    Returns:
        返回子状态值中是否设置子状态位"""

invoke("sm_substate_is_set_all", extra_state_bits_value: int, extra_state_bits_list: list) -> bool

def sm_substate_is_set_all(extra_state_bits_value: int, extra_state_bits_list: list) -> bool:
"""子状态值中是否设置全部子状态位

    Args:
        extra_state_bits_value: 附加状态值
        extra_state_bits_list: 附加状态位列表

    Returns:
        返回子状态值中是否设置全部子状态位"""

invoke("sm_substate_is_set_any", extra_state_bits_value: int, extra_state_bits_list: list) -> bool

def sm_substate_is_set_any(extra_state_bits_value: int, extra_state_bits_list: list) -> bool:
"""子状态值中是否设置任一子状态位

    Args:
        extra_state_bits_value: 附加状态值
        extra_state_bits_list: 附加状态位列表

    Returns:
        返回子状态值中是否设置任一子状态位"""

invoke("sm_substate_name_split", substate_name: str) -> list

def sm_substate_name_split(substate_name: str) -> list:
"""子状态名称拆分

    Args:
        substate_name: 子状态名称

    Returns:
        返回拆分列表"""

invoke("sm_substate_set", extra_state_bits_value: int, extra_state_bits: int) -> int

def sm_substate_set(extra_state_bits_value: int, extra_state_bits: int) -> int:
"""设置子状态位

    Args:
        extra_state_bits_value: 附加状态值
        extra_state_bits: 附加状态位

    Returns:
        返回设置子状态位的值"""

invoke("stake_from_string", stake: str) -> float

def stake_from_string(stake: str) -> float:
"""从桩号字符串得到桩号,K100+020 ==> 100020

    Args:
        stake: 桩号

    Returns:
        返回桩号值(浮点数)"""

invoke("stake_to_string", stake: int) -> str

def stake_to_string(stake: int) -> str:
"""桩号转换为字符串,100020 ==> K100+020

    Args:
        stake: 桩号

    Returns:
        返回字符串格式桩号"""

invoke("start_of_next_day")

def start_of_next_day():
"""明天开始

    Returns:
        返回明天开始"""

invoke("start_of_next_hour")

def start_of_next_hour():
"""下一小时开始

    Returns:
        返回当前时间的下一个小时"""

invoke("test_widgets")

def test_widgets():
"""测试部件"""

invoke("type_traits_get", *args, **kwargs)

def application_started_lru_cache.._memorize..__memorize(*args, **kwargs):
"""包装函数"""

invoke("type_traits_has", *args, **kwargs)

def application_started_lru_cache.._memorize..__memorize(*args, **kwargs):
"""包装函数"""

invoke("unregister_named_object", name: str) -> None

def unregister_named_object(name: str) -> None:
"""注销命名对象

    Args:
        name: 对象名称"""

invoke("user_account_to_name", user_account: str) -> str

def user_account_to_name(user_account: str) -> str:
"""用户帐户转用户名称

    Args:
        user_account: 用户帐户

    Returns:
        返回用户名称"""

invoke("verify_directory_exist", path: str) -> None

def verify_directory_exist(path: str) -> None:
"""确保目录存在.

    Args:
        path: 目标目录"""

invoke("visit_dispatchs", visitor) -> bool

def visit_dispatchs(visitor) -> bool:
"""访问派发者

    Args:
        visitor: 访问者 def visitor(url, function_instance, level) -> bool:

    Returns:
        返回中断与否"""

invoke("web_main") -> tuple

def web_main() -> tuple:
"""web服务器入口

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("wgs84_to_bd09", wgs84_longitude: float, wgs84_latitude: float) -> tuple

def wgs84_to_bd09(wgs84_longitude: float, wgs84_latitude: float) -> tuple:
"""WGS84经纬度转百度地图经纬度

    Args:
        wgs84_longitude: WGS84经度
        wgs84_latitude: WGS84纬度

    Returns:
        返回(True, (bd_longitude, bd_latitude))或(False, {error_message})"""

invoke("write_file", path_name: str, content: bytes) -> None

def write_file(path_name: str, content: bytes) -> None:
"""写入文件内容.

    Args:
        path_name: 目标文件.
        content: 文件内容"""

invoke("ws_connection_send", connection_handle: int, message: str) -> None

def ws_connection_send(connection_handle: int, message: str) -> None:
"""连接发送

    Args:
        connection_handle: 连接id
        message: 消息内容"""

invoke("ws_get_connection_name", connection_handle: int) -> str

def ws_get_connection_name(connection_handle: int) -> str:
"""得到连接名称

    Args:
        connection_handle: 连接id

    Returns:
        返回连接名称"""

invoke("ws_has_connection", connection_handle: int) -> bool

def ws_has_connection(connection_handle: int) -> bool:
"""是否有连接存在

    Args:
        connection_handle: 连接id

    Returns:
        返回连接是否存在"""

invoke("ws_plugin_final") -> None

def ws_plugin_final() -> None:
"""插件释放"""

invoke("ws_plugin_initialize") -> tuple

def ws_plugin_initialize() -> tuple:
"""插件初始化

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("ws_set_connection_name", connection_handle: int, name: str) -> None

def ws_set_connection_name(connection_handle: int, name: str) -> None:
"""设置连接名称

    Args:
        connection_handle: 连接id
        name: 连接名称"""

invoke("ws_visit_connection", handler) -> None

def ws_visit_connection(handler) -> None:
"""访问连接

    Args:
        handler: 访问回调函数: def visit_handler(connection_handle: int) -> None"""

invoke("xian80_grid_to_geodetic", central_meridian: float, northing: float, easting: float) -> tuple

def xian80_grid_to_geodetic(central_meridian: float, northing: float, easting: float) -> tuple:
"""西安80坐标系高斯反算

    args:
        central_meridian: 中央子午线(小数度)
        northing: 高斯投影平面北距(N, X)
        easting: 高斯投影平面东距(E, Y)

    Returns:
        返回小数度表示的({latitude：纬度}, {longitude: 经度})"""

invoke("/<type_name>/import_record_list_from_excel", type_name: str, excel_path_name: str, content_dict: dict) -> tuple

def _(type_name: str, excel_path_name: str, content_dict: dict) -> tuple:
"""从excel表格中导入记录表, 返回(success, error_message)

    Args:
            type_name: 类型名称
            excel_path_name: excel文件路径
            content_dict: 场景字典

    Returns:
            成功时返回(True, ''), 失败时返回(False, '')"""

invoke("/<type_name>/export_record_list", type_name: str, context_dict: dict) -> tuple

def _(type_name: str, context_dict: dict) -> tuple:
"""导出记录表

    Args:
            type_name: 类型名称
            context_dict: 场景字典

    Returns:
            成功时返回(True, html_content), 失败时返回(False, error_message)"""

invoke("/<type_name>/get_db_connection", type_name: str) -> object

def _(type_name: str) -> object:
"""得到类型对应的数据库连接

    Args:
        type_name: 类型名称

    Returns:
        返回数据库连接或None"""

invoke("/<type_name>/find_record_by_id", type_name: str, object_id: str, tag_name: str, context_dict: dict) -> tuple

def _(type_name: str, object_id: str, tag_name: str, context_dict: dict) -> tuple:
"""查找指定ID的记录

    Args:
        type_name: 类型
        object_id: 字段值(id)
        tag_name: 字段名
        context_dict: 场景字典

    Returns:
        返回(True, {record_dict})或(False, {error_message})"""

invoke("/<type_name>/add", type_name: str, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, record_dict: dict, context_dict: dict) -> tuple:
"""添加记录

    Args:
        type_name: 类型
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("/<type_name>/modify", type_name: str, filter_list: list, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, filter_list: list, record_dict: dict, context_dict: dict) -> tuple:
"""修改记录

    Args:
        type_name: 类型
        filter_list: 过滤条件列表
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, {record_dict})或(False, {error_message})"""

invoke("/<type_name>/remove", type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple

def _(type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple:
"""删除记录列表

    Args:
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("/<type_name>/add_begin", type_name: str, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, record_dict: dict, context_dict: dict) -> tuple:
"""添加记录开始事件

    Args:
        type_name: 类型名称
        record_dict; 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})或None"""

invoke("/<type_name>/do_add_record", type_name: str, record_dict: dict, db_connection: object, context_dict: dict) -> tuple

def _(type_name: str, record_dict: dict, db_connection: object, context_dict: dict) -> tuple:
"""执行添加记录

    Args:
        type_name: 类型名称
        record_dict: 记录字典
        db_connection: 数据库连接
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("/<type_name>/add_final", type_name: str, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, record_dict: dict, context_dict: dict) -> tuple:
"""添加记录完成事件

    Args:
        type_name: 类型名称
        record_dict; 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})或None"""

invoke("/<type_name>/modify_begin", type_name: str, filter_list: list, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, filter_list: list, record_dict: dict, context_dict: dict) -> tuple:
"""修改记录开始事件

    Args:
        type_name: 类型名称
        filter_list: 过滤条件列表
        record_dict; 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})或None"""

invoke("/<type_name>/do_modify_record", type_name: str, filter_list: list, record_dict: dict, db_connection: object, context_dict: dict) -> tuple

def _(type_name: str, filter_list: list, record_dict: dict, db_connection: object, context_dict: dict) -> tuple:
"""执行修改记录

    Args:
        type_name: 类型名称
        filter_list: 过滤列表
        record_dict: 记录字典
        db_connection: 数据库连接
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("/<type_name>/modify_final", type_name: str, filter_list: list, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, filter_list: list, record_dict: dict, context_dict: dict) -> tuple:
"""修改记录完成事件

    Args:
        type_name: 类型名称
        filter_list: 过滤条件列表
        record_dict; 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})或None"""

invoke("/<type_name>/remove_begin", type_name: str, field_id: str, field_value: str, context_dict: dict) -> tuple

def _(type_name: str, field_id: str, field_value: str, context_dict: dict) -> tuple:
"""删除记录开始事件

    Args:
        type_name: 类型名称
        field_id: 字段id
        field_value: 记录值
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})或None"""

invoke("/<type_name>/do_remove_record_list", type_traits_element: lxml.etree._Element, filter_list: list, db_connection: object, context_dict: dict) -> tuple

def _(type_traits_element: lxml.etree._Element, filter_list: list, db_connection: object, context_dict: dict) -> tuple:
"""执行记录列表删除

    Args:
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        db_connection: 数据库连接
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("/<type_name>/add_in_dialog/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到模板文件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/add_in_dialog/get_render_dict", type_name: str, action_type: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, context_dict: dict) -> dict:
"""得到添加对象的渲染字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/add_in_dialog/add_success/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到添加成功对话框页片

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面主题类"""

invoke("/<type_name>/add_in_dialog/add_success/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到添加成功对话框渲染字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/modify_in_dialog/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到模板文件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/modify_in_dialog/get_render_dict", type_name: str, action_type: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, context_dict: dict) -> dict:
"""得到修改对象的渲染字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/modify_in_dialog/modify_success/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到添加成功对话框页片

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面主题类"""

invoke("/<type_name>/modify_in_dialog/modify_success/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到修改成功对话框渲染字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/add_in_page/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到模板文件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/modify_in_dialog/get_page_primary_theme_class", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页面主题类

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面主题类"""

invoke("/<type_name>/add_in_dialog/get_page_primary_theme_class", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页面主题类

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面主题类"""

invoke("/<type_name>/add_in_page/get_page_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面标题"""

invoke("/<type_name>/add_in_page/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内容标题

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内容标题"""

invoke("/<type_name>/add_in_dialog/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内容标题

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内容标题"""

invoke("/<type_name>/add_in_page/get_fragment_name_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, fragment_name_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, fragment_name_list: list, context_dict: dict) -> None:
"""得到页片名称列表事件

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        fragment_name_list: 页片名称列表
        context_dict: 场景字典"""

invoke("/<type_name>/add_in_page/get_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联css文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联css文件列表"""

invoke("/<type_name>/add_in_page/get_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联脚本文件列表"""

invoke("/<type_name>/add_in_page/get_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联脚本文件列表"""

invoke("/<type_name>/modify_in_dialog/get_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到启动脚本函数名称列表

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回启动脚本函数名称列表"""

invoke("/<type_name>/add_in_page/get_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到启动脚本函数名称列表

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回启动脚本函数名称列表"""

invoke("/<type_name>/add_in_dialog/get_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到启动脚本函数名称列表

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回启动脚本函数名称列表"""

invoke("/<type_name>/add_in_page/fragment_card/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到面板页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回面板页片内容"""

invoke("/<type_name>/add_in_page/get_submit_click_url", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到提交脚本

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回提交脚本"""

invoke("/<type_name>/add_in_dialog/get_submit_click_url", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到提交脚本

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回提交脚本"""

invoke("/<type_name>/modify_in_dialog/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内容标题

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内容标题"""

invoke("/<type_name>/modify_in_dialog/get_submit_click_url", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到提交脚本

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回提交脚本"""

invoke("/<type_name>/search_record_list/get_render_dict", type_name: str, action_type: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, context_dict: dict) -> dict:
"""得到渲染字典

    通过重载本函数, 可提供特定类型、特定行为的渲染字典特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/show_list/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到渲染模板文件

    通过重载本函数, 可提供特定类型、特定行为的模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/search_record_list/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到显示列表模板文件原型(允许类型特化)

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/show_list/get_fragment_name_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片名称列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片名称列表"""

invoke("/<type_name>/show_list/get_page_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页面标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面标题"""

invoke("/<type_name>/show_list/get_page_primary_theme_class", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面面板主题类

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面面板主题类"""

invoke("/<type_name>/show_list/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面内容标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面内容标题"""

invoke("/<type_name>/show_list/get_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联css文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联css文件列表"""

invoke("/<type_name>/show_list/get_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联css文件列表

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联css文件列表"""

invoke("/<type_name>/show_list/get_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联脚本连接文件列表

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联脚本文件列表"""

invoke("/<type_name>/show_list/get_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联脚本文件列表"""

invoke("/<type_name>/show_list/get_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到启动脚本函数名称列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回启动脚本函数名称列表"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到过滤表页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回过滤表页片内容"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_style_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_style_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_style_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联css文件列表"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_style_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_script_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_script_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_script_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_script_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_startup_script_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/show_list/fragment_filters/get_fragment_startup_script_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到命令组页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回命令组页片内容"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_style_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_style_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_style_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联css文件列表"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_style_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_script_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_script_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_script_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_script_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_startup_script_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/show_list/fragment_actions/get_fragment_startup_script_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到记录表页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回记录表页片内容"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_style_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_style_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_style_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联css文件列表"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_style_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_script_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_script_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_script_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_script_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_startup_script_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/show_list/fragment_record_table/get_fragment_startup_script_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到分页页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回分页页片内容"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_style_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_style_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_style_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联css文件列表"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_style_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_script_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_script_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_script_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_script_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_startup_script_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/show_list/fragment_pagination/get_fragment_startup_script_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/sm_action/get_action_group_list", type_name: str, record_id: str, context_dict: dict) -> tuple

def _(type_name: str, record_id: str, context_dict: dict) -> tuple:
"""得到状态机命令组列表

    Args:
        type_name: 类型名称
        record_id: 记录id
        context_dict: 场景字典

    Returns:
        返回(True, {命令组列表})或(False, {error_message})"""

invoke("/<type_name>/sm_action/get_approval_action_list", type_name: str, record_id: str, context_dict: dict) -> tuple

def _(type_name: str, record_id: str, context_dict: dict) -> tuple:
"""得到状态机批准的命令列表

    Args:
        type_name: 类型名称
        record_id: 记录id
        context_dict: 场景字典

    Returns:
        返回(True, {命令字典列表})或(False, {error_message})"""

invoke("/<type_name>/sm_action/get_reject_action_list", type_name: str, record_id: str, context_dict: dict) -> tuple

def _(type_name: str, record_id: str, context_dict: dict) -> tuple:
"""得到状态机驳回的命令列表

    Args:
        type_name: 类型名称
        record_id: 记录id
        context_dict: 场景字典

    Returns:
        返回(True, {命令字典列表})或(False, {error_message})"""

invoke("/<type_name>/sm_action/get_reject_command_dict_list", type_name: str, record_id: str, context_dict: dict) -> tuple

def _(type_name: str, record_id: str, context_dict: dict) -> tuple:
"""得到驳回命令字典

    Args:
        type_name: 类型名称
        record_id: 记录id
        context_dict: 场景字典

    Returns:
        返回(True, [{命令字典}, ...])或(False, {error_message})"""

invoke("/<type_name>/sm_action/get_command_dict_from_sm_action", type_name: str, record_id: str, sm_action_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, record_id: str, sm_action_dict: dict, context_dict: dict) -> tuple:
"""根据状态机动作构建界面命令字典

    Args:
        type_name: 类型名称
        record_id: 记录id
        sm_action_dict: 状态机动作字典
        context_dict: 场景字典

    Returns:
        返回(True, {界面命令url})或(False, {error_message})"""

invoke("/<type_name>/sm_action/get_click_url_from_sm_action", type_name: str, record_id: str, sm_action_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, record_id: str, sm_action_dict: dict, context_dict: dict) -> tuple:
"""根据状态机动作构建界面命令url

    Args:
        type_name: 类型名称
        record_id: 记录id
        sm_action_dict: 状态机动作字典
        context_dict: 场景字典

    Returns:
        返回(True, {界面命令url})或(False, {error_message})"""

invoke("/<type_name>/sm_menu/get_module_id", type_name: str, sm_diagram_dict: dict) -> tuple

def _(type_name: str, sm_diagram_dict: dict) -> tuple:
"""得到状态机模块菜单id

    Args:
        type_name: 类型名称
        sm_diagram_dict: 状态机流程字典

    Returns:
        返回(True, {状态机模块菜单id})或(False, {error_message})"""

invoke("/<type_name>/sm_menu/get_module_name", type_name: str, sm_diagram_dict: dict) -> tuple

def _(type_name: str, sm_diagram_dict: dict) -> tuple:
"""得到状态机模块菜单名称

    Args:
        type_name: 类型名称
        sm_diagram_dict: 状态机流程字典

    Returns:
        返回(True, {状态机模块菜单名称})或(False, {error_message})"""

invoke("/<type_name>/sm_menu/get_module_icon_class", type_name: str, sm_diagram_dict: dict) -> tuple

def _(type_name: str, sm_diagram_dict: dict) -> tuple:
"""得到状态机模块菜单图标

    Args:
        type_name: 类型名称
        sm_diagram_dict: 状态机流程字典

    Returns:
        返回(True, {状态机模块菜单图标})或(False, {error_message})"""

invoke("/<type_name>/sm_menu/get_menu_item_dict_list", type_name: str, sm_diagram_dict: dict) -> tuple

def _(type_name: str, sm_diagram_dict: dict) -> tuple:
"""得到状态机菜单项字典列表

    Args:
        type_name: 类型名称
        sm_diagram_dict: 状态机流程字典

    Returns:
        返回(True, [{状态机菜单项字典}, ...])或(False, {error_message})"""

invoke("/<type_name>/get_process_flow_dict_list", type_name: str, record_id: str) -> tuple

def _(type_name: str, record_id: str) -> tuple:
"""得到处理流程字典列表

    Args:
        type_name: 类型名称

    Returns:
        返回(True, [{处理日志字典}, ...])或(False, {error_message})"""

invoke("/<type_name>/sm_is_support", type_name: str, action_type: str, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, context_dict: dict) -> tuple:
"""指定类型是否支持状态机

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回(True, {是否支持状态机})或(False, {error_message})"""

invoke("/<type_name>/search_record_list/type_traits_get", type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element

def _(type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element:
"""得到指定类型的特征xml节点

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回类型特征xml节点."""

invoke("/<type_name>/process_list/type_traits_get", type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element

def _(type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element:
"""得到指定类型的特征xml节点

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回类型特征xml节点."""

invoke("/<type_name>/show_list/type_traits_get", type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element

def _(type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element:
"""得到指定类型的特征xml节点

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回类型特征xml节点."""

invoke("/<type_name>/process_list/search_record_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, field_id_list: list, record_list: list, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, field_id_list: list, record_list: list, context_dict: dict) -> tuple:
"""搜索记录数量.

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        context_dict: 场景字典

    Returns:
        返回(True, '')或(False, {error_message})"""

invoke("/<type_name>/get_state_dict_list", type_name: str, context_dict: dict) -> tuple

def _(type_name: str, context_dict: dict) -> tuple:
"""得到状态字典列表

    Args:
        type_name: 类型名称
        context_dict: 场景字典

    Returns:
        返回(True, {状态字典列表})或(False, {error_message})"""

invoke("/<type_name>/get_process_flow_fragment", type_name: str, record_id: str) -> tuple

def _(type_name: str, record_id: str) -> tuple:
"""得到处理流程页片

    Args:
        type_name: 类型名称

    Returns:
        返回(True, {处理流程页片})或(False, {error_message})"""

invoke("/<type_name>/get_process_flow_template_file", type_name: str) -> str

def _(type_name: str) -> str:
"""得到处理流程页片模板文件

    Args:
        type_name: 类型名称

    Returns:
        返回处理流程页片模板文件"""

invoke("/<type_name>/get_process_flow_render_dict", type_name: str, record_id: str) -> tuple

def _(type_name: str, record_id: str) -> tuple:
"""得到处理流程渲染字典

    Args:
        type_name: 类型名称

    Returns:
        返回(True, {渲染字典})或(False, {error_message})"""

invoke("/<type_name>/process/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到渲染模板文件

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/process/get_page_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面标题"""

invoke("/<type_name>/process/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面内容标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面内容标题"""

invoke("/<type_name>/process/get_fragment_name_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片名称列表

    通过重载本函数, 提供指定类型、指定行为的页片特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片名称列表"""

invoke("/<type_name>/process/fragment_process_flow/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片内容

    通过重载本函数, 提供指定类型、指定行为的页片特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内容"""

invoke("/<type_name>/process/fragment_actions/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/<type_name>/process/fragment_actions/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/<type_name>/process/get_action_group_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到命令组列表([[{命令字典}, ...], ...])

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回命令组列表"""

invoke("/<type_name>/process/fragment_approval_comment/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/<type_name>/process/fragment_approval_comment/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/<type_name>/process/fragment_approval_logs/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/<type_name>/process/fragment_approval_logs/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/<type_name>/process/fragment_record_detail/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/<type_name>/process/fragment_record_detail/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/<type_name>/process/get_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联css文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联css文件列表"""

invoke("/<type_name>/process/get_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联脚本文件列表"""

invoke("/<type_name>/process/get_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联脚本文件列表"""

invoke("/<type_name>/process_list/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到渲染模板文件

    通过重载本函数, 可提供特定类型、特定行为的模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/process_list/get_page_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面标题"""

invoke("/<type_name>/process_list/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面内容标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面内容标题"""

invoke("/<type_name>/process_list/get_fragment_name_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片名称列表

    通过重载本函数, 提供指定类型、指定行为的页片特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片名称列表"""

invoke("/<type_name>/process_list/get_fragment_name_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, fragment_name_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, fragment_name_list: list, context_dict: dict) -> None:
"""得到页片名称列表事件

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        fragment_name_list: 页片名称列表
        context_dict: 场景字典"""

invoke("/<type_name>/process_list/get_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联css文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联css文件列表"""

invoke("/<type_name>/process_list/get_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联css文件列表

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联css文件列表"""

invoke("/<type_name>/process_list/get_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联脚本文件列表"""

invoke("/<type_name>/process_list/render_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染即将完成

    视图渲染即将完成时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/process_list/fragment_filters/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到过滤表页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回过滤表页片内容"""

invoke("/<type_name>/process_list/fragment_process_flow/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/<type_name>/process_list/fragment_process_flow/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/<type_name>/process_list/fragment_record_table/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到记录表页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回记录表页片内容"""

invoke("/<type_name>/process_list/fragment_pagination/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到分页页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典

    Returns:
        返回分页页片内容"""

invoke("/<type_name>/process_list/fragment_record_table/get_fragment_script_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/admin/<action_type>/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到渲染模板文件

    通过重载本函数, 可提供特定类型、特定行为的模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/admin/<action_type>/get_render_dict", type_name: str, action_type: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, context_dict: dict) -> dict:
"""得到渲染字典

    通过重载本函数, 可提供特定类型、特定行为的渲染字典特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/admin/<action_type>/type_traits_get", type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element

def _(type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element:
"""得到指定类型的特征xml节点

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回类型特征xml节点."""

invoke("/admin/<action_type>/get_page_primary_theme_class", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面面板主题类

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面面板主题类"""

invoke("/admin/<action_type>/get_fragment_name_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片名称列表

    通过重载本函数, 提供指定类型、指定行为的页片特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片名称列表"""

invoke("/admin/<action_type>/get_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联脚本文件列表"""

invoke("/admin/<action_type>/fragment_header/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/admin/<action_type>/fragment_header/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/admin/<action_type>/fragment_footer/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/admin/<action_type>/fragment_footer/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/admin/<action_type>/fragment_sidebar/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/admin/<action_type>/fragment_sidebar/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/admin/<action_type>/fragment_control_sidebar/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/admin/<action_type>/fragment_control_sidebar/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/admin/<action_type>/fragment_content/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/admin/<action_type>/fragment_content/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/admin/<action_type>/get_start_page_url") -> str

def _() -> str:
"""得到起始页面url

    Returns:
        返回起始页面url"""

invoke("/accessory/<action_type>/get_script_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, script_file_list: list, context_dict: dict) -> None:
"""内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/search_record_count", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple:
"""搜索记录数量.

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        context_dict: 场景字典

    Returns:
        返回(True, {record_count})或(False, {error_message})"""

invoke("/<type_name>/<action_type>/search_record_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, count_per_page: int, page_no: int, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, count_per_page: int, page_no: int, context_dict: dict) -> tuple:
"""搜索记录列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        count_per_page; 每页记录数量
        page_no: 页索引(0基)
        context_dict: 场景字典

    Returns:
        返回(True, {record_list})或(False, {error_message})"""

invoke("/<type_name>/<action_type>/get_res_authorize_sql", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple:
"""得到资源授权sql

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        context_dict: 场景字典

    Returns:
        返回({sql}, {value_list})或None"""

invoke("/<type_name>/<action_type>/get_extra_sql", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, filter_list: list, context_dict: dict) -> tuple:
"""得到附加约束sql

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        filter_list: 过滤表列表
        context_dict: 场景字典

    Returns:
        返回({sql}, {value_list})或None"""

invoke("/<type_name>/<action_type>/record_list_summary", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, field_id_list: list, record_list: list, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, field_id_list: list, record_list: list, context_dict: dict) -> tuple:
"""记录列表汇总

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        field_id_list: 字段id列表
        record_list; 记录列表
        context_dict: 场景字典

    Returns:
        返回(True, {summary_record})或None"""

invoke("/<type_name>/<action_type>/search_record_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, field_id_list: list, record_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, field_id_list: list, record_list: list, context_dict: dict) -> None:
"""搜索记录列表完成事件

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        field_id_list: 字段id列表
        record_list; 记录列表
        context_dict: 场景字典

    Returns:
        返回(True, {summary_record})或None"""

invoke("/<type_name>/<action_type>/get_context_dict", type_name: str, action_type: str) -> dict

def _(type_name: str, action_type: str) -> dict:
"""得到渲染场景字典

        视图渲染开始前调用, 场景字典贯穿页面的整个渲染过程，通过重载本函数, 可为整个渲染过程提供附加参数

    Args:
        type_name: 类型名称
        action_type: 行为名称

    Returns:
        返回渲染场景字典."""

invoke("/<type_name>/<action_type>/get_template_file", type_name: str, action_type: str, context_dict: dict) -> str

def _(type_name: str, action_type: str, context_dict: dict) -> str:
"""得到渲染模板文件

    通过重载本函数, 可提供特定类型、特定行为的模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/<action_type>/get_render_dict", type_name: str, action_type: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, context_dict: dict) -> dict:
"""得到渲染字典

    通过重载本函数, 可提供特定类型、特定行为的渲染字典特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/<action_type>/get_object_description", type_name: str, action_type: str, record_id: str, field_id_tag: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, record_id: str, field_id_tag: str, context_dict: dict) -> dict:
"""得到对象描述

    通过重载本函数, 可提供特定类型、特定行为的对象描述特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        record_id: 记录id值
        field_id_tag: 记录id名
        context_dict: 场景字典

    Returns:
        返回渲染字典"""

invoke("/<type_name>/<action_type>/get_basic_render_dict", type_name: str, action_type: str, context_dict: dict, force: bool = False) -> dict

def _(type_name: str, action_type: str, context_dict: dict, force: bool = False) -> dict:
"""得到基本属性渲染字典(渲染字典构建前调用)

    Args:
        type_name: 类型名称
        action_type: 动作类型
        context_dict: 场景字典
        result_render_dict: 结果渲染字典
        force: 是否强制渲染

    Returns:
        返回基本属性渲染字典"""

invoke("/<type_name>/<action_type>/type_traits_get", type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element

def _(type_name: str, action_type: str, context_dict: dict) -> lxml.etree._Element:
"""得到指定类型的特征xml节点

    Args:
        type_name: 类型名称
        action_type: 动作名称
        context_dict: 场景字典

    Returns:
        返回类型特征xml节点."""

invoke("/<type_name>/<action_type>/render_begin", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染开始

    视图渲染开始时调用, 通过重载本函数, 可初始化渲染结果字典和场景字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/render_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染即将完成

    视图渲染即将完成时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/get_fragment_name_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片名称列表

    通过重载本函数, 提供指定类型、指定行为的页片特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片名称列表"""

invoke("/<type_name>/<action_type>/get_fragment_name_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, fragment_name_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, fragment_name_list: list, context_dict: dict) -> None:
"""得到页片名称列表事件

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        fragment_name_list: 页片名称列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_page_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面标题"""

invoke("/<type_name>/<action_type>/get_page_primary_theme_class", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面面板主题类

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面面板主题类"""

invoke("/<type_name>/<action_type>/get_content_title", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页面内容标题

    通过重载本函数, 提供指定类型、指定行为的页面标题特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页面内容标题"""

invoke("/<type_name>/<action_type>/get_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联css文件列表

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联css文件列表"""

invoke("/<type_name>/<action_type>/get_style_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, style_link_file_list: list, context_dict: dict) -> None:
"""外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联css文件列表

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联css文件列表"""

invoke("/<type_name>/<action_type>/get_style_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, style_file_list: list, context_dict: dict) -> None:
"""内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到外联脚本连接文件列表

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回外联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_script_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, script_link_file_list: list, context_dict: dict) -> None:
"""外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回内联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_script_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, script_file_list: list, context_dict: dict) -> None:
"""内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到启动脚本函数名称列表

    通过重载本函数, 提供指定类型、指定行为的启动脚本函数特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回启动脚本函数名称列表"""

invoke("/<type_name>/<action_type>/get_startup_script_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, startup_script_list: list, context_dict: dict) -> None:
"""启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_actions_fragment", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到命令组视图页片

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典

    Returns:
        返回命令组视图页片"""

invoke("/<type_name>/<action_type>/get_actions_template_file", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到命令组模板文件原型(允许类型特化)

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/<action_type>/get_actions_render_dict", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到命令组渲染字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回命令组渲染字典."""

invoke("/<type_name>/<action_type>/actions_render_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染即将完成

    视图渲染开始时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/get_actions_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_actions_style_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_actions_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_actions_style_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_actions_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_actions_script_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_actions_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_actions_script_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_actions_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/<action_type>/get_actions_startup_script_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_action_group_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到命令组列表([[{命令字典}, ...], ...])

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回命令组列表"""

invoke("/<type_name>/<action_type>/get_query_string", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到查询字符串

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回查询字符串"""

invoke("/<type_name>/<action_type>/get_next_url", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到跳转url

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回跳转url"""

invoke("/<type_name>/<action_type>/get_action_name_group_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到命令名称分组列表([['cmd_add', ...], ...])

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回命令名称分组列表"""

invoke("/<type_name>/<action_type>/get_disable_action_name_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, action_name_list: list, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, action_name_list: list, context_dict: dict) -> list:
"""返回禁用的行为列表

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        action_name_list: 命令名列表
        context_dict: 场景字典

    Returns:
        返回禁用的命令名列表."""

invoke("/<type_name>/<action_type>/get_action_name_group_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, action_name_group_list: list, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, action_name_group_list: list, context_dict: dict) -> list:
"""得到命令名称分组列表完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        action_name_group_list: 命令名分组列表([['cmd_add', ...], ...])
        context_dict: 场景字典

    Returns:
        返回命令组列表"""

invoke("/<type_name>/<action_type>/is_action_authorized", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> tuple:
"""检查命令是否授权

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称(cmd_add, cmd_search, ...)
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回(True, {是否授权})或(False, {error_message})或None"""

invoke("/<type_name>/<action_type>/get_action_group_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_group_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_group_list: list, context_dict: dict) -> None:
"""命令组列表完成事件

    重载本函数可添加修改命令组和命令

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        result_group_list: 命令组结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_search/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到搜索命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回搜索命令字典"""

invoke("/<type_name>/<action_type>/cmd_search/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""搜索命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_add/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到添加命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回添加命令字典"""

invoke("/<type_name>/<action_type>/cmd_add/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""添加命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_remove/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到删除命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回删除命令字典"""

invoke("/<type_name>/<action_type>/cmd_remove/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""删除命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_template_download/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到模板下载命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回导入命令字典"""

invoke("/<type_name>/<action_type>/cmd_template_download/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""模板下载命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_import/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到导入命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回导入命令字典"""

invoke("/<type_name>/<action_type>/cmd_import/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""导入命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_export/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到导出命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回导出命令字典"""

invoke("/<type_name>/<action_type>/cmd_export/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""导出命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_select_all/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到全选命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回全选命令字典"""

invoke("/<type_name>/<action_type>/cmd_select_all/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""全选命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_select_reverse/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到反选命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回反选命令字典"""

invoke("/<type_name>/<action_type>/cmd_select_reverse/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""反选命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/cmd_select_reset/get_action_dict", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, context_dict: dict) -> dict:
"""得到复位命令字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        context_dict: 场景字典

    Returns:
        返回复位命令字典"""

invoke("/<type_name>/<action_type>/cmd_select_reset/get_action_dict_final", type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None

def _(type_name: str, action_type: str, action_name: str, type_traits_element: lxml.etree._Element, query_string: str, next_url: str, result_action_dict: dict, context_dict: dict) -> None:
"""复位命令字典完成事件

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        type_traits_element: 类型特征xml节点
        query_string: 查询字符串
        next_url: 下一个url
        result_action_dict: 命令字典
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_filters_fragment", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到过滤表视图页片

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典

    Returns:
        返回过滤表视图页片"""

invoke("/<type_name>/<action_type>/get_filters_template_file", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到过滤表模板文件原型(允许类型特化)

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/<action_type>/get_filters_render_dict", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到过滤表渲染字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回过滤表渲染字典."""

invoke("/<type_name>/<action_type>/filters_render_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染即将完成

    视图渲染开始时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/get_filters_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_filters_style_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_filters_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_filters_style_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_filters_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_filters_script_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_filters_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_filters_script_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_filters_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/<action_type>/get_filters_startup_script_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/filter_field_render_final", type_name: str, action_type: str, field_traits_element: lxml.etree._Element, compare_type: str, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, field_traits_element: lxml.etree._Element, compare_type: str, context_dict: dict, result_render_dict: dict) -> None:
"""过滤表字段渲染即将完成事件

    通过重载本函数, 提供指定类型、指定行为的过滤表特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        field_traits_element: 字段特征xml节点
        compare_type: 搜索比较类型
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/get_pagination_fragment", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到分页页片内容

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回分页页片内容"""

invoke("/<type_name>/<action_type>/get_pagination_template_file", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到分页模板文件原型(允许类型特化)

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/<action_type>/get_pagination_render_dict", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到分页渲染字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回分页渲染字典."""

invoke("/<type_name>/<action_type>/pagination_render_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染即将完成

    视图渲染开始时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/get_pagination_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_pagination_style_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_pagination_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_pagination_style_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_pagination_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_pagination_script_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_pagination_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_pagination_script_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_pagination_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/<action_type>/get_pagination_startup_script_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_record_table_fragment", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到记录表视图页片

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典

    Returns:
        返回记录表视图页片"""

invoke("/<type_name>/<action_type>/get_record_table_template_file", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到记录表模板文件原型(允许类型特化)

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回模板文件."""

invoke("/<type_name>/<action_type>/get_record_table_render_dict", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到记录表渲染字典

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回记录表渲染字典."""

invoke("/<type_name>/<action_type>/record_table_render_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""渲染即将完成

    视图渲染开始时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/get_record_table_style_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_record_table_style_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_record_table_style_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/get_record_table_style_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_record_table_script_link_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_record_table_script_link_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_record_table_script_file_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/<action_type>/get_record_table_script_file_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_record_table_startup_script_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/<action_type>/get_record_table_startup_script_list_final", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/get_record_table_output_field_id_list", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到记录表输出字段id列表

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回记录表输出字段id列表"""

invoke("/<type_name>/<action_type>/is_record_table_field_output", type_name: str, action_type: str, field_traits_element: lxml.etree._Element, context_dict: dict) -> bool

def _(type_name: str, action_type: str, field_traits_element: lxml.etree._Element, context_dict: dict) -> bool:
"""记录表字段是否输出

    Args:
        type_name: 类型名称
        action_type: 行为名称
        field_traits_element: 字段特征xml节点
        context_dict: 场景字典

    Returns:
        返回记录表字段是否输出"""

invoke("/<type_name>/<action_type>/is_record_table_field_visible", type_name: str, action_type: str, field_traits_element: lxml.etree._Element, context_dict: dict) -> bool

def _(type_name: str, action_type: str, field_traits_element: lxml.etree._Element, context_dict: dict) -> bool:
"""记录表字段是否可见

    Args:
        type_name: 类型名称
        action_type: 行为名称
        field_traits_element: 字段特征xml节点
        context_dict: 场景字典

    Returns:
        返回记录表字段是否可见"""

invoke("/<type_name>/<action_type>/whether_show_record_number", type_name: str, action_type: str, field_traits_element: lxml.etree._Element, context_dict: dict) -> bool

def _(type_name: str, action_type: str, field_traits_element: lxml.etree._Element, context_dict: dict) -> bool:
"""是否显示记录表行号

    Args:
        type_name: 类型名称
        action_type: 行为名称
        field_traits_element: 字段特征xml节点
        context_dict: 场景字典

    Returns:
        返回是否显示记录表行号"""

invoke("/<type_name>/<action_type>/render_record_row", type_name: str, action_type: str, type_traits_element: lxml.etree._Element, record_dict: dict, context_dict: dict) -> str

def _(type_name: str, action_type: str, type_traits_element: lxml.etree._Element, record_dict: dict, context_dict: dict) -> str:
"""渲染记录行

    Args:
        type_name: 类型名称
        action_type: 动作名称
        type_traits_element: 类型特征xml节点
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回记录行"""

invoke("/<type_name>/<action_type>/render_record_actions", type_name: str, action_type: str, actions_template: str, record_dict: dict, context_dict: dict) -> str

def _(type_name: str, action_type: str, actions_template: str, record_dict: dict, context_dict: dict) -> str:
"""渲染记录动作

    Args:
        type_name: 类型名称
        action_type: 动作名称
        actions_template: 动作模板
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回记录动作"""

invoke("/<type_name>/<action_type>/is_record_action_template_authorized", type_name: str, action_type: str, actions_template: str, type_traits_element: lxml.etree._Element, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, actions_template: str, type_traits_element: lxml.etree._Element, record_dict: dict, context_dict: dict) -> tuple:
"""渲染记录动作

    Args:
        type_name: 类型名称
        action_type: 动作名称
        actions_template: 动作模板
        type_traits_element: 类型特征xml节点
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回(True, {授权后的模板内容})或(False, {error_message})或None"""

invoke("/<type_name>/<action_type>/render_record_table_cell", type_name: str, action_type: str, field_dict: dict, record_dict: dict, context_dict: dict) -> str

def _(type_name: str, action_type: str, field_dict: dict, record_dict: dict, context_dict: dict) -> str:
"""渲染记录单元格

    Args:
        type_name: 类型名称
        action_type: 动作名称
        field_dict: 字段字典
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回记录单元格"""

invoke("/<type_name>/<action_type>/get_record_table_cell_value", type_name: str, action_type: str, field_dict: dict, record_dict: dict, context_dict: dict) -> tuple

def _(type_name: str, action_type: str, field_dict: dict, record_dict: dict, context_dict: dict) -> tuple:
"""得到记录单元格值

    Args:
        type_name: 类型名称
        action_type: 动作名称
        field_dict: 字段字典
        record_dict: 记录字典
        context_dict: 场景字典

    Returns:
        返回(ui_value, db_value)"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片内容

    通过重载本函数, 提供指定类型、指定行为的页片特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内容"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_template_file", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> str:
"""得到页片模板文件

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片模板文件"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_render_dict", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> dict:
"""得到页片渲染字典

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片渲染字典"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_style_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联css文件列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联css文件列表"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_style_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_link_file_list: list, context_dict: dict) -> None:
"""页片外联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_style_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联css文件列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联css文件列表"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_style_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_style_file_list: list, context_dict: dict) -> None:
"""页片内联css文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联css文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_style_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_script_link_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片外联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件列表特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片外联脚本文件列表"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_script_link_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_link_file_list: list, context_dict: dict) -> None:
"""页片外联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的外联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_link_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_script_file_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片内联脚本文件列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片内联脚本文件列表"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_script_file_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_script_file_list: list, context_dict: dict) -> None:
"""页片内联脚本文件列表完成事件

    通过重载本函数, 提供指定类型、指定行为的内联脚本文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_script_file_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_startup_script_list", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict) -> list:
"""得到页片启动脚本函数列表

    通过重载本函数, 提供指定类型、指定行为的页片模板文件特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        context_dict: 场景字典

    Returns:
        返回页片启动脚本函数列表"""

invoke("/<type_name>/<action_type>/<fragment_name>/get_fragment_startup_script_list_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, result_startup_script_list: list, context_dict: dict) -> None:
"""页片启动脚本列表完成事件

    通过重载本函数, 提供指定类型、指定行为的启动脚本特化

    Args:
        type_name: 类型名称
        action_type: 行为名称
        fragment_name: 页面名称
        type_traits_element: 类型特征xml节点
        result_startup_script_list: 结果列表
        context_dict: 场景字典"""

invoke("/<type_name>/<action_type>/<fragment_name>/fragment_render_final", type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None

def _(type_name: str, action_type: str, fragment_name: str, type_traits_element: lxml.etree._Element, context_dict: dict, result_render_dict: dict) -> None:
"""页片渲染即将完成事件

    页片视图渲染即将完成时调用, 通过重载本函数, 可调整渲染结果字典

    Args:
        type_name: 类型名称
        action_type: 行为名称
        type_traits_element: 类型特征节点
        context_dict: 场景字典
        result_render_dict: 结果渲染字典"""

invoke("/<type_name>/<action_type>/<action_name>/get_ui_extra_class", type_name: str, action_type: str, action_name: str, action_dict: dict, context_dict: dict) -> str

def _(type_name: str, action_type: str, action_name: str, action_dict: dict, context_dict: dict) -> str:
"""命令界面附加类

    重载本函数可添加命令的界面附加类属性

    Args:
        type_name: 类型名称
        action_type: 动作名称
        action_name: 命令名称
        action_dict: 命令字典
        context_dict: 场景字典

    Returns:
        返回命令界面附加类"""