/**
* 文件：MenuQuery.java
* 版本：1.0.0
* 日期：
* Copyright &reg; 
* All right reserved.
*/

package com.mortals.xhx.base.system.menu.model;
import java.util.List;
/**
 * <p>Title: 菜单信息</p>
 * <p>Description: MenuQuery  </p>
 * <p>Copyright: Copyright &reg;  </p>
 * <p>Company: </p>
 * @author 
 * @version 1.0.0
 */
public class MenuQuery extends MenuEntity{
	private static final long serialVersionUID = 1547777703329L;
	/** 开始 菜单ID，主键，自增长 */
	private Long idStart;

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

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

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

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

	/** 连接地址 */
	private List<String> urlList;

	/** 开始 父菜单ID，一级菜单的该字段值为-1 */
	private Long parentIdStart;

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

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

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

	/** 开始 排序编号 */
	private Integer orderIdStart;

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

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

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

	/** 开始 菜单状态，0：禁用，1：启用，默认1 */
	private Integer statusStart;

	/** 结束 菜单状态，0：禁用，1：启用，默认1 */
	private Integer statusEnd;

	/** 增加 菜单状态，0：禁用，1：启用，默认1 */
	private Integer statusIncrement;

	/** 菜单状态，0：禁用，1：启用，默认1 */
	private List<Integer> statusList;

	/** 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
	private Integer linkTypeStart;

	/** 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
	private Integer linkTypeEnd;

	/** 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
	private Integer linkTypeIncrement;

	/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
	private List<Integer> linkTypeList;

	/** 开始 分组编号，使用菜单分隔符按该值分隔，默认1 */
	private Integer groupIdStart;

	/** 结束 分组编号，使用菜单分隔符按该值分隔，默认1 */
	private Integer groupIdEnd;

	/** 增加 分组编号，使用菜单分隔符按该值分隔，默认1 */
	private Integer groupIdIncrement;

	/** 分组编号，使用菜单分隔符按该值分隔，默认1 */
	private List<Integer> groupIdList;

	/** 分组名称 */
	private List<String> groupNameList;

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

	/** 按钮图标，按钮图标的css样式名 */
	private List<String> buttonImgPathList;

	/** 常用菜单图标，常用菜单图标的css样式名 */
	private List<String> imgCommPathList;

	/** 开始 是否常用菜单，0：非常用，1：常用，默认0 */
	private Integer commMenuStart;

	/** 结束 是否常用菜单，0：非常用，1：常用，默认0 */
	private Integer commMenuEnd;

	/** 增加 是否常用菜单，0：非常用，1：常用，默认0 */
	private Integer commMenuIncrement;

	/** 是否常用菜单，0：非常用，1：常用，默认0 */
	private List<Integer> commMenuList;

	/** 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
	private Integer menuTypeStart;

	/** 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
	private Integer menuTypeEnd;

	/** 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
	private Integer menuTypeIncrement;

	/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
	private List<Integer> menuTypeList;

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

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

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

	/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
	private List<Integer> authTypeList;

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

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

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

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

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

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

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


	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;
	}

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

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

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

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

	/**
	 * 获取 开始 父菜单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;
	}

	/**
	 * 获取 开始 排序编号
	 * @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;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/**
	 * 获取 开始 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @return groupIdStart
	 */
	public Integer getGroupIdStart(){
		return this.groupIdStart;
	}

	/**
	 * 设置 开始 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @param groupIdStart
	 */
	public void setGroupIdStart(Integer groupIdStart){
		this.groupIdStart = groupIdStart;
	}

	/**
	 * 获取 结束 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @return groupIdEnd
	 */
	public Integer getGroupIdEnd(){
		return this.groupIdEnd;
	}

	/**
	 * 设置 结束 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @param groupIdEnd
	 */
	public void setGroupIdEnd(Integer groupIdEnd){
		this.groupIdEnd = groupIdEnd;
	}

	/**
	 * 获取 增加 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @return groupIdIncrement
	 */
	public Integer getGroupIdIncrement(){
		return this.groupIdIncrement;
	}

	/**
	 * 设置 增加 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @param groupIdIncrement
	 */
	public void setGroupIdIncrement(Integer groupIdIncrement){
		this.groupIdIncrement = groupIdIncrement;
	}

	/**
	 * 获取 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @return groupIdList
	 */
	public List<Integer> getGroupIdList(){
		return this.groupIdList;
	}

	/**
	 * 设置 分组编号，使用菜单分隔符按该值分隔，默认1
	 * @param groupIdList
	 */
	public void setGroupIdList(List<Integer> groupIdList){
		this.groupIdList = groupIdList;
	}

	/**
	 * 获取 分组名称
	 * @return groupNameList
	 */
	public List<String> getGroupNameList(){
		return this.groupNameList;
	}

	/**
	 * 设置 分组名称
	 * @param groupNameList
	 */
	public void setGroupNameList(List<String> groupNameList){
		this.groupNameList = groupNameList;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/**
	 * 获取 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @return menuTypeStart
	 */
	public Integer getMenuTypeStart(){
		return this.menuTypeStart;
	}

	/**
	 * 设置 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @param menuTypeStart
	 */
	public void setMenuTypeStart(Integer menuTypeStart){
		this.menuTypeStart = menuTypeStart;
	}

	/**
	 * 获取 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @return menuTypeEnd
	 */
	public Integer getMenuTypeEnd(){
		return this.menuTypeEnd;
	}

	/**
	 * 设置 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @param menuTypeEnd
	 */
	public void setMenuTypeEnd(Integer menuTypeEnd){
		this.menuTypeEnd = menuTypeEnd;
	}

	/**
	 * 获取 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @return menuTypeIncrement
	 */
	public Integer getMenuTypeIncrement(){
		return this.menuTypeIncrement;
	}

	/**
	 * 设置 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @param menuTypeIncrement
	 */
	public void setMenuTypeIncrement(Integer menuTypeIncrement){
		this.menuTypeIncrement = menuTypeIncrement;
	}

	/**
	 * 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @return menuTypeList
	 */
	public List<Integer> getMenuTypeList(){
		return this.menuTypeList;
	}

	/**
	 * 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
	 * @param menuTypeList
	 */
	public void setMenuTypeList(List<Integer> menuTypeList){
		this.menuTypeList = menuTypeList;
	}

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

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

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

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

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

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

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

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

	/**
	 * 获取 开始 创建时间
	 * @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 createUserNameList
	 */
	public List<String> getCreateUserNameList(){
		return this.createUserNameList;
	}

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


}