package com.mortals.xhx.base.system.menu.model;

import java.util.List;

/**
 * 菜单信息业务查询对象
 *
 * @author zxfei
 * @date 2024-12-06
 */
public class MenuQuery extends MenuEntity {
    /** 开始 菜单ID，主键，自增长 */
    private Long idStart;

    /** 结束 菜单ID，主键，自增长 */
    private Long idEnd;

    /** 增加 菜单ID，主键，自增长 */
    private Long idIncrement;

    /** 菜单ID，主键，自增长列表 */
    private List <Long> idList;

    /** 菜单ID，主键，自增长排除列表 */
    private List <Long> idNotList;

    /** 菜单名称 */
    private List<String> nameList;

    /** 菜单名称排除列表 */
    private List <String> nameNotList;
    /** 路由地址 */
    private List<String> urlList;

    /** 路由地址排除列表 */
    private List <String> urlNotList;
    /** 当前节点父id路径，“，”分割 */
    private List<String> ancestorsList;

    /** 当前节点父id路径，“，”分割排除列表 */
    private List <String> ancestorsNotList;
    /** 开始 父菜单ID，一级菜单的该字段值为-1 */
    private Long parentIdStart;

    /** 结束 父菜单ID，一级菜单的该字段值为-1 */
    private Long parentIdEnd;

    /** 增加 父菜单ID，一级菜单的该字段值为-1 */
    private Long parentIdIncrement;

    /** 父菜单ID，一级菜单的该字段值为-1列表 */
    private List <Long> parentIdList;

    /** 父菜单ID，一级菜单的该字段值为-1排除列表 */
    private List <Long> parentIdNotList;

    /** 开始 链接方式 (0.普通，1.弹出，2.脚本) */
    private Integer linkTypeStart;

    /** 结束 链接方式 (0.普通，1.弹出，2.脚本) */
    private Integer linkTypeEnd;

    /** 增加 链接方式 (0.普通，1.弹出，2.脚本) */
    private Integer linkTypeIncrement;

    /** 链接方式 (0.普通，1.弹出，2.脚本)列表 */
    private List <Integer> linkTypeList;

    /** 链接方式 (0.普通，1.弹出，2.脚本)排除列表 */
    private List <Integer> linkTypeNotList;

    /** 主菜单图标，主菜单图标的css样式名 */
    private List<String> imgPathList;

    /** 主菜单图标，主菜单图标的css样式名排除列表 */
    private List <String> imgPathNotList;
    /** 按钮图标，按钮图标的css样式名 */
    private List<String> buttonImgPathList;

    /** 按钮图标，按钮图标的css样式名排除列表 */
    private List <String> buttonImgPathNotList;
    /** 常用菜单图标，常用菜单图标的css样式名 */
    private List<String> imgCommPathList;

    /** 常用菜单图标，常用菜单图标的css样式名排除列表 */
    private List <String> imgCommPathNotList;
    /** 开始 是否常用菜单 (0.非常用，1.常用) */
    private Integer commMenuStart;

    /** 结束 是否常用菜单 (0.非常用，1.常用) */
    private Integer commMenuEnd;

    /** 增加 是否常用菜单 (0.非常用，1.常用) */
    private Integer commMenuIncrement;

    /** 是否常用菜单 (0.非常用，1.常用)列表 */
    private List <Integer> commMenuList;

    /** 是否常用菜单 (0.非常用，1.常用)排除列表 */
    private List <Integer> commMenuNotList;

    /** vue组件路径 */
    private List<String> componentList;

    /** vue组件路径排除列表 */
    private List <String> componentNotList;
    /** 开始 菜单类型 (0.目录，1.菜单，2.按钮) */
    private Integer menuTypeStart;

    /** 结束 菜单类型 (0.目录，1.菜单，2.按钮) */
    private Integer menuTypeEnd;

    /** 增加 菜单类型 (0.目录，1.菜单，2.按钮) */
    private Integer menuTypeIncrement;

    /** 菜单类型 (0.目录，1.菜单，2.按钮)列表 */
    private List <Integer> menuTypeList;

    /** 菜单类型 (0.目录，1.菜单，2.按钮)排除列表 */
    private List <Integer> menuTypeNotList;

    /** 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
    private Integer authTypeStart;

    /** 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
    private Integer authTypeEnd;

    /** 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
    private Integer authTypeIncrement;

    /** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)列表 */
    private List <Integer> authTypeList;

    /** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)排除列表 */
    private List <Integer> authTypeNotList;

    /** 开始 菜单显示状态 (0.显示，1.隐藏) */
    private Integer visibleStart;

    /** 结束 菜单显示状态 (0.显示，1.隐藏) */
    private Integer visibleEnd;

    /** 增加 菜单显示状态 (0.显示，1.隐藏) */
    private Integer visibleIncrement;

    /** 菜单显示状态 (0.显示，1.隐藏)列表 */
    private List <Integer> visibleList;

    /** 菜单显示状态 (0.显示，1.隐藏)排除列表 */
    private List <Integer> visibleNotList;

    /** 权限标识，多个逗号分割 */
    private List<String> permsList;

    /** 权限标识，多个逗号分割排除列表 */
    private List <String> permsNotList;
    /** 备注信息 */
    private List<String> remarkList;

    /** 备注信息排除列表 */
    private List <String> remarkNotList;
    /** 开始 排序编号 */
    private Integer orderIdStart;

    /** 结束 排序编号 */
    private Integer orderIdEnd;

    /** 增加 排序编号 */
    private Integer orderIdIncrement;

    /** 排序编号列表 */
    private List <Integer> orderIdList;

    /** 排序编号排除列表 */
    private List <Integer> orderIdNotList;

    /** 开始 菜单状态 (0.停用，1.启用) */
    private Integer statusStart;

    /** 结束 菜单状态 (0.停用，1.启用) */
    private Integer statusEnd;

    /** 增加 菜单状态 (0.停用，1.启用) */
    private Integer statusIncrement;

    /** 菜单状态 (0.停用，1.启用)列表 */
    private List <Integer> statusList;

    /** 菜单状态 (0.停用，1.启用)排除列表 */
    private List <Integer> statusNotList;

    /** 开始 创建时间 */
    private String createTimeStart;

    /** 结束 创建时间 */
    private String createTimeEnd;

    /** 开始 创建用户 */
    private Long createUserIdStart;

    /** 结束 创建用户 */
    private Long createUserIdEnd;

    /** 增加 创建用户 */
    private Long createUserIdIncrement;

    /** 创建用户列表 */
    private List <Long> createUserIdList;

    /** 创建用户排除列表 */
    private List <Long> createUserIdNotList;

    /** 创建用户名称 */
    private List<String> createUserNameList;

    /** 创建用户名称排除列表 */
    private List <String> createUserNameNotList;
    /** 开始 更新用户 */
    private Long updateUserIdStart;

    /** 结束 更新用户 */
    private Long updateUserIdEnd;

    /** 增加 更新用户 */
    private Long updateUserIdIncrement;

    /** 更新用户列表 */
    private List <Long> updateUserIdList;

    /** 更新用户排除列表 */
    private List <Long> updateUserIdNotList;

    /** 创建用户名称 */
    private List<String> updateUserNameList;

    /** 创建用户名称排除列表 */
    private List <String> updateUserNameNotList;
    /** 开始 更新时间 */
    private String updateTimeStart;

    /** 结束 更新时间 */
    private String updateTimeEnd;

    /** 开始 是否启用缓存 (0.否，1.是) */
    private Integer cacheStart;

    /** 结束 是否启用缓存 (0.否，1.是) */
    private Integer cacheEnd;

    /** 增加 是否启用缓存 (0.否，1.是) */
    private Integer cacheIncrement;

    /** 是否启用缓存 (0.否，1.是)列表 */
    private List <Integer> cacheList;

    /** 是否启用缓存 (0.否，1.是)排除列表 */
    private List <Integer> cacheNotList;

    /** 激活目录 */
    private List<String> activeDirList;

    /** 激活目录排除列表 */
    private List <String> activeDirNotList;
    /** 开始 是否隐藏(0.否，1.是) */
    private Integer hideChildrenInMenuStart;

    /** 结束 是否隐藏(0.否，1.是) */
    private Integer hideChildrenInMenuEnd;

    /** 增加 是否隐藏(0.否，1.是) */
    private Integer hideChildrenInMenuIncrement;

    /** 是否隐藏(0.否，1.是)列表 */
    private List <Integer> hideChildrenInMenuList;

    /** 是否隐藏(0.否，1.是)排除列表 */
    private List <Integer> hideChildrenInMenuNotList;

    /** 资源访问路径，多个逗号分割 */
    private List<String> resourceUrlList;

    /** 资源访问路径，多个逗号分割排除列表 */
    private List <String> resourceUrlNotList;
    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
    private List<MenuQuery> orConditionList;

    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
    private List<MenuQuery> andConditionList;

    public MenuQuery(){}

    /**
     * 获取 开始 菜单ID，主键，自增长
     * @return idStart
     */
    public Long getIdStart(){
        return this.idStart;
    }

    /**
     * 设置 开始 菜单ID，主键，自增长
     * @param idStart
     */
    public void setIdStart(Long idStart){
        this.idStart = idStart;
    }

    /**
     * 获取 结束 菜单ID，主键，自增长
     * @return $idEnd
     */
    public Long getIdEnd(){
        return this.idEnd;
    }

    /**
     * 设置 结束 菜单ID，主键，自增长
     * @param idEnd
     */
    public void setIdEnd(Long idEnd){
        this.idEnd = idEnd;
    }

    /**
     * 获取 增加 菜单ID，主键，自增长
     * @return idIncrement
     */
    public Long getIdIncrement(){
        return this.idIncrement;
    }

    /**
     * 设置 增加 菜单ID，主键，自增长
     * @param idIncrement
     */
    public void setIdIncrement(Long idIncrement){
        this.idIncrement = idIncrement;
    }

    /**
     * 获取 菜单ID，主键，自增长
     * @return idList
     */
    public List<Long> getIdList(){
        return this.idList;
    }

    /**
     * 设置 菜单ID，主键，自增长
     * @param idList
     */
    public void setIdList(List<Long> idList){
        this.idList = idList;
    }

    /**
     * 获取 菜单ID，主键，自增长
     * @return idNotList
     */
    public List<Long> getIdNotList(){
        return this.idNotList;
    }

    /**
     * 设置 菜单ID，主键，自增长
     * @param idNotList
     */
    public void setIdNotList(List<Long> idNotList){
        this.idNotList = idNotList;
    }


    /**
     * 获取 菜单名称
     * @return nameList
     */
    public List<String> getNameList(){
        return this.nameList;
    }

    /**
     * 设置 菜单名称
     * @param nameList
     */
    public void setNameList(List<String> nameList){
        this.nameList = nameList;
    }

    /**
     * 获取 菜单名称
     * @return nameNotList
     */
    public List<String> getNameNotList(){
        return this.nameNotList;
    }

    /**
     * 设置 菜单名称
     * @param nameNotList
     */
    public void setNameNotList(List<String> nameNotList){
        this.nameNotList = nameNotList;
    }

    /**
     * 获取 路由地址
     * @return urlList
     */
    public List<String> getUrlList(){
        return this.urlList;
    }

    /**
     * 设置 路由地址
     * @param urlList
     */
    public void setUrlList(List<String> urlList){
        this.urlList = urlList;
    }

    /**
     * 获取 路由地址
     * @return urlNotList
     */
    public List<String> getUrlNotList(){
        return this.urlNotList;
    }

    /**
     * 设置 路由地址
     * @param urlNotList
     */
    public void setUrlNotList(List<String> urlNotList){
        this.urlNotList = urlNotList;
    }

    /**
     * 获取 当前节点父id路径，“，”分割
     * @return ancestorsList
     */
    public List<String> getAncestorsList(){
        return this.ancestorsList;
    }

    /**
     * 设置 当前节点父id路径，“，”分割
     * @param ancestorsList
     */
    public void setAncestorsList(List<String> ancestorsList){
        this.ancestorsList = ancestorsList;
    }

    /**
     * 获取 当前节点父id路径，“，”分割
     * @return ancestorsNotList
     */
    public List<String> getAncestorsNotList(){
        return this.ancestorsNotList;
    }

    /**
     * 设置 当前节点父id路径，“，”分割
     * @param ancestorsNotList
     */
    public void setAncestorsNotList(List<String> ancestorsNotList){
        this.ancestorsNotList = ancestorsNotList;
    }

    /**
     * 获取 开始 父菜单ID，一级菜单的该字段值为-1
     * @return parentIdStart
     */
    public Long getParentIdStart(){
        return this.parentIdStart;
    }

    /**
     * 设置 开始 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdStart
     */
    public void setParentIdStart(Long parentIdStart){
        this.parentIdStart = parentIdStart;
    }

    /**
     * 获取 结束 父菜单ID，一级菜单的该字段值为-1
     * @return $parentIdEnd
     */
    public Long getParentIdEnd(){
        return this.parentIdEnd;
    }

    /**
     * 设置 结束 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdEnd
     */
    public void setParentIdEnd(Long parentIdEnd){
        this.parentIdEnd = parentIdEnd;
    }

    /**
     * 获取 增加 父菜单ID，一级菜单的该字段值为-1
     * @return parentIdIncrement
     */
    public Long getParentIdIncrement(){
        return this.parentIdIncrement;
    }

    /**
     * 设置 增加 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdIncrement
     */
    public void setParentIdIncrement(Long parentIdIncrement){
        this.parentIdIncrement = parentIdIncrement;
    }

    /**
     * 获取 父菜单ID，一级菜单的该字段值为-1
     * @return parentIdList
     */
    public List<Long> getParentIdList(){
        return this.parentIdList;
    }

    /**
     * 设置 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdList
     */
    public void setParentIdList(List<Long> parentIdList){
        this.parentIdList = parentIdList;
    }

    /**
     * 获取 父菜单ID，一级菜单的该字段值为-1
     * @return parentIdNotList
     */
    public List<Long> getParentIdNotList(){
        return this.parentIdNotList;
    }

    /**
     * 设置 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdNotList
     */
    public void setParentIdNotList(List<Long> parentIdNotList){
        this.parentIdNotList = parentIdNotList;
    }


    /**
     * 获取 开始 链接方式 (0.普通，1.弹出，2.脚本)
     * @return linkTypeStart
     */
    public Integer getLinkTypeStart(){
        return this.linkTypeStart;
    }

    /**
     * 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeStart
     */
    public void setLinkTypeStart(Integer linkTypeStart){
        this.linkTypeStart = linkTypeStart;
    }

    /**
     * 获取 结束 链接方式 (0.普通，1.弹出，2.脚本)
     * @return $linkTypeEnd
     */
    public Integer getLinkTypeEnd(){
        return this.linkTypeEnd;
    }

    /**
     * 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeEnd
     */
    public void setLinkTypeEnd(Integer linkTypeEnd){
        this.linkTypeEnd = linkTypeEnd;
    }

    /**
     * 获取 增加 链接方式 (0.普通，1.弹出，2.脚本)
     * @return linkTypeIncrement
     */
    public Integer getLinkTypeIncrement(){
        return this.linkTypeIncrement;
    }

    /**
     * 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeIncrement
     */
    public void setLinkTypeIncrement(Integer linkTypeIncrement){
        this.linkTypeIncrement = linkTypeIncrement;
    }

    /**
     * 获取 链接方式 (0.普通，1.弹出，2.脚本)
     * @return linkTypeList
     */
    public List<Integer> getLinkTypeList(){
        return this.linkTypeList;
    }

    /**
     * 设置 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeList
     */
    public void setLinkTypeList(List<Integer> linkTypeList){
        this.linkTypeList = linkTypeList;
    }

    /**
     * 获取 链接方式 (0.普通，1.弹出，2.脚本)
     * @return linkTypeNotList
     */
    public List<Integer> getLinkTypeNotList(){
        return this.linkTypeNotList;
    }

    /**
     * 设置 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeNotList
     */
    public void setLinkTypeNotList(List<Integer> linkTypeNotList){
        this.linkTypeNotList = linkTypeNotList;
    }


    /**
     * 获取 主菜单图标，主菜单图标的css样式名
     * @return imgPathList
     */
    public List<String> getImgPathList(){
        return this.imgPathList;
    }

    /**
     * 设置 主菜单图标，主菜单图标的css样式名
     * @param imgPathList
     */
    public void setImgPathList(List<String> imgPathList){
        this.imgPathList = imgPathList;
    }

    /**
     * 获取 主菜单图标，主菜单图标的css样式名
     * @return imgPathNotList
     */
    public List<String> getImgPathNotList(){
        return this.imgPathNotList;
    }

    /**
     * 设置 主菜单图标，主菜单图标的css样式名
     * @param imgPathNotList
     */
    public void setImgPathNotList(List<String> imgPathNotList){
        this.imgPathNotList = imgPathNotList;
    }

    /**
     * 获取 按钮图标，按钮图标的css样式名
     * @return buttonImgPathList
     */
    public List<String> getButtonImgPathList(){
        return this.buttonImgPathList;
    }

    /**
     * 设置 按钮图标，按钮图标的css样式名
     * @param buttonImgPathList
     */
    public void setButtonImgPathList(List<String> buttonImgPathList){
        this.buttonImgPathList = buttonImgPathList;
    }

    /**
     * 获取 按钮图标，按钮图标的css样式名
     * @return buttonImgPathNotList
     */
    public List<String> getButtonImgPathNotList(){
        return this.buttonImgPathNotList;
    }

    /**
     * 设置 按钮图标，按钮图标的css样式名
     * @param buttonImgPathNotList
     */
    public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
        this.buttonImgPathNotList = buttonImgPathNotList;
    }

    /**
     * 获取 常用菜单图标，常用菜单图标的css样式名
     * @return imgCommPathList
     */
    public List<String> getImgCommPathList(){
        return this.imgCommPathList;
    }

    /**
     * 设置 常用菜单图标，常用菜单图标的css样式名
     * @param imgCommPathList
     */
    public void setImgCommPathList(List<String> imgCommPathList){
        this.imgCommPathList = imgCommPathList;
    }

    /**
     * 获取 常用菜单图标，常用菜单图标的css样式名
     * @return imgCommPathNotList
     */
    public List<String> getImgCommPathNotList(){
        return this.imgCommPathNotList;
    }

    /**
     * 设置 常用菜单图标，常用菜单图标的css样式名
     * @param imgCommPathNotList
     */
    public void setImgCommPathNotList(List<String> imgCommPathNotList){
        this.imgCommPathNotList = imgCommPathNotList;
    }

    /**
     * 获取 开始 是否常用菜单 (0.非常用，1.常用)
     * @return commMenuStart
     */
    public Integer getCommMenuStart(){
        return this.commMenuStart;
    }

    /**
     * 设置 开始 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuStart
     */
    public void setCommMenuStart(Integer commMenuStart){
        this.commMenuStart = commMenuStart;
    }

    /**
     * 获取 结束 是否常用菜单 (0.非常用，1.常用)
     * @return $commMenuEnd
     */
    public Integer getCommMenuEnd(){
        return this.commMenuEnd;
    }

    /**
     * 设置 结束 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuEnd
     */
    public void setCommMenuEnd(Integer commMenuEnd){
        this.commMenuEnd = commMenuEnd;
    }

    /**
     * 获取 增加 是否常用菜单 (0.非常用，1.常用)
     * @return commMenuIncrement
     */
    public Integer getCommMenuIncrement(){
        return this.commMenuIncrement;
    }

    /**
     * 设置 增加 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuIncrement
     */
    public void setCommMenuIncrement(Integer commMenuIncrement){
        this.commMenuIncrement = commMenuIncrement;
    }

    /**
     * 获取 是否常用菜单 (0.非常用，1.常用)
     * @return commMenuList
     */
    public List<Integer> getCommMenuList(){
        return this.commMenuList;
    }

    /**
     * 设置 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuList
     */
    public void setCommMenuList(List<Integer> commMenuList){
        this.commMenuList = commMenuList;
    }

    /**
     * 获取 是否常用菜单 (0.非常用，1.常用)
     * @return commMenuNotList
     */
    public List<Integer> getCommMenuNotList(){
        return this.commMenuNotList;
    }

    /**
     * 设置 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuNotList
     */
    public void setCommMenuNotList(List<Integer> commMenuNotList){
        this.commMenuNotList = commMenuNotList;
    }


    /**
     * 获取 vue组件路径
     * @return componentList
     */
    public List<String> getComponentList(){
        return this.componentList;
    }

    /**
     * 设置 vue组件路径
     * @param componentList
     */
    public void setComponentList(List<String> componentList){
        this.componentList = componentList;
    }

    /**
     * 获取 vue组件路径
     * @return componentNotList
     */
    public List<String> getComponentNotList(){
        return this.componentNotList;
    }

    /**
     * 设置 vue组件路径
     * @param componentNotList
     */
    public void setComponentNotList(List<String> componentNotList){
        this.componentNotList = componentNotList;
    }

    /**
     * 获取 开始 菜单类型 (0.目录，1.菜单，2.按钮)
     * @return menuTypeStart
     */
    public Integer getMenuTypeStart(){
        return this.menuTypeStart;
    }

    /**
     * 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeStart
     */
    public void setMenuTypeStart(Integer menuTypeStart){
        this.menuTypeStart = menuTypeStart;
    }

    /**
     * 获取 结束 菜单类型 (0.目录，1.菜单，2.按钮)
     * @return $menuTypeEnd
     */
    public Integer getMenuTypeEnd(){
        return this.menuTypeEnd;
    }

    /**
     * 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeEnd
     */
    public void setMenuTypeEnd(Integer menuTypeEnd){
        this.menuTypeEnd = menuTypeEnd;
    }

    /**
     * 获取 增加 菜单类型 (0.目录，1.菜单，2.按钮)
     * @return menuTypeIncrement
     */
    public Integer getMenuTypeIncrement(){
        return this.menuTypeIncrement;
    }

    /**
     * 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeIncrement
     */
    public void setMenuTypeIncrement(Integer menuTypeIncrement){
        this.menuTypeIncrement = menuTypeIncrement;
    }

    /**
     * 获取 菜单类型 (0.目录，1.菜单，2.按钮)
     * @return menuTypeList
     */
    public List<Integer> getMenuTypeList(){
        return this.menuTypeList;
    }

    /**
     * 设置 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeList
     */
    public void setMenuTypeList(List<Integer> menuTypeList){
        this.menuTypeList = menuTypeList;
    }

    /**
     * 获取 菜单类型 (0.目录，1.菜单，2.按钮)
     * @return menuTypeNotList
     */
    public List<Integer> getMenuTypeNotList(){
        return this.menuTypeNotList;
    }

    /**
     * 设置 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeNotList
     */
    public void setMenuTypeNotList(List<Integer> menuTypeNotList){
        this.menuTypeNotList = menuTypeNotList;
    }


    /**
     * 获取 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @return authTypeStart
     */
    public Integer getAuthTypeStart(){
        return this.authTypeStart;
    }

    /**
     * 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeStart
     */
    public void setAuthTypeStart(Integer authTypeStart){
        this.authTypeStart = authTypeStart;
    }

    /**
     * 获取 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @return $authTypeEnd
     */
    public Integer getAuthTypeEnd(){
        return this.authTypeEnd;
    }

    /**
     * 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeEnd
     */
    public void setAuthTypeEnd(Integer authTypeEnd){
        this.authTypeEnd = authTypeEnd;
    }

    /**
     * 获取 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @return authTypeIncrement
     */
    public Integer getAuthTypeIncrement(){
        return this.authTypeIncrement;
    }

    /**
     * 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeIncrement
     */
    public void setAuthTypeIncrement(Integer authTypeIncrement){
        this.authTypeIncrement = authTypeIncrement;
    }

    /**
     * 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @return authTypeList
     */
    public List<Integer> getAuthTypeList(){
        return this.authTypeList;
    }

    /**
     * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeList
     */
    public void setAuthTypeList(List<Integer> authTypeList){
        this.authTypeList = authTypeList;
    }

    /**
     * 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @return authTypeNotList
     */
    public List<Integer> getAuthTypeNotList(){
        return this.authTypeNotList;
    }

    /**
     * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeNotList
     */
    public void setAuthTypeNotList(List<Integer> authTypeNotList){
        this.authTypeNotList = authTypeNotList;
    }


    /**
     * 获取 开始 菜单显示状态 (0.显示，1.隐藏)
     * @return visibleStart
     */
    public Integer getVisibleStart(){
        return this.visibleStart;
    }

    /**
     * 设置 开始 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleStart
     */
    public void setVisibleStart(Integer visibleStart){
        this.visibleStart = visibleStart;
    }

    /**
     * 获取 结束 菜单显示状态 (0.显示，1.隐藏)
     * @return $visibleEnd
     */
    public Integer getVisibleEnd(){
        return this.visibleEnd;
    }

    /**
     * 设置 结束 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleEnd
     */
    public void setVisibleEnd(Integer visibleEnd){
        this.visibleEnd = visibleEnd;
    }

    /**
     * 获取 增加 菜单显示状态 (0.显示，1.隐藏)
     * @return visibleIncrement
     */
    public Integer getVisibleIncrement(){
        return this.visibleIncrement;
    }

    /**
     * 设置 增加 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleIncrement
     */
    public void setVisibleIncrement(Integer visibleIncrement){
        this.visibleIncrement = visibleIncrement;
    }

    /**
     * 获取 菜单显示状态 (0.显示，1.隐藏)
     * @return visibleList
     */
    public List<Integer> getVisibleList(){
        return this.visibleList;
    }

    /**
     * 设置 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleList
     */
    public void setVisibleList(List<Integer> visibleList){
        this.visibleList = visibleList;
    }

    /**
     * 获取 菜单显示状态 (0.显示，1.隐藏)
     * @return visibleNotList
     */
    public List<Integer> getVisibleNotList(){
        return this.visibleNotList;
    }

    /**
     * 设置 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleNotList
     */
    public void setVisibleNotList(List<Integer> visibleNotList){
        this.visibleNotList = visibleNotList;
    }


    /**
     * 获取 权限标识，多个逗号分割
     * @return permsList
     */
    public List<String> getPermsList(){
        return this.permsList;
    }

    /**
     * 设置 权限标识，多个逗号分割
     * @param permsList
     */
    public void setPermsList(List<String> permsList){
        this.permsList = permsList;
    }

    /**
     * 获取 权限标识，多个逗号分割
     * @return permsNotList
     */
    public List<String> getPermsNotList(){
        return this.permsNotList;
    }

    /**
     * 设置 权限标识，多个逗号分割
     * @param permsNotList
     */
    public void setPermsNotList(List<String> permsNotList){
        this.permsNotList = permsNotList;
    }

    /**
     * 获取 备注信息
     * @return remarkList
     */
    public List<String> getRemarkList(){
        return this.remarkList;
    }

    /**
     * 设置 备注信息
     * @param remarkList
     */
    public void setRemarkList(List<String> remarkList){
        this.remarkList = remarkList;
    }

    /**
     * 获取 备注信息
     * @return remarkNotList
     */
    public List<String> getRemarkNotList(){
        return this.remarkNotList;
    }

    /**
     * 设置 备注信息
     * @param remarkNotList
     */
    public void setRemarkNotList(List<String> remarkNotList){
        this.remarkNotList = remarkNotList;
    }

    /**
     * 获取 开始 排序编号
     * @return orderIdStart
     */
    public Integer getOrderIdStart(){
        return this.orderIdStart;
    }

    /**
     * 设置 开始 排序编号
     * @param orderIdStart
     */
    public void setOrderIdStart(Integer orderIdStart){
        this.orderIdStart = orderIdStart;
    }

    /**
     * 获取 结束 排序编号
     * @return $orderIdEnd
     */
    public Integer getOrderIdEnd(){
        return this.orderIdEnd;
    }

    /**
     * 设置 结束 排序编号
     * @param orderIdEnd
     */
    public void setOrderIdEnd(Integer orderIdEnd){
        this.orderIdEnd = orderIdEnd;
    }

    /**
     * 获取 增加 排序编号
     * @return orderIdIncrement
     */
    public Integer getOrderIdIncrement(){
        return this.orderIdIncrement;
    }

    /**
     * 设置 增加 排序编号
     * @param orderIdIncrement
     */
    public void setOrderIdIncrement(Integer orderIdIncrement){
        this.orderIdIncrement = orderIdIncrement;
    }

    /**
     * 获取 排序编号
     * @return orderIdList
     */
    public List<Integer> getOrderIdList(){
        return this.orderIdList;
    }

    /**
     * 设置 排序编号
     * @param orderIdList
     */
    public void setOrderIdList(List<Integer> orderIdList){
        this.orderIdList = orderIdList;
    }

    /**
     * 获取 排序编号
     * @return orderIdNotList
     */
    public List<Integer> getOrderIdNotList(){
        return this.orderIdNotList;
    }

    /**
     * 设置 排序编号
     * @param orderIdNotList
     */
    public void setOrderIdNotList(List<Integer> orderIdNotList){
        this.orderIdNotList = orderIdNotList;
    }


    /**
     * 获取 开始 菜单状态 (0.停用，1.启用)
     * @return statusStart
     */
    public Integer getStatusStart(){
        return this.statusStart;
    }

    /**
     * 设置 开始 菜单状态 (0.停用，1.启用)
     * @param statusStart
     */
    public void setStatusStart(Integer statusStart){
        this.statusStart = statusStart;
    }

    /**
     * 获取 结束 菜单状态 (0.停用，1.启用)
     * @return $statusEnd
     */
    public Integer getStatusEnd(){
        return this.statusEnd;
    }

    /**
     * 设置 结束 菜单状态 (0.停用，1.启用)
     * @param statusEnd
     */
    public void setStatusEnd(Integer statusEnd){
        this.statusEnd = statusEnd;
    }

    /**
     * 获取 增加 菜单状态 (0.停用，1.启用)
     * @return statusIncrement
     */
    public Integer getStatusIncrement(){
        return this.statusIncrement;
    }

    /**
     * 设置 增加 菜单状态 (0.停用，1.启用)
     * @param statusIncrement
     */
    public void setStatusIncrement(Integer statusIncrement){
        this.statusIncrement = statusIncrement;
    }

    /**
     * 获取 菜单状态 (0.停用，1.启用)
     * @return statusList
     */
    public List<Integer> getStatusList(){
        return this.statusList;
    }

    /**
     * 设置 菜单状态 (0.停用，1.启用)
     * @param statusList
     */
    public void setStatusList(List<Integer> statusList){
        this.statusList = statusList;
    }

    /**
     * 获取 菜单状态 (0.停用，1.启用)
     * @return statusNotList
     */
    public List<Integer> getStatusNotList(){
        return this.statusNotList;
    }

    /**
     * 设置 菜单状态 (0.停用，1.启用)
     * @param statusNotList
     */
    public void setStatusNotList(List<Integer> statusNotList){
        this.statusNotList = statusNotList;
    }


    /**
     * 获取 开始 创建时间
     * @return createTimeStart
     */
    public String getCreateTimeStart(){
        return this.createTimeStart;
    }

    /**
     * 设置 开始 创建时间
     * @param createTimeStart
     */
    public void setCreateTimeStart(String createTimeStart){
        this.createTimeStart = createTimeStart;
    }

    /**
     * 获取 结束 创建时间
     * @return createTimeEnd
     */
    public String getCreateTimeEnd(){
        return this.createTimeEnd;
    }

    /**
     * 设置 结束 创建时间
     * @param createTimeEnd
     */
    public void setCreateTimeEnd(String createTimeEnd){
        this.createTimeEnd = createTimeEnd;
    }

    /**
     * 获取 开始 创建用户
     * @return createUserIdStart
     */
    public Long getCreateUserIdStart(){
        return this.createUserIdStart;
    }

    /**
     * 设置 开始 创建用户
     * @param createUserIdStart
     */
    public void setCreateUserIdStart(Long createUserIdStart){
        this.createUserIdStart = createUserIdStart;
    }

    /**
     * 获取 结束 创建用户
     * @return $createUserIdEnd
     */
    public Long getCreateUserIdEnd(){
        return this.createUserIdEnd;
    }

    /**
     * 设置 结束 创建用户
     * @param createUserIdEnd
     */
    public void setCreateUserIdEnd(Long createUserIdEnd){
        this.createUserIdEnd = createUserIdEnd;
    }

    /**
     * 获取 增加 创建用户
     * @return createUserIdIncrement
     */
    public Long getCreateUserIdIncrement(){
        return this.createUserIdIncrement;
    }

    /**
     * 设置 增加 创建用户
     * @param createUserIdIncrement
     */
    public void setCreateUserIdIncrement(Long createUserIdIncrement){
        this.createUserIdIncrement = createUserIdIncrement;
    }

    /**
     * 获取 创建用户
     * @return createUserIdList
     */
    public List<Long> getCreateUserIdList(){
        return this.createUserIdList;
    }

    /**
     * 设置 创建用户
     * @param createUserIdList
     */
    public void setCreateUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
    }

    /**
     * 获取 创建用户
     * @return createUserIdNotList
     */
    public List<Long> getCreateUserIdNotList(){
        return this.createUserIdNotList;
    }

    /**
     * 设置 创建用户
     * @param createUserIdNotList
     */
    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
        this.createUserIdNotList = createUserIdNotList;
    }


    /**
     * 获取 创建用户名称
     * @return createUserNameList
     */
    public List<String> getCreateUserNameList(){
        return this.createUserNameList;
    }

    /**
     * 设置 创建用户名称
     * @param createUserNameList
     */
    public void setCreateUserNameList(List<String> createUserNameList){
        this.createUserNameList = createUserNameList;
    }

    /**
     * 获取 创建用户名称
     * @return createUserNameNotList
     */
    public List<String> getCreateUserNameNotList(){
        return this.createUserNameNotList;
    }

    /**
     * 设置 创建用户名称
     * @param createUserNameNotList
     */
    public void setCreateUserNameNotList(List<String> createUserNameNotList){
        this.createUserNameNotList = createUserNameNotList;
    }

    /**
     * 获取 开始 更新用户
     * @return updateUserIdStart
     */
    public Long getUpdateUserIdStart(){
        return this.updateUserIdStart;
    }

    /**
     * 设置 开始 更新用户
     * @param updateUserIdStart
     */
    public void setUpdateUserIdStart(Long updateUserIdStart){
        this.updateUserIdStart = updateUserIdStart;
    }

    /**
     * 获取 结束 更新用户
     * @return $updateUserIdEnd
     */
    public Long getUpdateUserIdEnd(){
        return this.updateUserIdEnd;
    }

    /**
     * 设置 结束 更新用户
     * @param updateUserIdEnd
     */
    public void setUpdateUserIdEnd(Long updateUserIdEnd){
        this.updateUserIdEnd = updateUserIdEnd;
    }

    /**
     * 获取 增加 更新用户
     * @return updateUserIdIncrement
     */
    public Long getUpdateUserIdIncrement(){
        return this.updateUserIdIncrement;
    }

    /**
     * 设置 增加 更新用户
     * @param updateUserIdIncrement
     */
    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
        this.updateUserIdIncrement = updateUserIdIncrement;
    }

    /**
     * 获取 更新用户
     * @return updateUserIdList
     */
    public List<Long> getUpdateUserIdList(){
        return this.updateUserIdList;
    }

    /**
     * 设置 更新用户
     * @param updateUserIdList
     */
    public void setUpdateUserIdList(List<Long> updateUserIdList){
        this.updateUserIdList = updateUserIdList;
    }

    /**
     * 获取 更新用户
     * @return updateUserIdNotList
     */
    public List<Long> getUpdateUserIdNotList(){
        return this.updateUserIdNotList;
    }

    /**
     * 设置 更新用户
     * @param updateUserIdNotList
     */
    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
        this.updateUserIdNotList = updateUserIdNotList;
    }


    /**
     * 获取 创建用户名称
     * @return updateUserNameList
     */
    public List<String> getUpdateUserNameList(){
        return this.updateUserNameList;
    }

    /**
     * 设置 创建用户名称
     * @param updateUserNameList
     */
    public void setUpdateUserNameList(List<String> updateUserNameList){
        this.updateUserNameList = updateUserNameList;
    }

    /**
     * 获取 创建用户名称
     * @return updateUserNameNotList
     */
    public List<String> getUpdateUserNameNotList(){
        return this.updateUserNameNotList;
    }

    /**
     * 设置 创建用户名称
     * @param updateUserNameNotList
     */
    public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
        this.updateUserNameNotList = updateUserNameNotList;
    }

    /**
     * 获取 开始 更新时间
     * @return updateTimeStart
     */
    public String getUpdateTimeStart(){
        return this.updateTimeStart;
    }

    /**
     * 设置 开始 更新时间
     * @param updateTimeStart
     */
    public void setUpdateTimeStart(String updateTimeStart){
        this.updateTimeStart = updateTimeStart;
    }

    /**
     * 获取 结束 更新时间
     * @return updateTimeEnd
     */
    public String getUpdateTimeEnd(){
        return this.updateTimeEnd;
    }

    /**
     * 设置 结束 更新时间
     * @param updateTimeEnd
     */
    public void setUpdateTimeEnd(String updateTimeEnd){
        this.updateTimeEnd = updateTimeEnd;
    }

    /**
     * 获取 开始 是否启用缓存 (0.否，1.是)
     * @return cacheStart
     */
    public Integer getCacheStart(){
        return this.cacheStart;
    }

    /**
     * 设置 开始 是否启用缓存 (0.否，1.是)
     * @param cacheStart
     */
    public void setCacheStart(Integer cacheStart){
        this.cacheStart = cacheStart;
    }

    /**
     * 获取 结束 是否启用缓存 (0.否，1.是)
     * @return $cacheEnd
     */
    public Integer getCacheEnd(){
        return this.cacheEnd;
    }

    /**
     * 设置 结束 是否启用缓存 (0.否，1.是)
     * @param cacheEnd
     */
    public void setCacheEnd(Integer cacheEnd){
        this.cacheEnd = cacheEnd;
    }

    /**
     * 获取 增加 是否启用缓存 (0.否，1.是)
     * @return cacheIncrement
     */
    public Integer getCacheIncrement(){
        return this.cacheIncrement;
    }

    /**
     * 设置 增加 是否启用缓存 (0.否，1.是)
     * @param cacheIncrement
     */
    public void setCacheIncrement(Integer cacheIncrement){
        this.cacheIncrement = cacheIncrement;
    }

    /**
     * 获取 是否启用缓存 (0.否，1.是)
     * @return cacheList
     */
    public List<Integer> getCacheList(){
        return this.cacheList;
    }

    /**
     * 设置 是否启用缓存 (0.否，1.是)
     * @param cacheList
     */
    public void setCacheList(List<Integer> cacheList){
        this.cacheList = cacheList;
    }

    /**
     * 获取 是否启用缓存 (0.否，1.是)
     * @return cacheNotList
     */
    public List<Integer> getCacheNotList(){
        return this.cacheNotList;
    }

    /**
     * 设置 是否启用缓存 (0.否，1.是)
     * @param cacheNotList
     */
    public void setCacheNotList(List<Integer> cacheNotList){
        this.cacheNotList = cacheNotList;
    }


    /**
     * 获取 激活目录
     * @return activeDirList
     */
    public List<String> getActiveDirList(){
        return this.activeDirList;
    }

    /**
     * 设置 激活目录
     * @param activeDirList
     */
    public void setActiveDirList(List<String> activeDirList){
        this.activeDirList = activeDirList;
    }

    /**
     * 获取 激活目录
     * @return activeDirNotList
     */
    public List<String> getActiveDirNotList(){
        return this.activeDirNotList;
    }

    /**
     * 设置 激活目录
     * @param activeDirNotList
     */
    public void setActiveDirNotList(List<String> activeDirNotList){
        this.activeDirNotList = activeDirNotList;
    }

    /**
     * 获取 开始 是否隐藏(0.否，1.是)
     * @return hideChildrenInMenuStart
     */
    public Integer getHideChildrenInMenuStart(){
        return this.hideChildrenInMenuStart;
    }

    /**
     * 设置 开始 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuStart
     */
    public void setHideChildrenInMenuStart(Integer hideChildrenInMenuStart){
        this.hideChildrenInMenuStart = hideChildrenInMenuStart;
    }

    /**
     * 获取 结束 是否隐藏(0.否，1.是)
     * @return $hideChildrenInMenuEnd
     */
    public Integer getHideChildrenInMenuEnd(){
        return this.hideChildrenInMenuEnd;
    }

    /**
     * 设置 结束 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuEnd
     */
    public void setHideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
        this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
    }

    /**
     * 获取 增加 是否隐藏(0.否，1.是)
     * @return hideChildrenInMenuIncrement
     */
    public Integer getHideChildrenInMenuIncrement(){
        return this.hideChildrenInMenuIncrement;
    }

    /**
     * 设置 增加 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuIncrement
     */
    public void setHideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
        this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
    }

    /**
     * 获取 是否隐藏(0.否，1.是)
     * @return hideChildrenInMenuList
     */
    public List<Integer> getHideChildrenInMenuList(){
        return this.hideChildrenInMenuList;
    }

    /**
     * 设置 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuList
     */
    public void setHideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
        this.hideChildrenInMenuList = hideChildrenInMenuList;
    }

    /**
     * 获取 是否隐藏(0.否，1.是)
     * @return hideChildrenInMenuNotList
     */
    public List<Integer> getHideChildrenInMenuNotList(){
        return this.hideChildrenInMenuNotList;
    }

    /**
     * 设置 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuNotList
     */
    public void setHideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
        this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
    }


    /**
     * 获取 资源访问路径，多个逗号分割
     * @return resourceUrlList
     */
    public List<String> getResourceUrlList(){
        return this.resourceUrlList;
    }

    /**
     * 设置 资源访问路径，多个逗号分割
     * @param resourceUrlList
     */
    public void setResourceUrlList(List<String> resourceUrlList){
        this.resourceUrlList = resourceUrlList;
    }

    /**
     * 获取 资源访问路径，多个逗号分割
     * @return resourceUrlNotList
     */
    public List<String> getResourceUrlNotList(){
        return this.resourceUrlNotList;
    }

    /**
     * 设置 资源访问路径，多个逗号分割
     * @param resourceUrlNotList
     */
    public void setResourceUrlNotList(List<String> resourceUrlNotList){
        this.resourceUrlNotList = resourceUrlNotList;
    }

    /**
     * 设置  菜单ID，主键，自增长
     * @param id
     */
    public MenuQuery id(Long id){
        setId(id);
        return this;
    }

    /**
     * 设置 开始 菜单ID，主键，自增长
     * @param idStart
     */
    public MenuQuery idStart(Long idStart){
        this.idStart = idStart;
        return this;
    }

    /**
     * 设置 结束 菜单ID，主键，自增长
     * @param idEnd
     */
    public MenuQuery idEnd(Long idEnd){
        this.idEnd = idEnd;
        return this;
    }

    /**
     * 设置 增加 菜单ID，主键，自增长
     * @param idIncrement
     */
    public MenuQuery idIncrement(Long idIncrement){
        this.idIncrement = idIncrement;
        return this;
    }

    /**
     * 设置 菜单ID，主键，自增长
     * @param idList
     */
    public MenuQuery idList(List<Long> idList){
        this.idList = idList;
        return this;
    }

    /**
     * 设置 菜单ID，主键，自增长
     * @param idNotList
     */
    public MenuQuery idNotList(List<Long> idNotList){
        this.idNotList = idNotList;
        return this;
    }


    /**
     * 设置 菜单名称
     * @param name
     */
    public MenuQuery name(String name){
        setName(name);
        return this;
    }

    /**
     * 设置 菜单名称
     * @param nameList
     */
    public MenuQuery nameList(List<String> nameList){
        this.nameList = nameList;
        return this;
    }


    /**
     * 设置 路由地址
     * @param url
     */
    public MenuQuery url(String url){
        setUrl(url);
        return this;
    }

    /**
     * 设置 路由地址
     * @param urlList
     */
    public MenuQuery urlList(List<String> urlList){
        this.urlList = urlList;
        return this;
    }


    /**
     * 设置 当前节点父id路径，“，”分割
     * @param ancestors
     */
    public MenuQuery ancestors(String ancestors){
        setAncestors(ancestors);
        return this;
    }

    /**
     * 设置 当前节点父id路径，“，”分割
     * @param ancestorsList
     */
    public MenuQuery ancestorsList(List<String> ancestorsList){
        this.ancestorsList = ancestorsList;
        return this;
    }

    /**
     * 设置  父菜单ID，一级菜单的该字段值为-1
     * @param parentId
     */
    public MenuQuery parentId(Long parentId){
        setParentId(parentId);
        return this;
    }

    /**
     * 设置 开始 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdStart
     */
    public MenuQuery parentIdStart(Long parentIdStart){
        this.parentIdStart = parentIdStart;
        return this;
    }

    /**
     * 设置 结束 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdEnd
     */
    public MenuQuery parentIdEnd(Long parentIdEnd){
        this.parentIdEnd = parentIdEnd;
        return this;
    }

    /**
     * 设置 增加 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdIncrement
     */
    public MenuQuery parentIdIncrement(Long parentIdIncrement){
        this.parentIdIncrement = parentIdIncrement;
        return this;
    }

    /**
     * 设置 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdList
     */
    public MenuQuery parentIdList(List<Long> parentIdList){
        this.parentIdList = parentIdList;
        return this;
    }

    /**
     * 设置 父菜单ID，一级菜单的该字段值为-1
     * @param parentIdNotList
     */
    public MenuQuery parentIdNotList(List<Long> parentIdNotList){
        this.parentIdNotList = parentIdNotList;
        return this;
    }

    /**
     * 设置  链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkType
     */
    public MenuQuery linkType(Integer linkType){
        setLinkType(linkType);
        return this;
    }

    /**
     * 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeStart
     */
    public MenuQuery linkTypeStart(Integer linkTypeStart){
        this.linkTypeStart = linkTypeStart;
        return this;
    }

    /**
     * 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeEnd
     */
    public MenuQuery linkTypeEnd(Integer linkTypeEnd){
        this.linkTypeEnd = linkTypeEnd;
        return this;
    }

    /**
     * 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeIncrement
     */
    public MenuQuery linkTypeIncrement(Integer linkTypeIncrement){
        this.linkTypeIncrement = linkTypeIncrement;
        return this;
    }

    /**
     * 设置 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeList
     */
    public MenuQuery linkTypeList(List<Integer> linkTypeList){
        this.linkTypeList = linkTypeList;
        return this;
    }

    /**
     * 设置 链接方式 (0.普通，1.弹出，2.脚本)
     * @param linkTypeNotList
     */
    public MenuQuery linkTypeNotList(List<Integer> linkTypeNotList){
        this.linkTypeNotList = linkTypeNotList;
        return this;
    }


    /**
     * 设置 主菜单图标，主菜单图标的css样式名
     * @param imgPath
     */
    public MenuQuery imgPath(String imgPath){
        setImgPath(imgPath);
        return this;
    }

    /**
     * 设置 主菜单图标，主菜单图标的css样式名
     * @param imgPathList
     */
    public MenuQuery imgPathList(List<String> imgPathList){
        this.imgPathList = imgPathList;
        return this;
    }


    /**
     * 设置 按钮图标，按钮图标的css样式名
     * @param buttonImgPath
     */
    public MenuQuery buttonImgPath(String buttonImgPath){
        setButtonImgPath(buttonImgPath);
        return this;
    }

    /**
     * 设置 按钮图标，按钮图标的css样式名
     * @param buttonImgPathList
     */
    public MenuQuery buttonImgPathList(List<String> buttonImgPathList){
        this.buttonImgPathList = buttonImgPathList;
        return this;
    }


    /**
     * 设置 常用菜单图标，常用菜单图标的css样式名
     * @param imgCommPath
     */
    public MenuQuery imgCommPath(String imgCommPath){
        setImgCommPath(imgCommPath);
        return this;
    }

    /**
     * 设置 常用菜单图标，常用菜单图标的css样式名
     * @param imgCommPathList
     */
    public MenuQuery imgCommPathList(List<String> imgCommPathList){
        this.imgCommPathList = imgCommPathList;
        return this;
    }

    /**
     * 设置  是否常用菜单 (0.非常用，1.常用)
     * @param commMenu
     */
    public MenuQuery commMenu(Integer commMenu){
        setCommMenu(commMenu);
        return this;
    }

    /**
     * 设置 开始 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuStart
     */
    public MenuQuery commMenuStart(Integer commMenuStart){
        this.commMenuStart = commMenuStart;
        return this;
    }

    /**
     * 设置 结束 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuEnd
     */
    public MenuQuery commMenuEnd(Integer commMenuEnd){
        this.commMenuEnd = commMenuEnd;
        return this;
    }

    /**
     * 设置 增加 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuIncrement
     */
    public MenuQuery commMenuIncrement(Integer commMenuIncrement){
        this.commMenuIncrement = commMenuIncrement;
        return this;
    }

    /**
     * 设置 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuList
     */
    public MenuQuery commMenuList(List<Integer> commMenuList){
        this.commMenuList = commMenuList;
        return this;
    }

    /**
     * 设置 是否常用菜单 (0.非常用，1.常用)
     * @param commMenuNotList
     */
    public MenuQuery commMenuNotList(List<Integer> commMenuNotList){
        this.commMenuNotList = commMenuNotList;
        return this;
    }


    /**
     * 设置 vue组件路径
     * @param component
     */
    public MenuQuery component(String component){
        setComponent(component);
        return this;
    }

    /**
     * 设置 vue组件路径
     * @param componentList
     */
    public MenuQuery componentList(List<String> componentList){
        this.componentList = componentList;
        return this;
    }

    /**
     * 设置  菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuType
     */
    public MenuQuery menuType(Integer menuType){
        setMenuType(menuType);
        return this;
    }

    /**
     * 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeStart
     */
    public MenuQuery menuTypeStart(Integer menuTypeStart){
        this.menuTypeStart = menuTypeStart;
        return this;
    }

    /**
     * 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeEnd
     */
    public MenuQuery menuTypeEnd(Integer menuTypeEnd){
        this.menuTypeEnd = menuTypeEnd;
        return this;
    }

    /**
     * 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeIncrement
     */
    public MenuQuery menuTypeIncrement(Integer menuTypeIncrement){
        this.menuTypeIncrement = menuTypeIncrement;
        return this;
    }

    /**
     * 设置 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeList
     */
    public MenuQuery menuTypeList(List<Integer> menuTypeList){
        this.menuTypeList = menuTypeList;
        return this;
    }

    /**
     * 设置 菜单类型 (0.目录，1.菜单，2.按钮)
     * @param menuTypeNotList
     */
    public MenuQuery menuTypeNotList(List<Integer> menuTypeNotList){
        this.menuTypeNotList = menuTypeNotList;
        return this;
    }

    /**
     * 设置  权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authType
     */
    public MenuQuery authType(Integer authType){
        setAuthType(authType);
        return this;
    }

    /**
     * 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeStart
     */
    public MenuQuery authTypeStart(Integer authTypeStart){
        this.authTypeStart = authTypeStart;
        return this;
    }

    /**
     * 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeEnd
     */
    public MenuQuery authTypeEnd(Integer authTypeEnd){
        this.authTypeEnd = authTypeEnd;
        return this;
    }

    /**
     * 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeIncrement
     */
    public MenuQuery authTypeIncrement(Integer authTypeIncrement){
        this.authTypeIncrement = authTypeIncrement;
        return this;
    }

    /**
     * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeList
     */
    public MenuQuery authTypeList(List<Integer> authTypeList){
        this.authTypeList = authTypeList;
        return this;
    }

    /**
     * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
     * @param authTypeNotList
     */
    public MenuQuery authTypeNotList(List<Integer> authTypeNotList){
        this.authTypeNotList = authTypeNotList;
        return this;
    }

    /**
     * 设置  菜单显示状态 (0.显示，1.隐藏)
     * @param visible
     */
    public MenuQuery visible(Integer visible){
        setVisible(visible);
        return this;
    }

    /**
     * 设置 开始 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleStart
     */
    public MenuQuery visibleStart(Integer visibleStart){
        this.visibleStart = visibleStart;
        return this;
    }

    /**
     * 设置 结束 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleEnd
     */
    public MenuQuery visibleEnd(Integer visibleEnd){
        this.visibleEnd = visibleEnd;
        return this;
    }

    /**
     * 设置 增加 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleIncrement
     */
    public MenuQuery visibleIncrement(Integer visibleIncrement){
        this.visibleIncrement = visibleIncrement;
        return this;
    }

    /**
     * 设置 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleList
     */
    public MenuQuery visibleList(List<Integer> visibleList){
        this.visibleList = visibleList;
        return this;
    }

    /**
     * 设置 菜单显示状态 (0.显示，1.隐藏)
     * @param visibleNotList
     */
    public MenuQuery visibleNotList(List<Integer> visibleNotList){
        this.visibleNotList = visibleNotList;
        return this;
    }


    /**
     * 设置 权限标识，多个逗号分割
     * @param perms
     */
    public MenuQuery perms(String perms){
        setPerms(perms);
        return this;
    }

    /**
     * 设置 权限标识，多个逗号分割
     * @param permsList
     */
    public MenuQuery permsList(List<String> permsList){
        this.permsList = permsList;
        return this;
    }


    /**
     * 设置 备注信息
     * @param remark
     */
    public MenuQuery remark(String remark){
        setRemark(remark);
        return this;
    }

    /**
     * 设置 备注信息
     * @param remarkList
     */
    public MenuQuery remarkList(List<String> remarkList){
        this.remarkList = remarkList;
        return this;
    }

    /**
     * 设置  排序编号
     * @param orderId
     */
    public MenuQuery orderId(Integer orderId){
        setOrderId(orderId);
        return this;
    }

    /**
     * 设置 开始 排序编号
     * @param orderIdStart
     */
    public MenuQuery orderIdStart(Integer orderIdStart){
        this.orderIdStart = orderIdStart;
        return this;
    }

    /**
     * 设置 结束 排序编号
     * @param orderIdEnd
     */
    public MenuQuery orderIdEnd(Integer orderIdEnd){
        this.orderIdEnd = orderIdEnd;
        return this;
    }

    /**
     * 设置 增加 排序编号
     * @param orderIdIncrement
     */
    public MenuQuery orderIdIncrement(Integer orderIdIncrement){
        this.orderIdIncrement = orderIdIncrement;
        return this;
    }

    /**
     * 设置 排序编号
     * @param orderIdList
     */
    public MenuQuery orderIdList(List<Integer> orderIdList){
        this.orderIdList = orderIdList;
        return this;
    }

    /**
     * 设置 排序编号
     * @param orderIdNotList
     */
    public MenuQuery orderIdNotList(List<Integer> orderIdNotList){
        this.orderIdNotList = orderIdNotList;
        return this;
    }

    /**
     * 设置  菜单状态 (0.停用，1.启用)
     * @param status
     */
    public MenuQuery status(Integer status){
        setStatus(status);
        return this;
    }

    /**
     * 设置 开始 菜单状态 (0.停用，1.启用)
     * @param statusStart
     */
    public MenuQuery statusStart(Integer statusStart){
        this.statusStart = statusStart;
        return this;
    }

    /**
     * 设置 结束 菜单状态 (0.停用，1.启用)
     * @param statusEnd
     */
    public MenuQuery statusEnd(Integer statusEnd){
        this.statusEnd = statusEnd;
        return this;
    }

    /**
     * 设置 增加 菜单状态 (0.停用，1.启用)
     * @param statusIncrement
     */
    public MenuQuery statusIncrement(Integer statusIncrement){
        this.statusIncrement = statusIncrement;
        return this;
    }

    /**
     * 设置 菜单状态 (0.停用，1.启用)
     * @param statusList
     */
    public MenuQuery statusList(List<Integer> statusList){
        this.statusList = statusList;
        return this;
    }

    /**
     * 设置 菜单状态 (0.停用，1.启用)
     * @param statusNotList
     */
    public MenuQuery statusNotList(List<Integer> statusNotList){
        this.statusNotList = statusNotList;
        return this;
    }


    /**
     * 设置  创建用户
     * @param createUserId
     */
    public MenuQuery createUserId(Long createUserId){
        setCreateUserId(createUserId);
        return this;
    }

    /**
     * 设置 开始 创建用户
     * @param createUserIdStart
     */
    public MenuQuery createUserIdStart(Long createUserIdStart){
        this.createUserIdStart = createUserIdStart;
        return this;
    }

    /**
     * 设置 结束 创建用户
     * @param createUserIdEnd
     */
    public MenuQuery createUserIdEnd(Long createUserIdEnd){
        this.createUserIdEnd = createUserIdEnd;
        return this;
    }

    /**
     * 设置 增加 创建用户
     * @param createUserIdIncrement
     */
    public MenuQuery createUserIdIncrement(Long createUserIdIncrement){
        this.createUserIdIncrement = createUserIdIncrement;
        return this;
    }

    /**
     * 设置 创建用户
     * @param createUserIdList
     */
    public MenuQuery createUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
        return this;
    }

    /**
     * 设置 创建用户
     * @param createUserIdNotList
     */
    public MenuQuery createUserIdNotList(List<Long> createUserIdNotList){
        this.createUserIdNotList = createUserIdNotList;
        return this;
    }


    /**
     * 设置 创建用户名称
     * @param createUserName
     */
    public MenuQuery createUserName(String createUserName){
        setCreateUserName(createUserName);
        return this;
    }

    /**
     * 设置 创建用户名称
     * @param createUserNameList
     */
    public MenuQuery createUserNameList(List<String> createUserNameList){
        this.createUserNameList = createUserNameList;
        return this;
    }

    /**
     * 设置  更新用户
     * @param updateUserId
     */
    public MenuQuery updateUserId(Long updateUserId){
        setUpdateUserId(updateUserId);
        return this;
    }

    /**
     * 设置 开始 更新用户
     * @param updateUserIdStart
     */
    public MenuQuery updateUserIdStart(Long updateUserIdStart){
        this.updateUserIdStart = updateUserIdStart;
        return this;
    }

    /**
     * 设置 结束 更新用户
     * @param updateUserIdEnd
     */
    public MenuQuery updateUserIdEnd(Long updateUserIdEnd){
        this.updateUserIdEnd = updateUserIdEnd;
        return this;
    }

    /**
     * 设置 增加 更新用户
     * @param updateUserIdIncrement
     */
    public MenuQuery updateUserIdIncrement(Long updateUserIdIncrement){
        this.updateUserIdIncrement = updateUserIdIncrement;
        return this;
    }

    /**
     * 设置 更新用户
     * @param updateUserIdList
     */
    public MenuQuery updateUserIdList(List<Long> updateUserIdList){
        this.updateUserIdList = updateUserIdList;
        return this;
    }

    /**
     * 设置 更新用户
     * @param updateUserIdNotList
     */
    public MenuQuery updateUserIdNotList(List<Long> updateUserIdNotList){
        this.updateUserIdNotList = updateUserIdNotList;
        return this;
    }


    /**
     * 设置 创建用户名称
     * @param updateUserName
     */
    public MenuQuery updateUserName(String updateUserName){
        setUpdateUserName(updateUserName);
        return this;
    }

    /**
     * 设置 创建用户名称
     * @param updateUserNameList
     */
    public MenuQuery updateUserNameList(List<String> updateUserNameList){
        this.updateUserNameList = updateUserNameList;
        return this;
    }


    /**
     * 设置  是否启用缓存 (0.否，1.是)
     * @param cache
     */
    public MenuQuery cache(Integer cache){
        setCache(cache);
        return this;
    }

    /**
     * 设置 开始 是否启用缓存 (0.否，1.是)
     * @param cacheStart
     */
    public MenuQuery cacheStart(Integer cacheStart){
        this.cacheStart = cacheStart;
        return this;
    }

    /**
     * 设置 结束 是否启用缓存 (0.否，1.是)
     * @param cacheEnd
     */
    public MenuQuery cacheEnd(Integer cacheEnd){
        this.cacheEnd = cacheEnd;
        return this;
    }

    /**
     * 设置 增加 是否启用缓存 (0.否，1.是)
     * @param cacheIncrement
     */
    public MenuQuery cacheIncrement(Integer cacheIncrement){
        this.cacheIncrement = cacheIncrement;
        return this;
    }

    /**
     * 设置 是否启用缓存 (0.否，1.是)
     * @param cacheList
     */
    public MenuQuery cacheList(List<Integer> cacheList){
        this.cacheList = cacheList;
        return this;
    }

    /**
     * 设置 是否启用缓存 (0.否，1.是)
     * @param cacheNotList
     */
    public MenuQuery cacheNotList(List<Integer> cacheNotList){
        this.cacheNotList = cacheNotList;
        return this;
    }


    /**
     * 设置 激活目录
     * @param activeDir
     */
    public MenuQuery activeDir(String activeDir){
        setActiveDir(activeDir);
        return this;
    }

    /**
     * 设置 激活目录
     * @param activeDirList
     */
    public MenuQuery activeDirList(List<String> activeDirList){
        this.activeDirList = activeDirList;
        return this;
    }

    /**
     * 设置  是否隐藏(0.否，1.是)
     * @param hideChildrenInMenu
     */
    public MenuQuery hideChildrenInMenu(Integer hideChildrenInMenu){
        setHideChildrenInMenu(hideChildrenInMenu);
        return this;
    }

    /**
     * 设置 开始 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuStart
     */
    public MenuQuery hideChildrenInMenuStart(Integer hideChildrenInMenuStart){
        this.hideChildrenInMenuStart = hideChildrenInMenuStart;
        return this;
    }

    /**
     * 设置 结束 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuEnd
     */
    public MenuQuery hideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
        this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
        return this;
    }

    /**
     * 设置 增加 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuIncrement
     */
    public MenuQuery hideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
        this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
        return this;
    }

    /**
     * 设置 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuList
     */
    public MenuQuery hideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
        this.hideChildrenInMenuList = hideChildrenInMenuList;
        return this;
    }

    /**
     * 设置 是否隐藏(0.否，1.是)
     * @param hideChildrenInMenuNotList
     */
    public MenuQuery hideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
        this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
        return this;
    }


    /**
     * 设置 资源访问路径，多个逗号分割
     * @param resourceUrl
     */
    public MenuQuery resourceUrl(String resourceUrl){
        setResourceUrl(resourceUrl);
        return this;
    }

    /**
     * 设置 资源访问路径，多个逗号分割
     * @param resourceUrlList
     */
    public MenuQuery resourceUrlList(List<String> resourceUrlList){
        this.resourceUrlList = resourceUrlList;
        return this;
    }

    /**
     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
     * @return orConditionList
     */
    public List<MenuQuery> getOrConditionList(){
        return this.orConditionList;
    }

    /**
     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
     * @param orConditionList
     */
    public void setOrConditionList(List<MenuQuery> orConditionList){
        this.orConditionList = orConditionList;
    }

    /**
     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
     * @return andConditionList
     */
    public List<MenuQuery> getAndConditionList(){
        return this.andConditionList;
    }

    /**
     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
     * @param andConditionList
     */
    public void setAndConditionList(List<MenuQuery> andConditionList){
        this.andConditionList = andConditionList;
    }

}