package com.mortals.xhx.module.matter.model;

import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.matter.model.MatterEntity;
/**
 * 基础事项查询对象
 *
 * @author zxfei
 * @date 2025-03-15
 */
public class MatterQuery extends MatterEntity {
    /** 开始 序号，主键，自增长 */
    private Long idStart;

    /** 结束 序号，主键，自增长 */
    private Long idEnd;

    /** 增加 序号，主键，自增长 */
    private Long idIncrement;

    /** 序号，主键，自增长列表 */
    private List <Long> idList;

    /** 序号，主键，自增长排除列表 */
    private List <Long> idNotList;

    /** 开始 站点ID */
    private Long siteIdStart;

    /** 结束 站点ID */
    private Long siteIdEnd;

    /** 增加 站点ID */
    private Long siteIdIncrement;

    /** 站点ID列表 */
    private List <Long> siteIdList;

    /** 站点ID排除列表 */
    private List <Long> siteIdNotList;

    /** 从政务系统来的事项id */
    private List<String> tidList;

    /** 从政务系统来的事项id排除列表 */
    private List <String> tidNotList;
    /** 从政务系统来的事项code */
    private List<String> tcodeList;

    /** 从政务系统来的事项code排除列表 */
    private List <String> tcodeNotList;
    /** 从政务系统来的事项name */
    private List<String> tnameList;

    /** 从政务系统来的事项name排除列表 */
    private List <String> tnameNotList;
    /** 事项名称 */
    private List<String> matterNameList;

    /** 事项名称排除列表 */
    private List <String> matterNameNotList;
    /** 英语事项名 */
    private List<String> englishNameList;

    /** 英语事项名排除列表 */
    private List <String> englishNameNotList;
    /** 事项编号 */
    private List<String> matterNoList;

    /** 事项编号排除列表 */
    private List <String> matterNoNotList;
    /** 区域编码 */
    private List<String> areaCodeList;

    /** 区域编码排除列表 */
    private List <String> areaCodeNotList;
    /** 部门编号 */
    private List<String> deptCodeList;

    /** 部门编号排除列表 */
    private List <String> deptCodeNotList;
    /** 行政权力编号 */
    private List<String> powerCodeList;

    /** 行政权力编号排除列表 */
    private List <String> powerCodeNotList;
    /** 主题编号 */
    private List<String> themeCodeList;

    /** 主题编号排除列表 */
    private List <String> themeCodeNotList;
    /** 服务类型编号 */
    private List<String> usertypeCodeList;

    /** 服务类型编号排除列表 */
    private List <String> usertypeCodeNotList;
    /** 事项组名 */
    private List<String> groupNameList;

    /** 事项组名排除列表 */
    private List <String> groupNameNotList;
    /** 事项详情链接 */
    private List<String> urlList;

    /** 事项详情链接排除列表 */
    private List <String> urlNotList;
    /** 是否获取事项详情 */
    private List<String> haveGetMatterInfoList;

    /** 是否获取事项详情排除列表 */
    private List <String> haveGetMatterInfoNotList;
    /** 所属部门 */
    private List<String> belongDeptList;

    /** 所属部门排除列表 */
    private List <String> belongDeptNotList;
    /** 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织） */
    private List<String> appoveObjectShowList;

    /** 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）排除列表 */
    private List <String> appoveObjectShowNotList;
    /** 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]） */
    private List<String> operatScopeShowList;

    /** 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）排除列表 */
    private List <String> operatScopeShowNotList;
    /** 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件） */
    private List<String> appoveTimeLimitShowList;

    /** 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）排除列表 */
    private List <String> appoveTimeLimitShowNotList;
    /** 办理形式（窗口办理.窗口办理，网上办理.网上办理）	 */
    private List<String> handleTypeList;

    /** 办理形式（窗口办理.窗口办理，网上办理.网上办理）	排除列表 */
    private List <String> handleTypeNotList;
    /** 法定办结时限 */
    private List<String> legalTimeLimitShowList;

    /** 法定办结时限排除列表 */
    private List <String> legalTimeLimitShowNotList;
    /** 法定时限办结说明 */
    private List<String> legalEndExplainList;

    /** 法定时限办结说明排除列表 */
    private List <String> legalEndExplainNotList;
    /** 承诺办结时限 */
    private List<String> promiseTimeLimitShowList;

    /** 承诺办结时限排除列表 */
    private List <String> promiseTimeLimitShowNotList;
    /** 承诺时限办结说明 */
    private List<String> promiseEndExplainList;

    /** 承诺时限办结说明排除列表 */
    private List <String> promiseEndExplainNotList;
    /** 是否收费（否.否，是.是） */
    private List<String> isChargesShowList;

    /** 是否收费（否.否，是.是）排除列表 */
    private List <String> isChargesShowNotList;
    /** 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签） */
    private List<String> certificationLevelsShowList;

    /** 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）排除列表 */
    private List <String> certificationLevelsShowNotList;
    /** 开始 计划生效日期 */
    private String planTakeTimeStart;

    /** 结束 计划生效日期 */
    private String planTakeTimeEnd;

    /** 开始 承诺生效日期 */
    private String promiseTakeTimeStart;

    /** 结束 承诺生效日期 */
    private String promiseTakeTimeEnd;

    /** 特别程序 */
    private List<String> specialProcedureList;

    /** 特别程序排除列表 */
    private List <String> specialProcedureNotList;
    /** 开始 窗口到现场次数 */
    private Integer windowToTheSceneNumStart;

    /** 结束 窗口到现场次数 */
    private Integer windowToTheSceneNumEnd;

    /** 增加 窗口到现场次数 */
    private Integer windowToTheSceneNumIncrement;

    /** 窗口到现场次数列表 */
    private List <Integer> windowToTheSceneNumList;

    /** 窗口到现场次数排除列表 */
    private List <Integer> windowToTheSceneNumNotList;

    /** 是否网上预约,窗口办理选（否.否，是.是） */
    private List<String> isOnlineSubscribeShowList;

    /** 是否网上预约,窗口办理选（否.否，是.是）排除列表 */
    private List <String> isOnlineSubscribeShowNotList;
    /** 物流快递,窗口办理选（否.否，是.是） */
    private List<String> isExpressTakeShowList;

    /** 物流快递,窗口办理选（否.否，是.是）排除列表 */
    private List <String> isExpressTakeShowNotList;
    /** 是否支持全省范围就近取件（否.否，是.是） */
    private List<String> isProvinceAcquisitionShowList;

    /** 是否支持全省范围就近取件（否.否，是.是）排除列表 */
    private List <String> isProvinceAcquisitionShowNotList;
    /** 是否支持全省范围就近办理（否.否，是.是） */
    private List<String> isApplyProvinceShowList;

    /** 是否支持全省范围就近办理（否.否，是.是）排除列表 */
    private List <String> isApplyProvinceShowNotList;
    /** 必须到现场原因 */
    private List<String> mustSceneExplainList;

    /** 必须到现场原因排除列表 */
    private List <String> mustSceneExplainNotList;
    /** 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办） */
    private List<String> onlineTypeList;

    /** 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）排除列表 */
    private List <String> onlineTypeNotList;
    /** 开始 网办到现场次数 */
    private Integer onlineToTheSceneNumStart;

    /** 结束 网办到现场次数 */
    private Integer onlineToTheSceneNumEnd;

    /** 增加 网办到现场次数 */
    private Integer onlineToTheSceneNumIncrement;

    /** 网办到现场次数列表 */
    private List <Integer> onlineToTheSceneNumList;

    /** 网办到现场次数排除列表 */
    private List <Integer> onlineToTheSceneNumNotList;

    /** 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他） */
    private List<String> onlineOperatDeepList;

    /** 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）排除列表 */
    private List <String> onlineOperatDeepNotList;
    /** 物流快递，网上办理选（否.否，是.是） */
    private List<String> isExpressTakeOnlineShowList;

    /** 物流快递，网上办理选（否.否，是.是）排除列表 */
    private List <String> isExpressTakeOnlineShowNotList;
    /** 是否支持上门收取申请（否.否，是.是） */
    private List<String> isDoorTakeShowList;

    /** 是否支持上门收取申请（否.否，是.是）排除列表 */
    private List <String> isDoorTakeShowNotList;
    /** 网上必须到现场原因 */
    private List<String> onlineMustSceneExplainList;

    /** 网上必须到现场原因排除列表 */
    private List <String> onlineMustSceneExplainNotList;
    /** 实施主体 */
    private List<String> performDeptTypeList;

    /** 实施主体排除列表 */
    private List <String> performDeptTypeNotList;
    /** 事项版本 */
    private List<String> matterEditionList;

    /** 事项版本排除列表 */
    private List <String> matterEditionNotList;
    /** 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项） */
    private List<String> eventTypeShowList;

    /** 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）排除列表 */
    private List <String> eventTypeShowNotList;
    /** 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级） */
    private List<String> performHierarchyShowList;

    /** 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）排除列表 */
    private List <String> performHierarchyShowNotList;
    /** 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托） */
    private List<String> powerSourceShowList;

    /** 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）排除列表 */
    private List <String> powerSourceShowNotList;
    /** 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织） */
    private List<String> performDeptTypeShowList;

    /** 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）排除列表 */
    private List <String> performDeptTypeShowNotList;
    /** 是否进驻中心（否.否，是.是） */
    private List<String> goveServiceCenterShowList;

    /** 是否进驻中心（否.否，是.是）排除列表 */
    private List <String> goveServiceCenterShowNotList;
    /** 是否纳入便民服务中心（否.否，是.是） */
    private List<String> isConvenientCenterShowList;

    /** 是否纳入便民服务中心（否.否，是.是）排除列表 */
    private List <String> isConvenientCenterShowNotList;
    /** 自助终端办理 （否.否，是.是） */
    private List<String> terminalHandleList;

    /** 自助终端办理 （否.否，是.是）排除列表 */
    private List <String> terminalHandleNotList;
    /** 是否网办 （否.否，是.是） */
    private List<String> isOnlineList;

    /** 是否网办 （否.否，是.是）排除列表 */
    private List <String> isOnlineNotList;
    /** 支持网上支付（否.否，是.是） */
    private List<String> isOnlinePayShowList;

    /** 支持网上支付（否.否，是.是）排除列表 */
    private List <String> isOnlinePayShowNotList;
    /** 委托部门（否.否，是.是） */
    private List<String> entrustmentDepartmenList;

    /** 委托部门（否.否，是.是）排除列表 */
    private List <String> entrustmentDepartmenNotList;
    /** 联办机构 */
    private List<String> jointInfoShowList;

    /** 联办机构排除列表 */
    private List <String> jointInfoShowNotList;
    /** 事项状态（停用.停用，在用.在用） */
    private List<String> matterStatusList;

    /** 事项状态（停用.停用，在用.在用）排除列表 */
    private List <String> matterStatusNotList;
    /** 开始 数量限制 */
    private Long numberLimitStart;

    /** 结束 数量限制 */
    private Long numberLimitEnd;

    /** 增加 数量限制 */
    private Long numberLimitIncrement;

    /** 数量限制列表 */
    private List <Long> numberLimitList;

    /** 数量限制排除列表 */
    private List <Long> numberLimitNotList;

    /** 主题类型 */
    private List<String> typeList;

    /** 主题类型排除列表 */
    private List <String> typeNotList;
    /** 基本编码 */
    private List<String> baseCodeList;

    /** 基本编码排除列表 */
    private List <String> baseCodeNotList;
    /** 实施编码 */
    private List<String> implementCodeList;

    /** 实施编码排除列表 */
    private List <String> implementCodeNotList;
    /** 实施主体编码 */
    private List<String> implementBodyCodeList;

    /** 实施主体编码排除列表 */
    private List <String> implementBodyCodeNotList;
    /** 办理项编码 */
    private List<String> operateItemCodeList;

    /** 办理项编码排除列表 */
    private List <String> operateItemCodeNotList;
    /** 乡镇街道名称 */
    private List<String> townshipNameList;

    /** 乡镇街道名称排除列表 */
    private List <String> townshipNameNotList;
    /** 乡镇街道代码 */
    private List<String> townshipCodeList;

    /** 乡镇街道代码排除列表 */
    private List <String> townshipCodeNotList;
    /** 村居社区名称 */
    private List<String> villageNameList;

    /** 村居社区名称排除列表 */
    private List <String> villageNameNotList;
    /** 村居社区代码 */
    private List<String> villageCodeList;

    /** 村居社区代码排除列表 */
    private List <String> villageCodeNotList;
    /** 办理时间 */
    private List<String> operateTimeList;

    /** 办理时间排除列表 */
    private List <String> operateTimeNotList;
    /** 办理地点 */
    private List<String> operateSiteList;

    /** 办理地点排除列表 */
    private List <String> operateSiteNotList;
    /** 咨询方式 */
    private List<String> cousultingShowList;

    /** 咨询方式排除列表 */
    private List <String> cousultingShowNotList;
    /** 咨询电话 */
    private List<String> cousultingTelephoneShowList;

    /** 咨询电话排除列表 */
    private List <String> cousultingTelephoneShowNotList;
    /** 监督投诉方式 */
    private List<String> superviseShowList;

    /** 监督投诉方式排除列表 */
    private List <String> superviseShowNotList;
    /** 开始 排序 */
    private Integer sortStart;

    /** 结束 排序 */
    private Integer sortEnd;

    /** 增加 排序 */
    private Integer sortIncrement;

    /** 排序列表 */
    private List <Integer> sortList;

    /** 排序排除列表 */
    private List <Integer> sortNotList;

    /** 开始 事项来源(0.政务网，1.自定义) */
    private Integer sourceStart;

    /** 结束 事项来源(0.政务网，1.自定义) */
    private Integer sourceEnd;

    /** 增加 事项来源(0.政务网，1.自定义) */
    private Integer sourceIncrement;

    /** 事项来源(0.政务网，1.自定义)列表 */
    private List <Integer> sourceList;

    /** 事项来源(0.政务网，1.自定义)排除列表 */
    private List <Integer> sourceNotList;

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

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

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

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

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

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

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

    /** 开始 修改时间 */
    private String updateTimeStart;

    /** 结束 修改时间 */
    private String updateTimeEnd;

    /** 部门名称 */
    private List<String> deptNameList;

    /** 部门名称排除列表 */
    private List <String> deptNameNotList;
    /** 评价地址 */
    private List<String> evaluationUrlList;

    /** 评价地址排除列表 */
    private List <String> evaluationUrlNotList;
    /** 申请地址 */
    private List<String> netApplyUrlList;

    /** 申请地址排除列表 */
    private List <String> netApplyUrlNotList;
    /** 区域名称 */
    private List<String> areaNameList;

    /** 区域名称排除列表 */
    private List <String> areaNameNotList;
    /** 开始 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区) */
    private Integer areaLevelStart;

    /** 结束 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区) */
    private Integer areaLevelEnd;

    /** 增加 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区) */
    private Integer areaLevelIncrement;

    /** 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)列表 */
    private List <Integer> areaLevelList;

    /** 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)排除列表 */
    private List <Integer> areaLevelNotList;

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

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

    public MatterQuery(){}

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

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

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

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

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

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

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

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

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

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


    /**
     * 获取 开始 站点ID
     * @return siteIdStart
     */
    public Long getSiteIdStart(){
        return this.siteIdStart;
    }

    /**
     * 设置 开始 站点ID
     * @param siteIdStart
     */
    public void setSiteIdStart(Long siteIdStart){
        this.siteIdStart = siteIdStart;
    }

    /**
     * 获取 结束 站点ID
     * @return $siteIdEnd
     */
    public Long getSiteIdEnd(){
        return this.siteIdEnd;
    }

    /**
     * 设置 结束 站点ID
     * @param siteIdEnd
     */
    public void setSiteIdEnd(Long siteIdEnd){
        this.siteIdEnd = siteIdEnd;
    }

    /**
     * 获取 增加 站点ID
     * @return siteIdIncrement
     */
    public Long getSiteIdIncrement(){
        return this.siteIdIncrement;
    }

    /**
     * 设置 增加 站点ID
     * @param siteIdIncrement
     */
    public void setSiteIdIncrement(Long siteIdIncrement){
        this.siteIdIncrement = siteIdIncrement;
    }

    /**
     * 获取 站点ID
     * @return siteIdList
     */
    public List<Long> getSiteIdList(){
        return this.siteIdList;
    }

    /**
     * 设置 站点ID
     * @param siteIdList
     */
    public void setSiteIdList(List<Long> siteIdList){
        this.siteIdList = siteIdList;
    }

    /**
     * 获取 站点ID
     * @return siteIdNotList
     */
    public List<Long> getSiteIdNotList(){
        return this.siteIdNotList;
    }

    /**
     * 设置 站点ID
     * @param siteIdNotList
     */
    public void setSiteIdNotList(List<Long> siteIdNotList){
        this.siteIdNotList = siteIdNotList;
    }


    /**
     * 获取 从政务系统来的事项id
     * @return tidList
     */
    public List<String> getTidList(){
        return this.tidList;
    }

    /**
     * 设置 从政务系统来的事项id
     * @param tidList
     */
    public void setTidList(List<String> tidList){
        this.tidList = tidList;
    }

    /**
     * 获取 从政务系统来的事项id
     * @return tidNotList
     */
    public List<String> getTidNotList(){
        return this.tidNotList;
    }

    /**
     * 设置 从政务系统来的事项id
     * @param tidNotList
     */
    public void setTidNotList(List<String> tidNotList){
        this.tidNotList = tidNotList;
    }

    /**
     * 获取 从政务系统来的事项code
     * @return tcodeList
     */
    public List<String> getTcodeList(){
        return this.tcodeList;
    }

    /**
     * 设置 从政务系统来的事项code
     * @param tcodeList
     */
    public void setTcodeList(List<String> tcodeList){
        this.tcodeList = tcodeList;
    }

    /**
     * 获取 从政务系统来的事项code
     * @return tcodeNotList
     */
    public List<String> getTcodeNotList(){
        return this.tcodeNotList;
    }

    /**
     * 设置 从政务系统来的事项code
     * @param tcodeNotList
     */
    public void setTcodeNotList(List<String> tcodeNotList){
        this.tcodeNotList = tcodeNotList;
    }

    /**
     * 获取 从政务系统来的事项name
     * @return tnameList
     */
    public List<String> getTnameList(){
        return this.tnameList;
    }

    /**
     * 设置 从政务系统来的事项name
     * @param tnameList
     */
    public void setTnameList(List<String> tnameList){
        this.tnameList = tnameList;
    }

    /**
     * 获取 从政务系统来的事项name
     * @return tnameNotList
     */
    public List<String> getTnameNotList(){
        return this.tnameNotList;
    }

    /**
     * 设置 从政务系统来的事项name
     * @param tnameNotList
     */
    public void setTnameNotList(List<String> tnameNotList){
        this.tnameNotList = tnameNotList;
    }

    /**
     * 获取 事项名称
     * @return matterNameList
     */
    public List<String> getMatterNameList(){
        return this.matterNameList;
    }

    /**
     * 设置 事项名称
     * @param matterNameList
     */
    public void setMatterNameList(List<String> matterNameList){
        this.matterNameList = matterNameList;
    }

    /**
     * 获取 事项名称
     * @return matterNameNotList
     */
    public List<String> getMatterNameNotList(){
        return this.matterNameNotList;
    }

    /**
     * 设置 事项名称
     * @param matterNameNotList
     */
    public void setMatterNameNotList(List<String> matterNameNotList){
        this.matterNameNotList = matterNameNotList;
    }

    /**
     * 获取 英语事项名
     * @return englishNameList
     */
    public List<String> getEnglishNameList(){
        return this.englishNameList;
    }

    /**
     * 设置 英语事项名
     * @param englishNameList
     */
    public void setEnglishNameList(List<String> englishNameList){
        this.englishNameList = englishNameList;
    }

    /**
     * 获取 英语事项名
     * @return englishNameNotList
     */
    public List<String> getEnglishNameNotList(){
        return this.englishNameNotList;
    }

    /**
     * 设置 英语事项名
     * @param englishNameNotList
     */
    public void setEnglishNameNotList(List<String> englishNameNotList){
        this.englishNameNotList = englishNameNotList;
    }

    /**
     * 获取 事项编号
     * @return matterNoList
     */
    public List<String> getMatterNoList(){
        return this.matterNoList;
    }

    /**
     * 设置 事项编号
     * @param matterNoList
     */
    public void setMatterNoList(List<String> matterNoList){
        this.matterNoList = matterNoList;
    }

    /**
     * 获取 事项编号
     * @return matterNoNotList
     */
    public List<String> getMatterNoNotList(){
        return this.matterNoNotList;
    }

    /**
     * 设置 事项编号
     * @param matterNoNotList
     */
    public void setMatterNoNotList(List<String> matterNoNotList){
        this.matterNoNotList = matterNoNotList;
    }

    /**
     * 获取 区域编码
     * @return areaCodeList
     */
    public List<String> getAreaCodeList(){
        return this.areaCodeList;
    }

    /**
     * 设置 区域编码
     * @param areaCodeList
     */
    public void setAreaCodeList(List<String> areaCodeList){
        this.areaCodeList = areaCodeList;
    }

    /**
     * 获取 区域编码
     * @return areaCodeNotList
     */
    public List<String> getAreaCodeNotList(){
        return this.areaCodeNotList;
    }

    /**
     * 设置 区域编码
     * @param areaCodeNotList
     */
    public void setAreaCodeNotList(List<String> areaCodeNotList){
        this.areaCodeNotList = areaCodeNotList;
    }

    /**
     * 获取 部门编号
     * @return deptCodeList
     */
    public List<String> getDeptCodeList(){
        return this.deptCodeList;
    }

    /**
     * 设置 部门编号
     * @param deptCodeList
     */
    public void setDeptCodeList(List<String> deptCodeList){
        this.deptCodeList = deptCodeList;
    }

    /**
     * 获取 部门编号
     * @return deptCodeNotList
     */
    public List<String> getDeptCodeNotList(){
        return this.deptCodeNotList;
    }

    /**
     * 设置 部门编号
     * @param deptCodeNotList
     */
    public void setDeptCodeNotList(List<String> deptCodeNotList){
        this.deptCodeNotList = deptCodeNotList;
    }

    /**
     * 获取 行政权力编号
     * @return powerCodeList
     */
    public List<String> getPowerCodeList(){
        return this.powerCodeList;
    }

    /**
     * 设置 行政权力编号
     * @param powerCodeList
     */
    public void setPowerCodeList(List<String> powerCodeList){
        this.powerCodeList = powerCodeList;
    }

    /**
     * 获取 行政权力编号
     * @return powerCodeNotList
     */
    public List<String> getPowerCodeNotList(){
        return this.powerCodeNotList;
    }

    /**
     * 设置 行政权力编号
     * @param powerCodeNotList
     */
    public void setPowerCodeNotList(List<String> powerCodeNotList){
        this.powerCodeNotList = powerCodeNotList;
    }

    /**
     * 获取 主题编号
     * @return themeCodeList
     */
    public List<String> getThemeCodeList(){
        return this.themeCodeList;
    }

    /**
     * 设置 主题编号
     * @param themeCodeList
     */
    public void setThemeCodeList(List<String> themeCodeList){
        this.themeCodeList = themeCodeList;
    }

    /**
     * 获取 主题编号
     * @return themeCodeNotList
     */
    public List<String> getThemeCodeNotList(){
        return this.themeCodeNotList;
    }

    /**
     * 设置 主题编号
     * @param themeCodeNotList
     */
    public void setThemeCodeNotList(List<String> themeCodeNotList){
        this.themeCodeNotList = themeCodeNotList;
    }

    /**
     * 获取 服务类型编号
     * @return usertypeCodeList
     */
    public List<String> getUsertypeCodeList(){
        return this.usertypeCodeList;
    }

    /**
     * 设置 服务类型编号
     * @param usertypeCodeList
     */
    public void setUsertypeCodeList(List<String> usertypeCodeList){
        this.usertypeCodeList = usertypeCodeList;
    }

    /**
     * 获取 服务类型编号
     * @return usertypeCodeNotList
     */
    public List<String> getUsertypeCodeNotList(){
        return this.usertypeCodeNotList;
    }

    /**
     * 设置 服务类型编号
     * @param usertypeCodeNotList
     */
    public void setUsertypeCodeNotList(List<String> usertypeCodeNotList){
        this.usertypeCodeNotList = usertypeCodeNotList;
    }

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

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

    /**
     * 获取 事项组名
     * @return groupNameNotList
     */
    public List<String> getGroupNameNotList(){
        return this.groupNameNotList;
    }

    /**
     * 设置 事项组名
     * @param groupNameNotList
     */
    public void setGroupNameNotList(List<String> groupNameNotList){
        this.groupNameNotList = groupNameNotList;
    }

    /**
     * 获取 事项详情链接
     * @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;
    }

    /**
     * 获取 是否获取事项详情
     * @return haveGetMatterInfoList
     */
    public List<String> getHaveGetMatterInfoList(){
        return this.haveGetMatterInfoList;
    }

    /**
     * 设置 是否获取事项详情
     * @param haveGetMatterInfoList
     */
    public void setHaveGetMatterInfoList(List<String> haveGetMatterInfoList){
        this.haveGetMatterInfoList = haveGetMatterInfoList;
    }

    /**
     * 获取 是否获取事项详情
     * @return haveGetMatterInfoNotList
     */
    public List<String> getHaveGetMatterInfoNotList(){
        return this.haveGetMatterInfoNotList;
    }

    /**
     * 设置 是否获取事项详情
     * @param haveGetMatterInfoNotList
     */
    public void setHaveGetMatterInfoNotList(List<String> haveGetMatterInfoNotList){
        this.haveGetMatterInfoNotList = haveGetMatterInfoNotList;
    }

    /**
     * 获取 所属部门
     * @return belongDeptList
     */
    public List<String> getBelongDeptList(){
        return this.belongDeptList;
    }

    /**
     * 设置 所属部门
     * @param belongDeptList
     */
    public void setBelongDeptList(List<String> belongDeptList){
        this.belongDeptList = belongDeptList;
    }

    /**
     * 获取 所属部门
     * @return belongDeptNotList
     */
    public List<String> getBelongDeptNotList(){
        return this.belongDeptNotList;
    }

    /**
     * 设置 所属部门
     * @param belongDeptNotList
     */
    public void setBelongDeptNotList(List<String> belongDeptNotList){
        this.belongDeptNotList = belongDeptNotList;
    }

    /**
     * 获取 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
     * @return appoveObjectShowList
     */
    public List<String> getAppoveObjectShowList(){
        return this.appoveObjectShowList;
    }

    /**
     * 设置 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
     * @param appoveObjectShowList
     */
    public void setAppoveObjectShowList(List<String> appoveObjectShowList){
        this.appoveObjectShowList = appoveObjectShowList;
    }

    /**
     * 获取 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
     * @return appoveObjectShowNotList
     */
    public List<String> getAppoveObjectShowNotList(){
        return this.appoveObjectShowNotList;
    }

    /**
     * 设置 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
     * @param appoveObjectShowNotList
     */
    public void setAppoveObjectShowNotList(List<String> appoveObjectShowNotList){
        this.appoveObjectShowNotList = appoveObjectShowNotList;
    }

    /**
     * 获取 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
     * @return operatScopeShowList
     */
    public List<String> getOperatScopeShowList(){
        return this.operatScopeShowList;
    }

    /**
     * 设置 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
     * @param operatScopeShowList
     */
    public void setOperatScopeShowList(List<String> operatScopeShowList){
        this.operatScopeShowList = operatScopeShowList;
    }

    /**
     * 获取 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
     * @return operatScopeShowNotList
     */
    public List<String> getOperatScopeShowNotList(){
        return this.operatScopeShowNotList;
    }

    /**
     * 设置 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
     * @param operatScopeShowNotList
     */
    public void setOperatScopeShowNotList(List<String> operatScopeShowNotList){
        this.operatScopeShowNotList = operatScopeShowNotList;
    }

    /**
     * 获取 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
     * @return appoveTimeLimitShowList
     */
    public List<String> getAppoveTimeLimitShowList(){
        return this.appoveTimeLimitShowList;
    }

    /**
     * 设置 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
     * @param appoveTimeLimitShowList
     */
    public void setAppoveTimeLimitShowList(List<String> appoveTimeLimitShowList){
        this.appoveTimeLimitShowList = appoveTimeLimitShowList;
    }

    /**
     * 获取 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
     * @return appoveTimeLimitShowNotList
     */
    public List<String> getAppoveTimeLimitShowNotList(){
        return this.appoveTimeLimitShowNotList;
    }

    /**
     * 设置 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
     * @param appoveTimeLimitShowNotList
     */
    public void setAppoveTimeLimitShowNotList(List<String> appoveTimeLimitShowNotList){
        this.appoveTimeLimitShowNotList = appoveTimeLimitShowNotList;
    }

    /**
     * 获取 办理形式（窗口办理.窗口办理，网上办理.网上办理）
     * @return handleTypeList
     */
    public List<String> getHandleTypeList(){
        return this.handleTypeList;
    }

    /**
     * 设置 办理形式（窗口办理.窗口办理，网上办理.网上办理）
     * @param handleTypeList
     */
    public void setHandleTypeList(List<String> handleTypeList){
        this.handleTypeList = handleTypeList;
    }

    /**
     * 获取 办理形式（窗口办理.窗口办理，网上办理.网上办理）
     * @return handleTypeNotList
     */
    public List<String> getHandleTypeNotList(){
        return this.handleTypeNotList;
    }

    /**
     * 设置 办理形式（窗口办理.窗口办理，网上办理.网上办理）
     * @param handleTypeNotList
     */
    public void setHandleTypeNotList(List<String> handleTypeNotList){
        this.handleTypeNotList = handleTypeNotList;
    }

    /**
     * 获取 法定办结时限
     * @return legalTimeLimitShowList
     */
    public List<String> getLegalTimeLimitShowList(){
        return this.legalTimeLimitShowList;
    }

    /**
     * 设置 法定办结时限
     * @param legalTimeLimitShowList
     */
    public void setLegalTimeLimitShowList(List<String> legalTimeLimitShowList){
        this.legalTimeLimitShowList = legalTimeLimitShowList;
    }

    /**
     * 获取 法定办结时限
     * @return legalTimeLimitShowNotList
     */
    public List<String> getLegalTimeLimitShowNotList(){
        return this.legalTimeLimitShowNotList;
    }

    /**
     * 设置 法定办结时限
     * @param legalTimeLimitShowNotList
     */
    public void setLegalTimeLimitShowNotList(List<String> legalTimeLimitShowNotList){
        this.legalTimeLimitShowNotList = legalTimeLimitShowNotList;
    }

    /**
     * 获取 法定时限办结说明
     * @return legalEndExplainList
     */
    public List<String> getLegalEndExplainList(){
        return this.legalEndExplainList;
    }

    /**
     * 设置 法定时限办结说明
     * @param legalEndExplainList
     */
    public void setLegalEndExplainList(List<String> legalEndExplainList){
        this.legalEndExplainList = legalEndExplainList;
    }

    /**
     * 获取 法定时限办结说明
     * @return legalEndExplainNotList
     */
    public List<String> getLegalEndExplainNotList(){
        return this.legalEndExplainNotList;
    }

    /**
     * 设置 法定时限办结说明
     * @param legalEndExplainNotList
     */
    public void setLegalEndExplainNotList(List<String> legalEndExplainNotList){
        this.legalEndExplainNotList = legalEndExplainNotList;
    }

    /**
     * 获取 承诺办结时限
     * @return promiseTimeLimitShowList
     */
    public List<String> getPromiseTimeLimitShowList(){
        return this.promiseTimeLimitShowList;
    }

    /**
     * 设置 承诺办结时限
     * @param promiseTimeLimitShowList
     */
    public void setPromiseTimeLimitShowList(List<String> promiseTimeLimitShowList){
        this.promiseTimeLimitShowList = promiseTimeLimitShowList;
    }

    /**
     * 获取 承诺办结时限
     * @return promiseTimeLimitShowNotList
     */
    public List<String> getPromiseTimeLimitShowNotList(){
        return this.promiseTimeLimitShowNotList;
    }

    /**
     * 设置 承诺办结时限
     * @param promiseTimeLimitShowNotList
     */
    public void setPromiseTimeLimitShowNotList(List<String> promiseTimeLimitShowNotList){
        this.promiseTimeLimitShowNotList = promiseTimeLimitShowNotList;
    }

    /**
     * 获取 承诺时限办结说明
     * @return promiseEndExplainList
     */
    public List<String> getPromiseEndExplainList(){
        return this.promiseEndExplainList;
    }

    /**
     * 设置 承诺时限办结说明
     * @param promiseEndExplainList
     */
    public void setPromiseEndExplainList(List<String> promiseEndExplainList){
        this.promiseEndExplainList = promiseEndExplainList;
    }

    /**
     * 获取 承诺时限办结说明
     * @return promiseEndExplainNotList
     */
    public List<String> getPromiseEndExplainNotList(){
        return this.promiseEndExplainNotList;
    }

    /**
     * 设置 承诺时限办结说明
     * @param promiseEndExplainNotList
     */
    public void setPromiseEndExplainNotList(List<String> promiseEndExplainNotList){
        this.promiseEndExplainNotList = promiseEndExplainNotList;
    }

    /**
     * 获取 是否收费（否.否，是.是）
     * @return isChargesShowList
     */
    public List<String> getIsChargesShowList(){
        return this.isChargesShowList;
    }

    /**
     * 设置 是否收费（否.否，是.是）
     * @param isChargesShowList
     */
    public void setIsChargesShowList(List<String> isChargesShowList){
        this.isChargesShowList = isChargesShowList;
    }

    /**
     * 获取 是否收费（否.否，是.是）
     * @return isChargesShowNotList
     */
    public List<String> getIsChargesShowNotList(){
        return this.isChargesShowNotList;
    }

    /**
     * 设置 是否收费（否.否，是.是）
     * @param isChargesShowNotList
     */
    public void setIsChargesShowNotList(List<String> isChargesShowNotList){
        this.isChargesShowNotList = isChargesShowNotList;
    }

    /**
     * 获取 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
     * @return certificationLevelsShowList
     */
    public List<String> getCertificationLevelsShowList(){
        return this.certificationLevelsShowList;
    }

    /**
     * 设置 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
     * @param certificationLevelsShowList
     */
    public void setCertificationLevelsShowList(List<String> certificationLevelsShowList){
        this.certificationLevelsShowList = certificationLevelsShowList;
    }

    /**
     * 获取 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
     * @return certificationLevelsShowNotList
     */
    public List<String> getCertificationLevelsShowNotList(){
        return this.certificationLevelsShowNotList;
    }

    /**
     * 设置 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
     * @param certificationLevelsShowNotList
     */
    public void setCertificationLevelsShowNotList(List<String> certificationLevelsShowNotList){
        this.certificationLevelsShowNotList = certificationLevelsShowNotList;
    }

    /**
     * 获取 开始 计划生效日期
     * @return planTakeTimeStart
     */
    public String getPlanTakeTimeStart(){
        return this.planTakeTimeStart;
    }

    /**
     * 设置 开始 计划生效日期
     * @param planTakeTimeStart
     */
    public void setPlanTakeTimeStart(String planTakeTimeStart){
        this.planTakeTimeStart = planTakeTimeStart;
    }

    /**
     * 获取 结束 计划生效日期
     * @return planTakeTimeEnd
     */
    public String getPlanTakeTimeEnd(){
        return this.planTakeTimeEnd;
    }

    /**
     * 设置 结束 计划生效日期
     * @param planTakeTimeEnd
     */
    public void setPlanTakeTimeEnd(String planTakeTimeEnd){
        this.planTakeTimeEnd = planTakeTimeEnd;
    }

    /**
     * 获取 开始 承诺生效日期
     * @return promiseTakeTimeStart
     */
    public String getPromiseTakeTimeStart(){
        return this.promiseTakeTimeStart;
    }

    /**
     * 设置 开始 承诺生效日期
     * @param promiseTakeTimeStart
     */
    public void setPromiseTakeTimeStart(String promiseTakeTimeStart){
        this.promiseTakeTimeStart = promiseTakeTimeStart;
    }

    /**
     * 获取 结束 承诺生效日期
     * @return promiseTakeTimeEnd
     */
    public String getPromiseTakeTimeEnd(){
        return this.promiseTakeTimeEnd;
    }

    /**
     * 设置 结束 承诺生效日期
     * @param promiseTakeTimeEnd
     */
    public void setPromiseTakeTimeEnd(String promiseTakeTimeEnd){
        this.promiseTakeTimeEnd = promiseTakeTimeEnd;
    }

    /**
     * 获取 特别程序
     * @return specialProcedureList
     */
    public List<String> getSpecialProcedureList(){
        return this.specialProcedureList;
    }

    /**
     * 设置 特别程序
     * @param specialProcedureList
     */
    public void setSpecialProcedureList(List<String> specialProcedureList){
        this.specialProcedureList = specialProcedureList;
    }

    /**
     * 获取 特别程序
     * @return specialProcedureNotList
     */
    public List<String> getSpecialProcedureNotList(){
        return this.specialProcedureNotList;
    }

    /**
     * 设置 特别程序
     * @param specialProcedureNotList
     */
    public void setSpecialProcedureNotList(List<String> specialProcedureNotList){
        this.specialProcedureNotList = specialProcedureNotList;
    }

    /**
     * 获取 开始 窗口到现场次数
     * @return windowToTheSceneNumStart
     */
    public Integer getWindowToTheSceneNumStart(){
        return this.windowToTheSceneNumStart;
    }

    /**
     * 设置 开始 窗口到现场次数
     * @param windowToTheSceneNumStart
     */
    public void setWindowToTheSceneNumStart(Integer windowToTheSceneNumStart){
        this.windowToTheSceneNumStart = windowToTheSceneNumStart;
    }

    /**
     * 获取 结束 窗口到现场次数
     * @return $windowToTheSceneNumEnd
     */
    public Integer getWindowToTheSceneNumEnd(){
        return this.windowToTheSceneNumEnd;
    }

    /**
     * 设置 结束 窗口到现场次数
     * @param windowToTheSceneNumEnd
     */
    public void setWindowToTheSceneNumEnd(Integer windowToTheSceneNumEnd){
        this.windowToTheSceneNumEnd = windowToTheSceneNumEnd;
    }

    /**
     * 获取 增加 窗口到现场次数
     * @return windowToTheSceneNumIncrement
     */
    public Integer getWindowToTheSceneNumIncrement(){
        return this.windowToTheSceneNumIncrement;
    }

    /**
     * 设置 增加 窗口到现场次数
     * @param windowToTheSceneNumIncrement
     */
    public void setWindowToTheSceneNumIncrement(Integer windowToTheSceneNumIncrement){
        this.windowToTheSceneNumIncrement = windowToTheSceneNumIncrement;
    }

    /**
     * 获取 窗口到现场次数
     * @return windowToTheSceneNumList
     */
    public List<Integer> getWindowToTheSceneNumList(){
        return this.windowToTheSceneNumList;
    }

    /**
     * 设置 窗口到现场次数
     * @param windowToTheSceneNumList
     */
    public void setWindowToTheSceneNumList(List<Integer> windowToTheSceneNumList){
        this.windowToTheSceneNumList = windowToTheSceneNumList;
    }

    /**
     * 获取 窗口到现场次数
     * @return windowToTheSceneNumNotList
     */
    public List<Integer> getWindowToTheSceneNumNotList(){
        return this.windowToTheSceneNumNotList;
    }

    /**
     * 设置 窗口到现场次数
     * @param windowToTheSceneNumNotList
     */
    public void setWindowToTheSceneNumNotList(List<Integer> windowToTheSceneNumNotList){
        this.windowToTheSceneNumNotList = windowToTheSceneNumNotList;
    }


    /**
     * 获取 是否网上预约,窗口办理选（否.否，是.是）
     * @return isOnlineSubscribeShowList
     */
    public List<String> getIsOnlineSubscribeShowList(){
        return this.isOnlineSubscribeShowList;
    }

    /**
     * 设置 是否网上预约,窗口办理选（否.否，是.是）
     * @param isOnlineSubscribeShowList
     */
    public void setIsOnlineSubscribeShowList(List<String> isOnlineSubscribeShowList){
        this.isOnlineSubscribeShowList = isOnlineSubscribeShowList;
    }

    /**
     * 获取 是否网上预约,窗口办理选（否.否，是.是）
     * @return isOnlineSubscribeShowNotList
     */
    public List<String> getIsOnlineSubscribeShowNotList(){
        return this.isOnlineSubscribeShowNotList;
    }

    /**
     * 设置 是否网上预约,窗口办理选（否.否，是.是）
     * @param isOnlineSubscribeShowNotList
     */
    public void setIsOnlineSubscribeShowNotList(List<String> isOnlineSubscribeShowNotList){
        this.isOnlineSubscribeShowNotList = isOnlineSubscribeShowNotList;
    }

    /**
     * 获取 物流快递,窗口办理选（否.否，是.是）
     * @return isExpressTakeShowList
     */
    public List<String> getIsExpressTakeShowList(){
        return this.isExpressTakeShowList;
    }

    /**
     * 设置 物流快递,窗口办理选（否.否，是.是）
     * @param isExpressTakeShowList
     */
    public void setIsExpressTakeShowList(List<String> isExpressTakeShowList){
        this.isExpressTakeShowList = isExpressTakeShowList;
    }

    /**
     * 获取 物流快递,窗口办理选（否.否，是.是）
     * @return isExpressTakeShowNotList
     */
    public List<String> getIsExpressTakeShowNotList(){
        return this.isExpressTakeShowNotList;
    }

    /**
     * 设置 物流快递,窗口办理选（否.否，是.是）
     * @param isExpressTakeShowNotList
     */
    public void setIsExpressTakeShowNotList(List<String> isExpressTakeShowNotList){
        this.isExpressTakeShowNotList = isExpressTakeShowNotList;
    }

    /**
     * 获取 是否支持全省范围就近取件（否.否，是.是）
     * @return isProvinceAcquisitionShowList
     */
    public List<String> getIsProvinceAcquisitionShowList(){
        return this.isProvinceAcquisitionShowList;
    }

    /**
     * 设置 是否支持全省范围就近取件（否.否，是.是）
     * @param isProvinceAcquisitionShowList
     */
    public void setIsProvinceAcquisitionShowList(List<String> isProvinceAcquisitionShowList){
        this.isProvinceAcquisitionShowList = isProvinceAcquisitionShowList;
    }

    /**
     * 获取 是否支持全省范围就近取件（否.否，是.是）
     * @return isProvinceAcquisitionShowNotList
     */
    public List<String> getIsProvinceAcquisitionShowNotList(){
        return this.isProvinceAcquisitionShowNotList;
    }

    /**
     * 设置 是否支持全省范围就近取件（否.否，是.是）
     * @param isProvinceAcquisitionShowNotList
     */
    public void setIsProvinceAcquisitionShowNotList(List<String> isProvinceAcquisitionShowNotList){
        this.isProvinceAcquisitionShowNotList = isProvinceAcquisitionShowNotList;
    }

    /**
     * 获取 是否支持全省范围就近办理（否.否，是.是）
     * @return isApplyProvinceShowList
     */
    public List<String> getIsApplyProvinceShowList(){
        return this.isApplyProvinceShowList;
    }

    /**
     * 设置 是否支持全省范围就近办理（否.否，是.是）
     * @param isApplyProvinceShowList
     */
    public void setIsApplyProvinceShowList(List<String> isApplyProvinceShowList){
        this.isApplyProvinceShowList = isApplyProvinceShowList;
    }

    /**
     * 获取 是否支持全省范围就近办理（否.否，是.是）
     * @return isApplyProvinceShowNotList
     */
    public List<String> getIsApplyProvinceShowNotList(){
        return this.isApplyProvinceShowNotList;
    }

    /**
     * 设置 是否支持全省范围就近办理（否.否，是.是）
     * @param isApplyProvinceShowNotList
     */
    public void setIsApplyProvinceShowNotList(List<String> isApplyProvinceShowNotList){
        this.isApplyProvinceShowNotList = isApplyProvinceShowNotList;
    }

    /**
     * 获取 必须到现场原因
     * @return mustSceneExplainList
     */
    public List<String> getMustSceneExplainList(){
        return this.mustSceneExplainList;
    }

    /**
     * 设置 必须到现场原因
     * @param mustSceneExplainList
     */
    public void setMustSceneExplainList(List<String> mustSceneExplainList){
        this.mustSceneExplainList = mustSceneExplainList;
    }

    /**
     * 获取 必须到现场原因
     * @return mustSceneExplainNotList
     */
    public List<String> getMustSceneExplainNotList(){
        return this.mustSceneExplainNotList;
    }

    /**
     * 设置 必须到现场原因
     * @param mustSceneExplainNotList
     */
    public void setMustSceneExplainNotList(List<String> mustSceneExplainNotList){
        this.mustSceneExplainNotList = mustSceneExplainNotList;
    }

    /**
     * 获取 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
     * @return onlineTypeList
     */
    public List<String> getOnlineTypeList(){
        return this.onlineTypeList;
    }

    /**
     * 设置 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
     * @param onlineTypeList
     */
    public void setOnlineTypeList(List<String> onlineTypeList){
        this.onlineTypeList = onlineTypeList;
    }

    /**
     * 获取 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
     * @return onlineTypeNotList
     */
    public List<String> getOnlineTypeNotList(){
        return this.onlineTypeNotList;
    }

    /**
     * 设置 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
     * @param onlineTypeNotList
     */
    public void setOnlineTypeNotList(List<String> onlineTypeNotList){
        this.onlineTypeNotList = onlineTypeNotList;
    }

    /**
     * 获取 开始 网办到现场次数
     * @return onlineToTheSceneNumStart
     */
    public Integer getOnlineToTheSceneNumStart(){
        return this.onlineToTheSceneNumStart;
    }

    /**
     * 设置 开始 网办到现场次数
     * @param onlineToTheSceneNumStart
     */
    public void setOnlineToTheSceneNumStart(Integer onlineToTheSceneNumStart){
        this.onlineToTheSceneNumStart = onlineToTheSceneNumStart;
    }

    /**
     * 获取 结束 网办到现场次数
     * @return $onlineToTheSceneNumEnd
     */
    public Integer getOnlineToTheSceneNumEnd(){
        return this.onlineToTheSceneNumEnd;
    }

    /**
     * 设置 结束 网办到现场次数
     * @param onlineToTheSceneNumEnd
     */
    public void setOnlineToTheSceneNumEnd(Integer onlineToTheSceneNumEnd){
        this.onlineToTheSceneNumEnd = onlineToTheSceneNumEnd;
    }

    /**
     * 获取 增加 网办到现场次数
     * @return onlineToTheSceneNumIncrement
     */
    public Integer getOnlineToTheSceneNumIncrement(){
        return this.onlineToTheSceneNumIncrement;
    }

    /**
     * 设置 增加 网办到现场次数
     * @param onlineToTheSceneNumIncrement
     */
    public void setOnlineToTheSceneNumIncrement(Integer onlineToTheSceneNumIncrement){
        this.onlineToTheSceneNumIncrement = onlineToTheSceneNumIncrement;
    }

    /**
     * 获取 网办到现场次数
     * @return onlineToTheSceneNumList
     */
    public List<Integer> getOnlineToTheSceneNumList(){
        return this.onlineToTheSceneNumList;
    }

    /**
     * 设置 网办到现场次数
     * @param onlineToTheSceneNumList
     */
    public void setOnlineToTheSceneNumList(List<Integer> onlineToTheSceneNumList){
        this.onlineToTheSceneNumList = onlineToTheSceneNumList;
    }

    /**
     * 获取 网办到现场次数
     * @return onlineToTheSceneNumNotList
     */
    public List<Integer> getOnlineToTheSceneNumNotList(){
        return this.onlineToTheSceneNumNotList;
    }

    /**
     * 设置 网办到现场次数
     * @param onlineToTheSceneNumNotList
     */
    public void setOnlineToTheSceneNumNotList(List<Integer> onlineToTheSceneNumNotList){
        this.onlineToTheSceneNumNotList = onlineToTheSceneNumNotList;
    }


    /**
     * 获取 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
     * @return onlineOperatDeepList
     */
    public List<String> getOnlineOperatDeepList(){
        return this.onlineOperatDeepList;
    }

    /**
     * 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
     * @param onlineOperatDeepList
     */
    public void setOnlineOperatDeepList(List<String> onlineOperatDeepList){
        this.onlineOperatDeepList = onlineOperatDeepList;
    }

    /**
     * 获取 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
     * @return onlineOperatDeepNotList
     */
    public List<String> getOnlineOperatDeepNotList(){
        return this.onlineOperatDeepNotList;
    }

    /**
     * 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
     * @param onlineOperatDeepNotList
     */
    public void setOnlineOperatDeepNotList(List<String> onlineOperatDeepNotList){
        this.onlineOperatDeepNotList = onlineOperatDeepNotList;
    }

    /**
     * 获取 物流快递，网上办理选（否.否，是.是）
     * @return isExpressTakeOnlineShowList
     */
    public List<String> getIsExpressTakeOnlineShowList(){
        return this.isExpressTakeOnlineShowList;
    }

    /**
     * 设置 物流快递，网上办理选（否.否，是.是）
     * @param isExpressTakeOnlineShowList
     */
    public void setIsExpressTakeOnlineShowList(List<String> isExpressTakeOnlineShowList){
        this.isExpressTakeOnlineShowList = isExpressTakeOnlineShowList;
    }

    /**
     * 获取 物流快递，网上办理选（否.否，是.是）
     * @return isExpressTakeOnlineShowNotList
     */
    public List<String> getIsExpressTakeOnlineShowNotList(){
        return this.isExpressTakeOnlineShowNotList;
    }

    /**
     * 设置 物流快递，网上办理选（否.否，是.是）
     * @param isExpressTakeOnlineShowNotList
     */
    public void setIsExpressTakeOnlineShowNotList(List<String> isExpressTakeOnlineShowNotList){
        this.isExpressTakeOnlineShowNotList = isExpressTakeOnlineShowNotList;
    }

    /**
     * 获取 是否支持上门收取申请（否.否，是.是）
     * @return isDoorTakeShowList
     */
    public List<String> getIsDoorTakeShowList(){
        return this.isDoorTakeShowList;
    }

    /**
     * 设置 是否支持上门收取申请（否.否，是.是）
     * @param isDoorTakeShowList
     */
    public void setIsDoorTakeShowList(List<String> isDoorTakeShowList){
        this.isDoorTakeShowList = isDoorTakeShowList;
    }

    /**
     * 获取 是否支持上门收取申请（否.否，是.是）
     * @return isDoorTakeShowNotList
     */
    public List<String> getIsDoorTakeShowNotList(){
        return this.isDoorTakeShowNotList;
    }

    /**
     * 设置 是否支持上门收取申请（否.否，是.是）
     * @param isDoorTakeShowNotList
     */
    public void setIsDoorTakeShowNotList(List<String> isDoorTakeShowNotList){
        this.isDoorTakeShowNotList = isDoorTakeShowNotList;
    }

    /**
     * 获取 网上必须到现场原因
     * @return onlineMustSceneExplainList
     */
    public List<String> getOnlineMustSceneExplainList(){
        return this.onlineMustSceneExplainList;
    }

    /**
     * 设置 网上必须到现场原因
     * @param onlineMustSceneExplainList
     */
    public void setOnlineMustSceneExplainList(List<String> onlineMustSceneExplainList){
        this.onlineMustSceneExplainList = onlineMustSceneExplainList;
    }

    /**
     * 获取 网上必须到现场原因
     * @return onlineMustSceneExplainNotList
     */
    public List<String> getOnlineMustSceneExplainNotList(){
        return this.onlineMustSceneExplainNotList;
    }

    /**
     * 设置 网上必须到现场原因
     * @param onlineMustSceneExplainNotList
     */
    public void setOnlineMustSceneExplainNotList(List<String> onlineMustSceneExplainNotList){
        this.onlineMustSceneExplainNotList = onlineMustSceneExplainNotList;
    }

    /**
     * 获取 实施主体
     * @return performDeptTypeList
     */
    public List<String> getPerformDeptTypeList(){
        return this.performDeptTypeList;
    }

    /**
     * 设置 实施主体
     * @param performDeptTypeList
     */
    public void setPerformDeptTypeList(List<String> performDeptTypeList){
        this.performDeptTypeList = performDeptTypeList;
    }

    /**
     * 获取 实施主体
     * @return performDeptTypeNotList
     */
    public List<String> getPerformDeptTypeNotList(){
        return this.performDeptTypeNotList;
    }

    /**
     * 设置 实施主体
     * @param performDeptTypeNotList
     */
    public void setPerformDeptTypeNotList(List<String> performDeptTypeNotList){
        this.performDeptTypeNotList = performDeptTypeNotList;
    }

    /**
     * 获取 事项版本
     * @return matterEditionList
     */
    public List<String> getMatterEditionList(){
        return this.matterEditionList;
    }

    /**
     * 设置 事项版本
     * @param matterEditionList
     */
    public void setMatterEditionList(List<String> matterEditionList){
        this.matterEditionList = matterEditionList;
    }

    /**
     * 获取 事项版本
     * @return matterEditionNotList
     */
    public List<String> getMatterEditionNotList(){
        return this.matterEditionNotList;
    }

    /**
     * 设置 事项版本
     * @param matterEditionNotList
     */
    public void setMatterEditionNotList(List<String> matterEditionNotList){
        this.matterEditionNotList = matterEditionNotList;
    }

    /**
     * 获取 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
     * @return eventTypeShowList
     */
    public List<String> getEventTypeShowList(){
        return this.eventTypeShowList;
    }

    /**
     * 设置 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
     * @param eventTypeShowList
     */
    public void setEventTypeShowList(List<String> eventTypeShowList){
        this.eventTypeShowList = eventTypeShowList;
    }

    /**
     * 获取 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
     * @return eventTypeShowNotList
     */
    public List<String> getEventTypeShowNotList(){
        return this.eventTypeShowNotList;
    }

    /**
     * 设置 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
     * @param eventTypeShowNotList
     */
    public void setEventTypeShowNotList(List<String> eventTypeShowNotList){
        this.eventTypeShowNotList = eventTypeShowNotList;
    }

    /**
     * 获取 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
     * @return performHierarchyShowList
     */
    public List<String> getPerformHierarchyShowList(){
        return this.performHierarchyShowList;
    }

    /**
     * 设置 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
     * @param performHierarchyShowList
     */
    public void setPerformHierarchyShowList(List<String> performHierarchyShowList){
        this.performHierarchyShowList = performHierarchyShowList;
    }

    /**
     * 获取 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
     * @return performHierarchyShowNotList
     */
    public List<String> getPerformHierarchyShowNotList(){
        return this.performHierarchyShowNotList;
    }

    /**
     * 设置 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
     * @param performHierarchyShowNotList
     */
    public void setPerformHierarchyShowNotList(List<String> performHierarchyShowNotList){
        this.performHierarchyShowNotList = performHierarchyShowNotList;
    }

    /**
     * 获取 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
     * @return powerSourceShowList
     */
    public List<String> getPowerSourceShowList(){
        return this.powerSourceShowList;
    }

    /**
     * 设置 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
     * @param powerSourceShowList
     */
    public void setPowerSourceShowList(List<String> powerSourceShowList){
        this.powerSourceShowList = powerSourceShowList;
    }

    /**
     * 获取 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
     * @return powerSourceShowNotList
     */
    public List<String> getPowerSourceShowNotList(){
        return this.powerSourceShowNotList;
    }

    /**
     * 设置 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
     * @param powerSourceShowNotList
     */
    public void setPowerSourceShowNotList(List<String> powerSourceShowNotList){
        this.powerSourceShowNotList = powerSourceShowNotList;
    }

    /**
     * 获取 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
     * @return performDeptTypeShowList
     */
    public List<String> getPerformDeptTypeShowList(){
        return this.performDeptTypeShowList;
    }

    /**
     * 设置 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
     * @param performDeptTypeShowList
     */
    public void setPerformDeptTypeShowList(List<String> performDeptTypeShowList){
        this.performDeptTypeShowList = performDeptTypeShowList;
    }

    /**
     * 获取 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
     * @return performDeptTypeShowNotList
     */
    public List<String> getPerformDeptTypeShowNotList(){
        return this.performDeptTypeShowNotList;
    }

    /**
     * 设置 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
     * @param performDeptTypeShowNotList
     */
    public void setPerformDeptTypeShowNotList(List<String> performDeptTypeShowNotList){
        this.performDeptTypeShowNotList = performDeptTypeShowNotList;
    }

    /**
     * 获取 是否进驻中心（否.否，是.是）
     * @return goveServiceCenterShowList
     */
    public List<String> getGoveServiceCenterShowList(){
        return this.goveServiceCenterShowList;
    }

    /**
     * 设置 是否进驻中心（否.否，是.是）
     * @param goveServiceCenterShowList
     */
    public void setGoveServiceCenterShowList(List<String> goveServiceCenterShowList){
        this.goveServiceCenterShowList = goveServiceCenterShowList;
    }

    /**
     * 获取 是否进驻中心（否.否，是.是）
     * @return goveServiceCenterShowNotList
     */
    public List<String> getGoveServiceCenterShowNotList(){
        return this.goveServiceCenterShowNotList;
    }

    /**
     * 设置 是否进驻中心（否.否，是.是）
     * @param goveServiceCenterShowNotList
     */
    public void setGoveServiceCenterShowNotList(List<String> goveServiceCenterShowNotList){
        this.goveServiceCenterShowNotList = goveServiceCenterShowNotList;
    }

    /**
     * 获取 是否纳入便民服务中心（否.否，是.是）
     * @return isConvenientCenterShowList
     */
    public List<String> getIsConvenientCenterShowList(){
        return this.isConvenientCenterShowList;
    }

    /**
     * 设置 是否纳入便民服务中心（否.否，是.是）
     * @param isConvenientCenterShowList
     */
    public void setIsConvenientCenterShowList(List<String> isConvenientCenterShowList){
        this.isConvenientCenterShowList = isConvenientCenterShowList;
    }

    /**
     * 获取 是否纳入便民服务中心（否.否，是.是）
     * @return isConvenientCenterShowNotList
     */
    public List<String> getIsConvenientCenterShowNotList(){
        return this.isConvenientCenterShowNotList;
    }

    /**
     * 设置 是否纳入便民服务中心（否.否，是.是）
     * @param isConvenientCenterShowNotList
     */
    public void setIsConvenientCenterShowNotList(List<String> isConvenientCenterShowNotList){
        this.isConvenientCenterShowNotList = isConvenientCenterShowNotList;
    }

    /**
     * 获取 自助终端办理 （否.否，是.是）
     * @return terminalHandleList
     */
    public List<String> getTerminalHandleList(){
        return this.terminalHandleList;
    }

    /**
     * 设置 自助终端办理 （否.否，是.是）
     * @param terminalHandleList
     */
    public void setTerminalHandleList(List<String> terminalHandleList){
        this.terminalHandleList = terminalHandleList;
    }

    /**
     * 获取 自助终端办理 （否.否，是.是）
     * @return terminalHandleNotList
     */
    public List<String> getTerminalHandleNotList(){
        return this.terminalHandleNotList;
    }

    /**
     * 设置 自助终端办理 （否.否，是.是）
     * @param terminalHandleNotList
     */
    public void setTerminalHandleNotList(List<String> terminalHandleNotList){
        this.terminalHandleNotList = terminalHandleNotList;
    }

    /**
     * 获取 是否网办 （否.否，是.是）
     * @return isOnlineList
     */
    public List<String> getIsOnlineList(){
        return this.isOnlineList;
    }

    /**
     * 设置 是否网办 （否.否，是.是）
     * @param isOnlineList
     */
    public void setIsOnlineList(List<String> isOnlineList){
        this.isOnlineList = isOnlineList;
    }

    /**
     * 获取 是否网办 （否.否，是.是）
     * @return isOnlineNotList
     */
    public List<String> getIsOnlineNotList(){
        return this.isOnlineNotList;
    }

    /**
     * 设置 是否网办 （否.否，是.是）
     * @param isOnlineNotList
     */
    public void setIsOnlineNotList(List<String> isOnlineNotList){
        this.isOnlineNotList = isOnlineNotList;
    }

    /**
     * 获取 支持网上支付（否.否，是.是）
     * @return isOnlinePayShowList
     */
    public List<String> getIsOnlinePayShowList(){
        return this.isOnlinePayShowList;
    }

    /**
     * 设置 支持网上支付（否.否，是.是）
     * @param isOnlinePayShowList
     */
    public void setIsOnlinePayShowList(List<String> isOnlinePayShowList){
        this.isOnlinePayShowList = isOnlinePayShowList;
    }

    /**
     * 获取 支持网上支付（否.否，是.是）
     * @return isOnlinePayShowNotList
     */
    public List<String> getIsOnlinePayShowNotList(){
        return this.isOnlinePayShowNotList;
    }

    /**
     * 设置 支持网上支付（否.否，是.是）
     * @param isOnlinePayShowNotList
     */
    public void setIsOnlinePayShowNotList(List<String> isOnlinePayShowNotList){
        this.isOnlinePayShowNotList = isOnlinePayShowNotList;
    }

    /**
     * 获取 委托部门（否.否，是.是）
     * @return entrustmentDepartmenList
     */
    public List<String> getEntrustmentDepartmenList(){
        return this.entrustmentDepartmenList;
    }

    /**
     * 设置 委托部门（否.否，是.是）
     * @param entrustmentDepartmenList
     */
    public void setEntrustmentDepartmenList(List<String> entrustmentDepartmenList){
        this.entrustmentDepartmenList = entrustmentDepartmenList;
    }

    /**
     * 获取 委托部门（否.否，是.是）
     * @return entrustmentDepartmenNotList
     */
    public List<String> getEntrustmentDepartmenNotList(){
        return this.entrustmentDepartmenNotList;
    }

    /**
     * 设置 委托部门（否.否，是.是）
     * @param entrustmentDepartmenNotList
     */
    public void setEntrustmentDepartmenNotList(List<String> entrustmentDepartmenNotList){
        this.entrustmentDepartmenNotList = entrustmentDepartmenNotList;
    }

    /**
     * 获取 联办机构
     * @return jointInfoShowList
     */
    public List<String> getJointInfoShowList(){
        return this.jointInfoShowList;
    }

    /**
     * 设置 联办机构
     * @param jointInfoShowList
     */
    public void setJointInfoShowList(List<String> jointInfoShowList){
        this.jointInfoShowList = jointInfoShowList;
    }

    /**
     * 获取 联办机构
     * @return jointInfoShowNotList
     */
    public List<String> getJointInfoShowNotList(){
        return this.jointInfoShowNotList;
    }

    /**
     * 设置 联办机构
     * @param jointInfoShowNotList
     */
    public void setJointInfoShowNotList(List<String> jointInfoShowNotList){
        this.jointInfoShowNotList = jointInfoShowNotList;
    }

    /**
     * 获取 事项状态（停用.停用，在用.在用）
     * @return matterStatusList
     */
    public List<String> getMatterStatusList(){
        return this.matterStatusList;
    }

    /**
     * 设置 事项状态（停用.停用，在用.在用）
     * @param matterStatusList
     */
    public void setMatterStatusList(List<String> matterStatusList){
        this.matterStatusList = matterStatusList;
    }

    /**
     * 获取 事项状态（停用.停用，在用.在用）
     * @return matterStatusNotList
     */
    public List<String> getMatterStatusNotList(){
        return this.matterStatusNotList;
    }

    /**
     * 设置 事项状态（停用.停用，在用.在用）
     * @param matterStatusNotList
     */
    public void setMatterStatusNotList(List<String> matterStatusNotList){
        this.matterStatusNotList = matterStatusNotList;
    }

    /**
     * 获取 开始 数量限制
     * @return numberLimitStart
     */
    public Long getNumberLimitStart(){
        return this.numberLimitStart;
    }

    /**
     * 设置 开始 数量限制
     * @param numberLimitStart
     */
    public void setNumberLimitStart(Long numberLimitStart){
        this.numberLimitStart = numberLimitStart;
    }

    /**
     * 获取 结束 数量限制
     * @return $numberLimitEnd
     */
    public Long getNumberLimitEnd(){
        return this.numberLimitEnd;
    }

    /**
     * 设置 结束 数量限制
     * @param numberLimitEnd
     */
    public void setNumberLimitEnd(Long numberLimitEnd){
        this.numberLimitEnd = numberLimitEnd;
    }

    /**
     * 获取 增加 数量限制
     * @return numberLimitIncrement
     */
    public Long getNumberLimitIncrement(){
        return this.numberLimitIncrement;
    }

    /**
     * 设置 增加 数量限制
     * @param numberLimitIncrement
     */
    public void setNumberLimitIncrement(Long numberLimitIncrement){
        this.numberLimitIncrement = numberLimitIncrement;
    }

    /**
     * 获取 数量限制
     * @return numberLimitList
     */
    public List<Long> getNumberLimitList(){
        return this.numberLimitList;
    }

    /**
     * 设置 数量限制
     * @param numberLimitList
     */
    public void setNumberLimitList(List<Long> numberLimitList){
        this.numberLimitList = numberLimitList;
    }

    /**
     * 获取 数量限制
     * @return numberLimitNotList
     */
    public List<Long> getNumberLimitNotList(){
        return this.numberLimitNotList;
    }

    /**
     * 设置 数量限制
     * @param numberLimitNotList
     */
    public void setNumberLimitNotList(List<Long> numberLimitNotList){
        this.numberLimitNotList = numberLimitNotList;
    }


    /**
     * 获取 主题类型
     * @return typeList
     */
    public List<String> getTypeList(){
        return this.typeList;
    }

    /**
     * 设置 主题类型
     * @param typeList
     */
    public void setTypeList(List<String> typeList){
        this.typeList = typeList;
    }

    /**
     * 获取 主题类型
     * @return typeNotList
     */
    public List<String> getTypeNotList(){
        return this.typeNotList;
    }

    /**
     * 设置 主题类型
     * @param typeNotList
     */
    public void setTypeNotList(List<String> typeNotList){
        this.typeNotList = typeNotList;
    }

    /**
     * 获取 基本编码
     * @return baseCodeList
     */
    public List<String> getBaseCodeList(){
        return this.baseCodeList;
    }

    /**
     * 设置 基本编码
     * @param baseCodeList
     */
    public void setBaseCodeList(List<String> baseCodeList){
        this.baseCodeList = baseCodeList;
    }

    /**
     * 获取 基本编码
     * @return baseCodeNotList
     */
    public List<String> getBaseCodeNotList(){
        return this.baseCodeNotList;
    }

    /**
     * 设置 基本编码
     * @param baseCodeNotList
     */
    public void setBaseCodeNotList(List<String> baseCodeNotList){
        this.baseCodeNotList = baseCodeNotList;
    }

    /**
     * 获取 实施编码
     * @return implementCodeList
     */
    public List<String> getImplementCodeList(){
        return this.implementCodeList;
    }

    /**
     * 设置 实施编码
     * @param implementCodeList
     */
    public void setImplementCodeList(List<String> implementCodeList){
        this.implementCodeList = implementCodeList;
    }

    /**
     * 获取 实施编码
     * @return implementCodeNotList
     */
    public List<String> getImplementCodeNotList(){
        return this.implementCodeNotList;
    }

    /**
     * 设置 实施编码
     * @param implementCodeNotList
     */
    public void setImplementCodeNotList(List<String> implementCodeNotList){
        this.implementCodeNotList = implementCodeNotList;
    }

    /**
     * 获取 实施主体编码
     * @return implementBodyCodeList
     */
    public List<String> getImplementBodyCodeList(){
        return this.implementBodyCodeList;
    }

    /**
     * 设置 实施主体编码
     * @param implementBodyCodeList
     */
    public void setImplementBodyCodeList(List<String> implementBodyCodeList){
        this.implementBodyCodeList = implementBodyCodeList;
    }

    /**
     * 获取 实施主体编码
     * @return implementBodyCodeNotList
     */
    public List<String> getImplementBodyCodeNotList(){
        return this.implementBodyCodeNotList;
    }

    /**
     * 设置 实施主体编码
     * @param implementBodyCodeNotList
     */
    public void setImplementBodyCodeNotList(List<String> implementBodyCodeNotList){
        this.implementBodyCodeNotList = implementBodyCodeNotList;
    }

    /**
     * 获取 办理项编码
     * @return operateItemCodeList
     */
    public List<String> getOperateItemCodeList(){
        return this.operateItemCodeList;
    }

    /**
     * 设置 办理项编码
     * @param operateItemCodeList
     */
    public void setOperateItemCodeList(List<String> operateItemCodeList){
        this.operateItemCodeList = operateItemCodeList;
    }

    /**
     * 获取 办理项编码
     * @return operateItemCodeNotList
     */
    public List<String> getOperateItemCodeNotList(){
        return this.operateItemCodeNotList;
    }

    /**
     * 设置 办理项编码
     * @param operateItemCodeNotList
     */
    public void setOperateItemCodeNotList(List<String> operateItemCodeNotList){
        this.operateItemCodeNotList = operateItemCodeNotList;
    }

    /**
     * 获取 乡镇街道名称
     * @return townshipNameList
     */
    public List<String> getTownshipNameList(){
        return this.townshipNameList;
    }

    /**
     * 设置 乡镇街道名称
     * @param townshipNameList
     */
    public void setTownshipNameList(List<String> townshipNameList){
        this.townshipNameList = townshipNameList;
    }

    /**
     * 获取 乡镇街道名称
     * @return townshipNameNotList
     */
    public List<String> getTownshipNameNotList(){
        return this.townshipNameNotList;
    }

    /**
     * 设置 乡镇街道名称
     * @param townshipNameNotList
     */
    public void setTownshipNameNotList(List<String> townshipNameNotList){
        this.townshipNameNotList = townshipNameNotList;
    }

    /**
     * 获取 乡镇街道代码
     * @return townshipCodeList
     */
    public List<String> getTownshipCodeList(){
        return this.townshipCodeList;
    }

    /**
     * 设置 乡镇街道代码
     * @param townshipCodeList
     */
    public void setTownshipCodeList(List<String> townshipCodeList){
        this.townshipCodeList = townshipCodeList;
    }

    /**
     * 获取 乡镇街道代码
     * @return townshipCodeNotList
     */
    public List<String> getTownshipCodeNotList(){
        return this.townshipCodeNotList;
    }

    /**
     * 设置 乡镇街道代码
     * @param townshipCodeNotList
     */
    public void setTownshipCodeNotList(List<String> townshipCodeNotList){
        this.townshipCodeNotList = townshipCodeNotList;
    }

    /**
     * 获取 村居社区名称
     * @return villageNameList
     */
    public List<String> getVillageNameList(){
        return this.villageNameList;
    }

    /**
     * 设置 村居社区名称
     * @param villageNameList
     */
    public void setVillageNameList(List<String> villageNameList){
        this.villageNameList = villageNameList;
    }

    /**
     * 获取 村居社区名称
     * @return villageNameNotList
     */
    public List<String> getVillageNameNotList(){
        return this.villageNameNotList;
    }

    /**
     * 设置 村居社区名称
     * @param villageNameNotList
     */
    public void setVillageNameNotList(List<String> villageNameNotList){
        this.villageNameNotList = villageNameNotList;
    }

    /**
     * 获取 村居社区代码
     * @return villageCodeList
     */
    public List<String> getVillageCodeList(){
        return this.villageCodeList;
    }

    /**
     * 设置 村居社区代码
     * @param villageCodeList
     */
    public void setVillageCodeList(List<String> villageCodeList){
        this.villageCodeList = villageCodeList;
    }

    /**
     * 获取 村居社区代码
     * @return villageCodeNotList
     */
    public List<String> getVillageCodeNotList(){
        return this.villageCodeNotList;
    }

    /**
     * 设置 村居社区代码
     * @param villageCodeNotList
     */
    public void setVillageCodeNotList(List<String> villageCodeNotList){
        this.villageCodeNotList = villageCodeNotList;
    }

    /**
     * 获取 办理时间
     * @return operateTimeList
     */
    public List<String> getOperateTimeList(){
        return this.operateTimeList;
    }

    /**
     * 设置 办理时间
     * @param operateTimeList
     */
    public void setOperateTimeList(List<String> operateTimeList){
        this.operateTimeList = operateTimeList;
    }

    /**
     * 获取 办理时间
     * @return operateTimeNotList
     */
    public List<String> getOperateTimeNotList(){
        return this.operateTimeNotList;
    }

    /**
     * 设置 办理时间
     * @param operateTimeNotList
     */
    public void setOperateTimeNotList(List<String> operateTimeNotList){
        this.operateTimeNotList = operateTimeNotList;
    }

    /**
     * 获取 办理地点
     * @return operateSiteList
     */
    public List<String> getOperateSiteList(){
        return this.operateSiteList;
    }

    /**
     * 设置 办理地点
     * @param operateSiteList
     */
    public void setOperateSiteList(List<String> operateSiteList){
        this.operateSiteList = operateSiteList;
    }

    /**
     * 获取 办理地点
     * @return operateSiteNotList
     */
    public List<String> getOperateSiteNotList(){
        return this.operateSiteNotList;
    }

    /**
     * 设置 办理地点
     * @param operateSiteNotList
     */
    public void setOperateSiteNotList(List<String> operateSiteNotList){
        this.operateSiteNotList = operateSiteNotList;
    }

    /**
     * 获取 咨询方式
     * @return cousultingShowList
     */
    public List<String> getCousultingShowList(){
        return this.cousultingShowList;
    }

    /**
     * 设置 咨询方式
     * @param cousultingShowList
     */
    public void setCousultingShowList(List<String> cousultingShowList){
        this.cousultingShowList = cousultingShowList;
    }

    /**
     * 获取 咨询方式
     * @return cousultingShowNotList
     */
    public List<String> getCousultingShowNotList(){
        return this.cousultingShowNotList;
    }

    /**
     * 设置 咨询方式
     * @param cousultingShowNotList
     */
    public void setCousultingShowNotList(List<String> cousultingShowNotList){
        this.cousultingShowNotList = cousultingShowNotList;
    }

    /**
     * 获取 咨询电话
     * @return cousultingTelephoneShowList
     */
    public List<String> getCousultingTelephoneShowList(){
        return this.cousultingTelephoneShowList;
    }

    /**
     * 设置 咨询电话
     * @param cousultingTelephoneShowList
     */
    public void setCousultingTelephoneShowList(List<String> cousultingTelephoneShowList){
        this.cousultingTelephoneShowList = cousultingTelephoneShowList;
    }

    /**
     * 获取 咨询电话
     * @return cousultingTelephoneShowNotList
     */
    public List<String> getCousultingTelephoneShowNotList(){
        return this.cousultingTelephoneShowNotList;
    }

    /**
     * 设置 咨询电话
     * @param cousultingTelephoneShowNotList
     */
    public void setCousultingTelephoneShowNotList(List<String> cousultingTelephoneShowNotList){
        this.cousultingTelephoneShowNotList = cousultingTelephoneShowNotList;
    }

    /**
     * 获取 监督投诉方式
     * @return superviseShowList
     */
    public List<String> getSuperviseShowList(){
        return this.superviseShowList;
    }

    /**
     * 设置 监督投诉方式
     * @param superviseShowList
     */
    public void setSuperviseShowList(List<String> superviseShowList){
        this.superviseShowList = superviseShowList;
    }

    /**
     * 获取 监督投诉方式
     * @return superviseShowNotList
     */
    public List<String> getSuperviseShowNotList(){
        return this.superviseShowNotList;
    }

    /**
     * 设置 监督投诉方式
     * @param superviseShowNotList
     */
    public void setSuperviseShowNotList(List<String> superviseShowNotList){
        this.superviseShowNotList = superviseShowNotList;
    }

    /**
     * 获取 开始 排序
     * @return sortStart
     */
    public Integer getSortStart(){
        return this.sortStart;
    }

    /**
     * 设置 开始 排序
     * @param sortStart
     */
    public void setSortStart(Integer sortStart){
        this.sortStart = sortStart;
    }

    /**
     * 获取 结束 排序
     * @return $sortEnd
     */
    public Integer getSortEnd(){
        return this.sortEnd;
    }

    /**
     * 设置 结束 排序
     * @param sortEnd
     */
    public void setSortEnd(Integer sortEnd){
        this.sortEnd = sortEnd;
    }

    /**
     * 获取 增加 排序
     * @return sortIncrement
     */
    public Integer getSortIncrement(){
        return this.sortIncrement;
    }

    /**
     * 设置 增加 排序
     * @param sortIncrement
     */
    public void setSortIncrement(Integer sortIncrement){
        this.sortIncrement = sortIncrement;
    }

    /**
     * 获取 排序
     * @return sortList
     */
    public List<Integer> getSortList(){
        return this.sortList;
    }

    /**
     * 设置 排序
     * @param sortList
     */
    public void setSortList(List<Integer> sortList){
        this.sortList = sortList;
    }

    /**
     * 获取 排序
     * @return sortNotList
     */
    public List<Integer> getSortNotList(){
        return this.sortNotList;
    }

    /**
     * 设置 排序
     * @param sortNotList
     */
    public void setSortNotList(List<Integer> sortNotList){
        this.sortNotList = sortNotList;
    }


    /**
     * 获取 开始 事项来源(0.政务网，1.自定义)
     * @return sourceStart
     */
    public Integer getSourceStart(){
        return this.sourceStart;
    }

    /**
     * 设置 开始 事项来源(0.政务网，1.自定义)
     * @param sourceStart
     */
    public void setSourceStart(Integer sourceStart){
        this.sourceStart = sourceStart;
    }

    /**
     * 获取 结束 事项来源(0.政务网，1.自定义)
     * @return $sourceEnd
     */
    public Integer getSourceEnd(){
        return this.sourceEnd;
    }

    /**
     * 设置 结束 事项来源(0.政务网，1.自定义)
     * @param sourceEnd
     */
    public void setSourceEnd(Integer sourceEnd){
        this.sourceEnd = sourceEnd;
    }

    /**
     * 获取 增加 事项来源(0.政务网，1.自定义)
     * @return sourceIncrement
     */
    public Integer getSourceIncrement(){
        return this.sourceIncrement;
    }

    /**
     * 设置 增加 事项来源(0.政务网，1.自定义)
     * @param sourceIncrement
     */
    public void setSourceIncrement(Integer sourceIncrement){
        this.sourceIncrement = sourceIncrement;
    }

    /**
     * 获取 事项来源(0.政务网，1.自定义)
     * @return sourceList
     */
    public List<Integer> getSourceList(){
        return this.sourceList;
    }

    /**
     * 设置 事项来源(0.政务网，1.自定义)
     * @param sourceList
     */
    public void setSourceList(List<Integer> sourceList){
        this.sourceList = sourceList;
    }

    /**
     * 获取 事项来源(0.政务网，1.自定义)
     * @return sourceNotList
     */
    public List<Integer> getSourceNotList(){
        return this.sourceNotList;
    }

    /**
     * 设置 事项来源(0.政务网，1.自定义)
     * @param sourceNotList
     */
    public void setSourceNotList(List<Integer> sourceNotList){
        this.sourceNotList = sourceNotList;
    }


    /**
     * 获取 开始 创建时间
     * @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 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;
    }

    /**
     * 获取 部门名称
     * @return deptNameList
     */
    public List<String> getDeptNameList(){
        return this.deptNameList;
    }

    /**
     * 设置 部门名称
     * @param deptNameList
     */
    public void setDeptNameList(List<String> deptNameList){
        this.deptNameList = deptNameList;
    }

    /**
     * 获取 部门名称
     * @return deptNameNotList
     */
    public List<String> getDeptNameNotList(){
        return this.deptNameNotList;
    }

    /**
     * 设置 部门名称
     * @param deptNameNotList
     */
    public void setDeptNameNotList(List<String> deptNameNotList){
        this.deptNameNotList = deptNameNotList;
    }

    /**
     * 获取 评价地址
     * @return evaluationUrlList
     */
    public List<String> getEvaluationUrlList(){
        return this.evaluationUrlList;
    }

    /**
     * 设置 评价地址
     * @param evaluationUrlList
     */
    public void setEvaluationUrlList(List<String> evaluationUrlList){
        this.evaluationUrlList = evaluationUrlList;
    }

    /**
     * 获取 评价地址
     * @return evaluationUrlNotList
     */
    public List<String> getEvaluationUrlNotList(){
        return this.evaluationUrlNotList;
    }

    /**
     * 设置 评价地址
     * @param evaluationUrlNotList
     */
    public void setEvaluationUrlNotList(List<String> evaluationUrlNotList){
        this.evaluationUrlNotList = evaluationUrlNotList;
    }

    /**
     * 获取 申请地址
     * @return netApplyUrlList
     */
    public List<String> getNetApplyUrlList(){
        return this.netApplyUrlList;
    }

    /**
     * 设置 申请地址
     * @param netApplyUrlList
     */
    public void setNetApplyUrlList(List<String> netApplyUrlList){
        this.netApplyUrlList = netApplyUrlList;
    }

    /**
     * 获取 申请地址
     * @return netApplyUrlNotList
     */
    public List<String> getNetApplyUrlNotList(){
        return this.netApplyUrlNotList;
    }

    /**
     * 设置 申请地址
     * @param netApplyUrlNotList
     */
    public void setNetApplyUrlNotList(List<String> netApplyUrlNotList){
        this.netApplyUrlNotList = netApplyUrlNotList;
    }

    /**
     * 获取 区域名称
     * @return areaNameList
     */
    public List<String> getAreaNameList(){
        return this.areaNameList;
    }

    /**
     * 设置 区域名称
     * @param areaNameList
     */
    public void setAreaNameList(List<String> areaNameList){
        this.areaNameList = areaNameList;
    }

    /**
     * 获取 区域名称
     * @return areaNameNotList
     */
    public List<String> getAreaNameNotList(){
        return this.areaNameNotList;
    }

    /**
     * 设置 区域名称
     * @param areaNameNotList
     */
    public void setAreaNameNotList(List<String> areaNameNotList){
        this.areaNameNotList = areaNameNotList;
    }

    /**
     * 获取 开始 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @return areaLevelStart
     */
    public Integer getAreaLevelStart(){
        return this.areaLevelStart;
    }

    /**
     * 设置 开始 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelStart
     */
    public void setAreaLevelStart(Integer areaLevelStart){
        this.areaLevelStart = areaLevelStart;
    }

    /**
     * 获取 结束 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @return $areaLevelEnd
     */
    public Integer getAreaLevelEnd(){
        return this.areaLevelEnd;
    }

    /**
     * 设置 结束 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelEnd
     */
    public void setAreaLevelEnd(Integer areaLevelEnd){
        this.areaLevelEnd = areaLevelEnd;
    }

    /**
     * 获取 增加 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @return areaLevelIncrement
     */
    public Integer getAreaLevelIncrement(){
        return this.areaLevelIncrement;
    }

    /**
     * 设置 增加 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelIncrement
     */
    public void setAreaLevelIncrement(Integer areaLevelIncrement){
        this.areaLevelIncrement = areaLevelIncrement;
    }

    /**
     * 获取 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @return areaLevelList
     */
    public List<Integer> getAreaLevelList(){
        return this.areaLevelList;
    }

    /**
     * 设置 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelList
     */
    public void setAreaLevelList(List<Integer> areaLevelList){
        this.areaLevelList = areaLevelList;
    }

    /**
     * 获取 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @return areaLevelNotList
     */
    public List<Integer> getAreaLevelNotList(){
        return this.areaLevelNotList;
    }

    /**
     * 设置 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelNotList
     */
    public void setAreaLevelNotList(List<Integer> areaLevelNotList){
        this.areaLevelNotList = areaLevelNotList;
    }


    /**
     * 设置  序号，主键，自增长
     * @param id
     */
    public MatterQuery id(Long id){
        setId(id);
        return this;
    }

    /**
     * 设置 开始 序号，主键，自增长
     * @param idStart
     */
    public MatterQuery idStart(Long idStart){
        this.idStart = idStart;
        return this;
    }

    /**
     * 设置 结束 序号，主键，自增长
     * @param idEnd
     */
    public MatterQuery idEnd(Long idEnd){
        this.idEnd = idEnd;
        return this;
    }

    /**
     * 设置 增加 序号，主键，自增长
     * @param idIncrement
     */
    public MatterQuery idIncrement(Long idIncrement){
        this.idIncrement = idIncrement;
        return this;
    }

    /**
     * 设置 序号，主键，自增长
     * @param idList
     */
    public MatterQuery idList(List<Long> idList){
        this.idList = idList;
        return this;
    }

    /**
     * 设置 序号，主键，自增长
     * @param idNotList
     */
    public MatterQuery idNotList(List<Long> idNotList){
        this.idNotList = idNotList;
        return this;
    }

    /**
     * 设置  站点ID
     * @param siteId
     */
    public MatterQuery siteId(Long siteId){
        setSiteId(siteId);
        return this;
    }

    /**
     * 设置 开始 站点ID
     * @param siteIdStart
     */
    public MatterQuery siteIdStart(Long siteIdStart){
        this.siteIdStart = siteIdStart;
        return this;
    }

    /**
     * 设置 结束 站点ID
     * @param siteIdEnd
     */
    public MatterQuery siteIdEnd(Long siteIdEnd){
        this.siteIdEnd = siteIdEnd;
        return this;
    }

    /**
     * 设置 增加 站点ID
     * @param siteIdIncrement
     */
    public MatterQuery siteIdIncrement(Long siteIdIncrement){
        this.siteIdIncrement = siteIdIncrement;
        return this;
    }

    /**
     * 设置 站点ID
     * @param siteIdList
     */
    public MatterQuery siteIdList(List<Long> siteIdList){
        this.siteIdList = siteIdList;
        return this;
    }

    /**
     * 设置 站点ID
     * @param siteIdNotList
     */
    public MatterQuery siteIdNotList(List<Long> siteIdNotList){
        this.siteIdNotList = siteIdNotList;
        return this;
    }


    /**
     * 设置 从政务系统来的事项id
     * @param tid
     */
    public MatterQuery tid(String tid){
        setTid(tid);
        return this;
    }

    /**
     * 设置 从政务系统来的事项id
     * @param tidList
     */
    public MatterQuery tidList(List<String> tidList){
        this.tidList = tidList;
        return this;
    }


    /**
     * 设置 从政务系统来的事项code
     * @param tcode
     */
    public MatterQuery tcode(String tcode){
        setTcode(tcode);
        return this;
    }

    /**
     * 设置 从政务系统来的事项code
     * @param tcodeList
     */
    public MatterQuery tcodeList(List<String> tcodeList){
        this.tcodeList = tcodeList;
        return this;
    }


    /**
     * 设置 从政务系统来的事项name
     * @param tname
     */
    public MatterQuery tname(String tname){
        setTname(tname);
        return this;
    }

    /**
     * 设置 从政务系统来的事项name
     * @param tnameList
     */
    public MatterQuery tnameList(List<String> tnameList){
        this.tnameList = tnameList;
        return this;
    }


    /**
     * 设置 事项名称
     * @param matterName
     */
    public MatterQuery matterName(String matterName){
        setMatterName(matterName);
        return this;
    }

    /**
     * 设置 事项名称
     * @param matterNameList
     */
    public MatterQuery matterNameList(List<String> matterNameList){
        this.matterNameList = matterNameList;
        return this;
    }


    /**
     * 设置 英语事项名
     * @param englishName
     */
    public MatterQuery englishName(String englishName){
        setEnglishName(englishName);
        return this;
    }

    /**
     * 设置 英语事项名
     * @param englishNameList
     */
    public MatterQuery englishNameList(List<String> englishNameList){
        this.englishNameList = englishNameList;
        return this;
    }


    /**
     * 设置 事项编号
     * @param matterNo
     */
    public MatterQuery matterNo(String matterNo){
        setMatterNo(matterNo);
        return this;
    }

    /**
     * 设置 事项编号
     * @param matterNoList
     */
    public MatterQuery matterNoList(List<String> matterNoList){
        this.matterNoList = matterNoList;
        return this;
    }


    /**
     * 设置 区域编码
     * @param areaCode
     */
    public MatterQuery areaCode(String areaCode){
        setAreaCode(areaCode);
        return this;
    }

    /**
     * 设置 区域编码
     * @param areaCodeList
     */
    public MatterQuery areaCodeList(List<String> areaCodeList){
        this.areaCodeList = areaCodeList;
        return this;
    }


    /**
     * 设置 部门编号
     * @param deptCode
     */
    public MatterQuery deptCode(String deptCode){
        setDeptCode(deptCode);
        return this;
    }

    /**
     * 设置 部门编号
     * @param deptCodeList
     */
    public MatterQuery deptCodeList(List<String> deptCodeList){
        this.deptCodeList = deptCodeList;
        return this;
    }


    /**
     * 设置 行政权力编号
     * @param powerCode
     */
    public MatterQuery powerCode(String powerCode){
        setPowerCode(powerCode);
        return this;
    }

    /**
     * 设置 行政权力编号
     * @param powerCodeList
     */
    public MatterQuery powerCodeList(List<String> powerCodeList){
        this.powerCodeList = powerCodeList;
        return this;
    }


    /**
     * 设置 主题编号
     * @param themeCode
     */
    public MatterQuery themeCode(String themeCode){
        setThemeCode(themeCode);
        return this;
    }

    /**
     * 设置 主题编号
     * @param themeCodeList
     */
    public MatterQuery themeCodeList(List<String> themeCodeList){
        this.themeCodeList = themeCodeList;
        return this;
    }


    /**
     * 设置 服务类型编号
     * @param usertypeCode
     */
    public MatterQuery usertypeCode(String usertypeCode){
        setUsertypeCode(usertypeCode);
        return this;
    }

    /**
     * 设置 服务类型编号
     * @param usertypeCodeList
     */
    public MatterQuery usertypeCodeList(List<String> usertypeCodeList){
        this.usertypeCodeList = usertypeCodeList;
        return this;
    }


    /**
     * 设置 事项组名
     * @param groupName
     */
    public MatterQuery groupName(String groupName){
        setGroupName(groupName);
        return this;
    }

    /**
     * 设置 事项组名
     * @param groupNameList
     */
    public MatterQuery groupNameList(List<String> groupNameList){
        this.groupNameList = groupNameList;
        return this;
    }


    /**
     * 设置 事项详情链接
     * @param url
     */
    public MatterQuery url(String url){
        setUrl(url);
        return this;
    }

    /**
     * 设置 事项详情链接
     * @param urlList
     */
    public MatterQuery urlList(List<String> urlList){
        this.urlList = urlList;
        return this;
    }


    /**
     * 设置 是否获取事项详情
     * @param haveGetMatterInfo
     */
    public MatterQuery haveGetMatterInfo(String haveGetMatterInfo){
        setHaveGetMatterInfo(haveGetMatterInfo);
        return this;
    }

    /**
     * 设置 是否获取事项详情
     * @param haveGetMatterInfoList
     */
    public MatterQuery haveGetMatterInfoList(List<String> haveGetMatterInfoList){
        this.haveGetMatterInfoList = haveGetMatterInfoList;
        return this;
    }


    /**
     * 设置 所属部门
     * @param belongDept
     */
    public MatterQuery belongDept(String belongDept){
        setBelongDept(belongDept);
        return this;
    }

    /**
     * 设置 所属部门
     * @param belongDeptList
     */
    public MatterQuery belongDeptList(List<String> belongDeptList){
        this.belongDeptList = belongDeptList;
        return this;
    }


    /**
     * 设置 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
     * @param appoveObjectShow
     */
    public MatterQuery appoveObjectShow(String appoveObjectShow){
        setAppoveObjectShow(appoveObjectShow);
        return this;
    }

    /**
     * 设置 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
     * @param appoveObjectShowList
     */
    public MatterQuery appoveObjectShowList(List<String> appoveObjectShowList){
        this.appoveObjectShowList = appoveObjectShowList;
        return this;
    }


    /**
     * 设置 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
     * @param operatScopeShow
     */
    public MatterQuery operatScopeShow(String operatScopeShow){
        setOperatScopeShow(operatScopeShow);
        return this;
    }

    /**
     * 设置 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
     * @param operatScopeShowList
     */
    public MatterQuery operatScopeShowList(List<String> operatScopeShowList){
        this.operatScopeShowList = operatScopeShowList;
        return this;
    }


    /**
     * 设置 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
     * @param appoveTimeLimitShow
     */
    public MatterQuery appoveTimeLimitShow(String appoveTimeLimitShow){
        setAppoveTimeLimitShow(appoveTimeLimitShow);
        return this;
    }

    /**
     * 设置 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
     * @param appoveTimeLimitShowList
     */
    public MatterQuery appoveTimeLimitShowList(List<String> appoveTimeLimitShowList){
        this.appoveTimeLimitShowList = appoveTimeLimitShowList;
        return this;
    }


    /**
     * 设置 办理形式（窗口办理.窗口办理，网上办理.网上办理）
     * @param handleType
     */
    public MatterQuery handleType(String handleType){
        setHandleType(handleType);
        return this;
    }

    /**
     * 设置 办理形式（窗口办理.窗口办理，网上办理.网上办理）
     * @param handleTypeList
     */
    public MatterQuery handleTypeList(List<String> handleTypeList){
        this.handleTypeList = handleTypeList;
        return this;
    }


    /**
     * 设置 法定办结时限
     * @param legalTimeLimitShow
     */
    public MatterQuery legalTimeLimitShow(String legalTimeLimitShow){
        setLegalTimeLimitShow(legalTimeLimitShow);
        return this;
    }

    /**
     * 设置 法定办结时限
     * @param legalTimeLimitShowList
     */
    public MatterQuery legalTimeLimitShowList(List<String> legalTimeLimitShowList){
        this.legalTimeLimitShowList = legalTimeLimitShowList;
        return this;
    }


    /**
     * 设置 法定时限办结说明
     * @param legalEndExplain
     */
    public MatterQuery legalEndExplain(String legalEndExplain){
        setLegalEndExplain(legalEndExplain);
        return this;
    }

    /**
     * 设置 法定时限办结说明
     * @param legalEndExplainList
     */
    public MatterQuery legalEndExplainList(List<String> legalEndExplainList){
        this.legalEndExplainList = legalEndExplainList;
        return this;
    }


    /**
     * 设置 承诺办结时限
     * @param promiseTimeLimitShow
     */
    public MatterQuery promiseTimeLimitShow(String promiseTimeLimitShow){
        setPromiseTimeLimitShow(promiseTimeLimitShow);
        return this;
    }

    /**
     * 设置 承诺办结时限
     * @param promiseTimeLimitShowList
     */
    public MatterQuery promiseTimeLimitShowList(List<String> promiseTimeLimitShowList){
        this.promiseTimeLimitShowList = promiseTimeLimitShowList;
        return this;
    }


    /**
     * 设置 承诺时限办结说明
     * @param promiseEndExplain
     */
    public MatterQuery promiseEndExplain(String promiseEndExplain){
        setPromiseEndExplain(promiseEndExplain);
        return this;
    }

    /**
     * 设置 承诺时限办结说明
     * @param promiseEndExplainList
     */
    public MatterQuery promiseEndExplainList(List<String> promiseEndExplainList){
        this.promiseEndExplainList = promiseEndExplainList;
        return this;
    }


    /**
     * 设置 是否收费（否.否，是.是）
     * @param isChargesShow
     */
    public MatterQuery isChargesShow(String isChargesShow){
        setIsChargesShow(isChargesShow);
        return this;
    }

    /**
     * 设置 是否收费（否.否，是.是）
     * @param isChargesShowList
     */
    public MatterQuery isChargesShowList(List<String> isChargesShowList){
        this.isChargesShowList = isChargesShowList;
        return this;
    }


    /**
     * 设置 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
     * @param certificationLevelsShow
     */
    public MatterQuery certificationLevelsShow(String certificationLevelsShow){
        setCertificationLevelsShow(certificationLevelsShow);
        return this;
    }

    /**
     * 设置 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
     * @param certificationLevelsShowList
     */
    public MatterQuery certificationLevelsShowList(List<String> certificationLevelsShowList){
        this.certificationLevelsShowList = certificationLevelsShowList;
        return this;
    }




    /**
     * 设置 特别程序
     * @param specialProcedure
     */
    public MatterQuery specialProcedure(String specialProcedure){
        setSpecialProcedure(specialProcedure);
        return this;
    }

    /**
     * 设置 特别程序
     * @param specialProcedureList
     */
    public MatterQuery specialProcedureList(List<String> specialProcedureList){
        this.specialProcedureList = specialProcedureList;
        return this;
    }

    /**
     * 设置  窗口到现场次数
     * @param windowToTheSceneNum
     */
    public MatterQuery windowToTheSceneNum(Integer windowToTheSceneNum){
        setWindowToTheSceneNum(windowToTheSceneNum);
        return this;
    }

    /**
     * 设置 开始 窗口到现场次数
     * @param windowToTheSceneNumStart
     */
    public MatterQuery windowToTheSceneNumStart(Integer windowToTheSceneNumStart){
        this.windowToTheSceneNumStart = windowToTheSceneNumStart;
        return this;
    }

    /**
     * 设置 结束 窗口到现场次数
     * @param windowToTheSceneNumEnd
     */
    public MatterQuery windowToTheSceneNumEnd(Integer windowToTheSceneNumEnd){
        this.windowToTheSceneNumEnd = windowToTheSceneNumEnd;
        return this;
    }

    /**
     * 设置 增加 窗口到现场次数
     * @param windowToTheSceneNumIncrement
     */
    public MatterQuery windowToTheSceneNumIncrement(Integer windowToTheSceneNumIncrement){
        this.windowToTheSceneNumIncrement = windowToTheSceneNumIncrement;
        return this;
    }

    /**
     * 设置 窗口到现场次数
     * @param windowToTheSceneNumList
     */
    public MatterQuery windowToTheSceneNumList(List<Integer> windowToTheSceneNumList){
        this.windowToTheSceneNumList = windowToTheSceneNumList;
        return this;
    }

    /**
     * 设置 窗口到现场次数
     * @param windowToTheSceneNumNotList
     */
    public MatterQuery windowToTheSceneNumNotList(List<Integer> windowToTheSceneNumNotList){
        this.windowToTheSceneNumNotList = windowToTheSceneNumNotList;
        return this;
    }


    /**
     * 设置 是否网上预约,窗口办理选（否.否，是.是）
     * @param isOnlineSubscribeShow
     */
    public MatterQuery isOnlineSubscribeShow(String isOnlineSubscribeShow){
        setIsOnlineSubscribeShow(isOnlineSubscribeShow);
        return this;
    }

    /**
     * 设置 是否网上预约,窗口办理选（否.否，是.是）
     * @param isOnlineSubscribeShowList
     */
    public MatterQuery isOnlineSubscribeShowList(List<String> isOnlineSubscribeShowList){
        this.isOnlineSubscribeShowList = isOnlineSubscribeShowList;
        return this;
    }


    /**
     * 设置 物流快递,窗口办理选（否.否，是.是）
     * @param isExpressTakeShow
     */
    public MatterQuery isExpressTakeShow(String isExpressTakeShow){
        setIsExpressTakeShow(isExpressTakeShow);
        return this;
    }

    /**
     * 设置 物流快递,窗口办理选（否.否，是.是）
     * @param isExpressTakeShowList
     */
    public MatterQuery isExpressTakeShowList(List<String> isExpressTakeShowList){
        this.isExpressTakeShowList = isExpressTakeShowList;
        return this;
    }


    /**
     * 设置 是否支持全省范围就近取件（否.否，是.是）
     * @param isProvinceAcquisitionShow
     */
    public MatterQuery isProvinceAcquisitionShow(String isProvinceAcquisitionShow){
        setIsProvinceAcquisitionShow(isProvinceAcquisitionShow);
        return this;
    }

    /**
     * 设置 是否支持全省范围就近取件（否.否，是.是）
     * @param isProvinceAcquisitionShowList
     */
    public MatterQuery isProvinceAcquisitionShowList(List<String> isProvinceAcquisitionShowList){
        this.isProvinceAcquisitionShowList = isProvinceAcquisitionShowList;
        return this;
    }


    /**
     * 设置 是否支持全省范围就近办理（否.否，是.是）
     * @param isApplyProvinceShow
     */
    public MatterQuery isApplyProvinceShow(String isApplyProvinceShow){
        setIsApplyProvinceShow(isApplyProvinceShow);
        return this;
    }

    /**
     * 设置 是否支持全省范围就近办理（否.否，是.是）
     * @param isApplyProvinceShowList
     */
    public MatterQuery isApplyProvinceShowList(List<String> isApplyProvinceShowList){
        this.isApplyProvinceShowList = isApplyProvinceShowList;
        return this;
    }


    /**
     * 设置 必须到现场原因
     * @param mustSceneExplain
     */
    public MatterQuery mustSceneExplain(String mustSceneExplain){
        setMustSceneExplain(mustSceneExplain);
        return this;
    }

    /**
     * 设置 必须到现场原因
     * @param mustSceneExplainList
     */
    public MatterQuery mustSceneExplainList(List<String> mustSceneExplainList){
        this.mustSceneExplainList = mustSceneExplainList;
        return this;
    }


    /**
     * 设置 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
     * @param onlineType
     */
    public MatterQuery onlineType(String onlineType){
        setOnlineType(onlineType);
        return this;
    }

    /**
     * 设置 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
     * @param onlineTypeList
     */
    public MatterQuery onlineTypeList(List<String> onlineTypeList){
        this.onlineTypeList = onlineTypeList;
        return this;
    }

    /**
     * 设置  网办到现场次数
     * @param onlineToTheSceneNum
     */
    public MatterQuery onlineToTheSceneNum(Integer onlineToTheSceneNum){
        setOnlineToTheSceneNum(onlineToTheSceneNum);
        return this;
    }

    /**
     * 设置 开始 网办到现场次数
     * @param onlineToTheSceneNumStart
     */
    public MatterQuery onlineToTheSceneNumStart(Integer onlineToTheSceneNumStart){
        this.onlineToTheSceneNumStart = onlineToTheSceneNumStart;
        return this;
    }

    /**
     * 设置 结束 网办到现场次数
     * @param onlineToTheSceneNumEnd
     */
    public MatterQuery onlineToTheSceneNumEnd(Integer onlineToTheSceneNumEnd){
        this.onlineToTheSceneNumEnd = onlineToTheSceneNumEnd;
        return this;
    }

    /**
     * 设置 增加 网办到现场次数
     * @param onlineToTheSceneNumIncrement
     */
    public MatterQuery onlineToTheSceneNumIncrement(Integer onlineToTheSceneNumIncrement){
        this.onlineToTheSceneNumIncrement = onlineToTheSceneNumIncrement;
        return this;
    }

    /**
     * 设置 网办到现场次数
     * @param onlineToTheSceneNumList
     */
    public MatterQuery onlineToTheSceneNumList(List<Integer> onlineToTheSceneNumList){
        this.onlineToTheSceneNumList = onlineToTheSceneNumList;
        return this;
    }

    /**
     * 设置 网办到现场次数
     * @param onlineToTheSceneNumNotList
     */
    public MatterQuery onlineToTheSceneNumNotList(List<Integer> onlineToTheSceneNumNotList){
        this.onlineToTheSceneNumNotList = onlineToTheSceneNumNotList;
        return this;
    }


    /**
     * 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
     * @param onlineOperatDeep
     */
    public MatterQuery onlineOperatDeep(String onlineOperatDeep){
        setOnlineOperatDeep(onlineOperatDeep);
        return this;
    }

    /**
     * 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
     * @param onlineOperatDeepList
     */
    public MatterQuery onlineOperatDeepList(List<String> onlineOperatDeepList){
        this.onlineOperatDeepList = onlineOperatDeepList;
        return this;
    }


    /**
     * 设置 物流快递，网上办理选（否.否，是.是）
     * @param isExpressTakeOnlineShow
     */
    public MatterQuery isExpressTakeOnlineShow(String isExpressTakeOnlineShow){
        setIsExpressTakeOnlineShow(isExpressTakeOnlineShow);
        return this;
    }

    /**
     * 设置 物流快递，网上办理选（否.否，是.是）
     * @param isExpressTakeOnlineShowList
     */
    public MatterQuery isExpressTakeOnlineShowList(List<String> isExpressTakeOnlineShowList){
        this.isExpressTakeOnlineShowList = isExpressTakeOnlineShowList;
        return this;
    }


    /**
     * 设置 是否支持上门收取申请（否.否，是.是）
     * @param isDoorTakeShow
     */
    public MatterQuery isDoorTakeShow(String isDoorTakeShow){
        setIsDoorTakeShow(isDoorTakeShow);
        return this;
    }

    /**
     * 设置 是否支持上门收取申请（否.否，是.是）
     * @param isDoorTakeShowList
     */
    public MatterQuery isDoorTakeShowList(List<String> isDoorTakeShowList){
        this.isDoorTakeShowList = isDoorTakeShowList;
        return this;
    }


    /**
     * 设置 网上必须到现场原因
     * @param onlineMustSceneExplain
     */
    public MatterQuery onlineMustSceneExplain(String onlineMustSceneExplain){
        setOnlineMustSceneExplain(onlineMustSceneExplain);
        return this;
    }

    /**
     * 设置 网上必须到现场原因
     * @param onlineMustSceneExplainList
     */
    public MatterQuery onlineMustSceneExplainList(List<String> onlineMustSceneExplainList){
        this.onlineMustSceneExplainList = onlineMustSceneExplainList;
        return this;
    }


    /**
     * 设置 实施主体
     * @param performDeptType
     */
    public MatterQuery performDeptType(String performDeptType){
        setPerformDeptType(performDeptType);
        return this;
    }

    /**
     * 设置 实施主体
     * @param performDeptTypeList
     */
    public MatterQuery performDeptTypeList(List<String> performDeptTypeList){
        this.performDeptTypeList = performDeptTypeList;
        return this;
    }


    /**
     * 设置 事项版本
     * @param matterEdition
     */
    public MatterQuery matterEdition(String matterEdition){
        setMatterEdition(matterEdition);
        return this;
    }

    /**
     * 设置 事项版本
     * @param matterEditionList
     */
    public MatterQuery matterEditionList(List<String> matterEditionList){
        this.matterEditionList = matterEditionList;
        return this;
    }


    /**
     * 设置 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
     * @param eventTypeShow
     */
    public MatterQuery eventTypeShow(String eventTypeShow){
        setEventTypeShow(eventTypeShow);
        return this;
    }

    /**
     * 设置 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
     * @param eventTypeShowList
     */
    public MatterQuery eventTypeShowList(List<String> eventTypeShowList){
        this.eventTypeShowList = eventTypeShowList;
        return this;
    }


    /**
     * 设置 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
     * @param performHierarchyShow
     */
    public MatterQuery performHierarchyShow(String performHierarchyShow){
        setPerformHierarchyShow(performHierarchyShow);
        return this;
    }

    /**
     * 设置 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
     * @param performHierarchyShowList
     */
    public MatterQuery performHierarchyShowList(List<String> performHierarchyShowList){
        this.performHierarchyShowList = performHierarchyShowList;
        return this;
    }


    /**
     * 设置 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
     * @param powerSourceShow
     */
    public MatterQuery powerSourceShow(String powerSourceShow){
        setPowerSourceShow(powerSourceShow);
        return this;
    }

    /**
     * 设置 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
     * @param powerSourceShowList
     */
    public MatterQuery powerSourceShowList(List<String> powerSourceShowList){
        this.powerSourceShowList = powerSourceShowList;
        return this;
    }


    /**
     * 设置 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
     * @param performDeptTypeShow
     */
    public MatterQuery performDeptTypeShow(String performDeptTypeShow){
        setPerformDeptTypeShow(performDeptTypeShow);
        return this;
    }

    /**
     * 设置 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
     * @param performDeptTypeShowList
     */
    public MatterQuery performDeptTypeShowList(List<String> performDeptTypeShowList){
        this.performDeptTypeShowList = performDeptTypeShowList;
        return this;
    }


    /**
     * 设置 是否进驻中心（否.否，是.是）
     * @param goveServiceCenterShow
     */
    public MatterQuery goveServiceCenterShow(String goveServiceCenterShow){
        setGoveServiceCenterShow(goveServiceCenterShow);
        return this;
    }

    /**
     * 设置 是否进驻中心（否.否，是.是）
     * @param goveServiceCenterShowList
     */
    public MatterQuery goveServiceCenterShowList(List<String> goveServiceCenterShowList){
        this.goveServiceCenterShowList = goveServiceCenterShowList;
        return this;
    }


    /**
     * 设置 是否纳入便民服务中心（否.否，是.是）
     * @param isConvenientCenterShow
     */
    public MatterQuery isConvenientCenterShow(String isConvenientCenterShow){
        setIsConvenientCenterShow(isConvenientCenterShow);
        return this;
    }

    /**
     * 设置 是否纳入便民服务中心（否.否，是.是）
     * @param isConvenientCenterShowList
     */
    public MatterQuery isConvenientCenterShowList(List<String> isConvenientCenterShowList){
        this.isConvenientCenterShowList = isConvenientCenterShowList;
        return this;
    }


    /**
     * 设置 自助终端办理 （否.否，是.是）
     * @param terminalHandle
     */
    public MatterQuery terminalHandle(String terminalHandle){
        setTerminalHandle(terminalHandle);
        return this;
    }

    /**
     * 设置 自助终端办理 （否.否，是.是）
     * @param terminalHandleList
     */
    public MatterQuery terminalHandleList(List<String> terminalHandleList){
        this.terminalHandleList = terminalHandleList;
        return this;
    }


    /**
     * 设置 是否网办 （否.否，是.是）
     * @param isOnline
     */
    public MatterQuery isOnline(String isOnline){
        setIsOnline(isOnline);
        return this;
    }

    /**
     * 设置 是否网办 （否.否，是.是）
     * @param isOnlineList
     */
    public MatterQuery isOnlineList(List<String> isOnlineList){
        this.isOnlineList = isOnlineList;
        return this;
    }


    /**
     * 设置 支持网上支付（否.否，是.是）
     * @param isOnlinePayShow
     */
    public MatterQuery isOnlinePayShow(String isOnlinePayShow){
        setIsOnlinePayShow(isOnlinePayShow);
        return this;
    }

    /**
     * 设置 支持网上支付（否.否，是.是）
     * @param isOnlinePayShowList
     */
    public MatterQuery isOnlinePayShowList(List<String> isOnlinePayShowList){
        this.isOnlinePayShowList = isOnlinePayShowList;
        return this;
    }


    /**
     * 设置 委托部门（否.否，是.是）
     * @param entrustmentDepartmen
     */
    public MatterQuery entrustmentDepartmen(String entrustmentDepartmen){
        setEntrustmentDepartmen(entrustmentDepartmen);
        return this;
    }

    /**
     * 设置 委托部门（否.否，是.是）
     * @param entrustmentDepartmenList
     */
    public MatterQuery entrustmentDepartmenList(List<String> entrustmentDepartmenList){
        this.entrustmentDepartmenList = entrustmentDepartmenList;
        return this;
    }


    /**
     * 设置 联办机构
     * @param jointInfoShow
     */
    public MatterQuery jointInfoShow(String jointInfoShow){
        setJointInfoShow(jointInfoShow);
        return this;
    }

    /**
     * 设置 联办机构
     * @param jointInfoShowList
     */
    public MatterQuery jointInfoShowList(List<String> jointInfoShowList){
        this.jointInfoShowList = jointInfoShowList;
        return this;
    }


    /**
     * 设置 事项状态（停用.停用，在用.在用）
     * @param matterStatus
     */
    public MatterQuery matterStatus(String matterStatus){
        setMatterStatus(matterStatus);
        return this;
    }

    /**
     * 设置 事项状态（停用.停用，在用.在用）
     * @param matterStatusList
     */
    public MatterQuery matterStatusList(List<String> matterStatusList){
        this.matterStatusList = matterStatusList;
        return this;
    }

    /**
     * 设置  数量限制
     * @param numberLimit
     */
    public MatterQuery numberLimit(Long numberLimit){
        setNumberLimit(numberLimit);
        return this;
    }

    /**
     * 设置 开始 数量限制
     * @param numberLimitStart
     */
    public MatterQuery numberLimitStart(Long numberLimitStart){
        this.numberLimitStart = numberLimitStart;
        return this;
    }

    /**
     * 设置 结束 数量限制
     * @param numberLimitEnd
     */
    public MatterQuery numberLimitEnd(Long numberLimitEnd){
        this.numberLimitEnd = numberLimitEnd;
        return this;
    }

    /**
     * 设置 增加 数量限制
     * @param numberLimitIncrement
     */
    public MatterQuery numberLimitIncrement(Long numberLimitIncrement){
        this.numberLimitIncrement = numberLimitIncrement;
        return this;
    }

    /**
     * 设置 数量限制
     * @param numberLimitList
     */
    public MatterQuery numberLimitList(List<Long> numberLimitList){
        this.numberLimitList = numberLimitList;
        return this;
    }

    /**
     * 设置 数量限制
     * @param numberLimitNotList
     */
    public MatterQuery numberLimitNotList(List<Long> numberLimitNotList){
        this.numberLimitNotList = numberLimitNotList;
        return this;
    }


    /**
     * 设置 主题类型
     * @param type
     */
    public MatterQuery type(String type){
        setType(type);
        return this;
    }

    /**
     * 设置 主题类型
     * @param typeList
     */
    public MatterQuery typeList(List<String> typeList){
        this.typeList = typeList;
        return this;
    }


    /**
     * 设置 基本编码
     * @param baseCode
     */
    public MatterQuery baseCode(String baseCode){
        setBaseCode(baseCode);
        return this;
    }

    /**
     * 设置 基本编码
     * @param baseCodeList
     */
    public MatterQuery baseCodeList(List<String> baseCodeList){
        this.baseCodeList = baseCodeList;
        return this;
    }


    /**
     * 设置 实施编码
     * @param implementCode
     */
    public MatterQuery implementCode(String implementCode){
        setImplementCode(implementCode);
        return this;
    }

    /**
     * 设置 实施编码
     * @param implementCodeList
     */
    public MatterQuery implementCodeList(List<String> implementCodeList){
        this.implementCodeList = implementCodeList;
        return this;
    }


    /**
     * 设置 实施主体编码
     * @param implementBodyCode
     */
    public MatterQuery implementBodyCode(String implementBodyCode){
        setImplementBodyCode(implementBodyCode);
        return this;
    }

    /**
     * 设置 实施主体编码
     * @param implementBodyCodeList
     */
    public MatterQuery implementBodyCodeList(List<String> implementBodyCodeList){
        this.implementBodyCodeList = implementBodyCodeList;
        return this;
    }


    /**
     * 设置 办理项编码
     * @param operateItemCode
     */
    public MatterQuery operateItemCode(String operateItemCode){
        setOperateItemCode(operateItemCode);
        return this;
    }

    /**
     * 设置 办理项编码
     * @param operateItemCodeList
     */
    public MatterQuery operateItemCodeList(List<String> operateItemCodeList){
        this.operateItemCodeList = operateItemCodeList;
        return this;
    }


    /**
     * 设置 乡镇街道名称
     * @param townshipName
     */
    public MatterQuery townshipName(String townshipName){
        setTownshipName(townshipName);
        return this;
    }

    /**
     * 设置 乡镇街道名称
     * @param townshipNameList
     */
    public MatterQuery townshipNameList(List<String> townshipNameList){
        this.townshipNameList = townshipNameList;
        return this;
    }


    /**
     * 设置 乡镇街道代码
     * @param townshipCode
     */
    public MatterQuery townshipCode(String townshipCode){
        setTownshipCode(townshipCode);
        return this;
    }

    /**
     * 设置 乡镇街道代码
     * @param townshipCodeList
     */
    public MatterQuery townshipCodeList(List<String> townshipCodeList){
        this.townshipCodeList = townshipCodeList;
        return this;
    }


    /**
     * 设置 村居社区名称
     * @param villageName
     */
    public MatterQuery villageName(String villageName){
        setVillageName(villageName);
        return this;
    }

    /**
     * 设置 村居社区名称
     * @param villageNameList
     */
    public MatterQuery villageNameList(List<String> villageNameList){
        this.villageNameList = villageNameList;
        return this;
    }


    /**
     * 设置 村居社区代码
     * @param villageCode
     */
    public MatterQuery villageCode(String villageCode){
        setVillageCode(villageCode);
        return this;
    }

    /**
     * 设置 村居社区代码
     * @param villageCodeList
     */
    public MatterQuery villageCodeList(List<String> villageCodeList){
        this.villageCodeList = villageCodeList;
        return this;
    }


    /**
     * 设置 办理时间
     * @param operateTime
     */
    public MatterQuery operateTime(String operateTime){
        setOperateTime(operateTime);
        return this;
    }

    /**
     * 设置 办理时间
     * @param operateTimeList
     */
    public MatterQuery operateTimeList(List<String> operateTimeList){
        this.operateTimeList = operateTimeList;
        return this;
    }


    /**
     * 设置 办理地点
     * @param operateSite
     */
    public MatterQuery operateSite(String operateSite){
        setOperateSite(operateSite);
        return this;
    }

    /**
     * 设置 办理地点
     * @param operateSiteList
     */
    public MatterQuery operateSiteList(List<String> operateSiteList){
        this.operateSiteList = operateSiteList;
        return this;
    }


    /**
     * 设置 咨询方式
     * @param cousultingShow
     */
    public MatterQuery cousultingShow(String cousultingShow){
        setCousultingShow(cousultingShow);
        return this;
    }

    /**
     * 设置 咨询方式
     * @param cousultingShowList
     */
    public MatterQuery cousultingShowList(List<String> cousultingShowList){
        this.cousultingShowList = cousultingShowList;
        return this;
    }


    /**
     * 设置 咨询电话
     * @param cousultingTelephoneShow
     */
    public MatterQuery cousultingTelephoneShow(String cousultingTelephoneShow){
        setCousultingTelephoneShow(cousultingTelephoneShow);
        return this;
    }

    /**
     * 设置 咨询电话
     * @param cousultingTelephoneShowList
     */
    public MatterQuery cousultingTelephoneShowList(List<String> cousultingTelephoneShowList){
        this.cousultingTelephoneShowList = cousultingTelephoneShowList;
        return this;
    }


    /**
     * 设置 监督投诉方式
     * @param superviseShow
     */
    public MatterQuery superviseShow(String superviseShow){
        setSuperviseShow(superviseShow);
        return this;
    }

    /**
     * 设置 监督投诉方式
     * @param superviseShowList
     */
    public MatterQuery superviseShowList(List<String> superviseShowList){
        this.superviseShowList = superviseShowList;
        return this;
    }

    /**
     * 设置  排序
     * @param sort
     */
    public MatterQuery sort(Integer sort){
        setSort(sort);
        return this;
    }

    /**
     * 设置 开始 排序
     * @param sortStart
     */
    public MatterQuery sortStart(Integer sortStart){
        this.sortStart = sortStart;
        return this;
    }

    /**
     * 设置 结束 排序
     * @param sortEnd
     */
    public MatterQuery sortEnd(Integer sortEnd){
        this.sortEnd = sortEnd;
        return this;
    }

    /**
     * 设置 增加 排序
     * @param sortIncrement
     */
    public MatterQuery sortIncrement(Integer sortIncrement){
        this.sortIncrement = sortIncrement;
        return this;
    }

    /**
     * 设置 排序
     * @param sortList
     */
    public MatterQuery sortList(List<Integer> sortList){
        this.sortList = sortList;
        return this;
    }

    /**
     * 设置 排序
     * @param sortNotList
     */
    public MatterQuery sortNotList(List<Integer> sortNotList){
        this.sortNotList = sortNotList;
        return this;
    }

    /**
     * 设置  事项来源(0.政务网，1.自定义)
     * @param source
     */
    public MatterQuery source(Integer source){
        setSource(source);
        return this;
    }

    /**
     * 设置 开始 事项来源(0.政务网，1.自定义)
     * @param sourceStart
     */
    public MatterQuery sourceStart(Integer sourceStart){
        this.sourceStart = sourceStart;
        return this;
    }

    /**
     * 设置 结束 事项来源(0.政务网，1.自定义)
     * @param sourceEnd
     */
    public MatterQuery sourceEnd(Integer sourceEnd){
        this.sourceEnd = sourceEnd;
        return this;
    }

    /**
     * 设置 增加 事项来源(0.政务网，1.自定义)
     * @param sourceIncrement
     */
    public MatterQuery sourceIncrement(Integer sourceIncrement){
        this.sourceIncrement = sourceIncrement;
        return this;
    }

    /**
     * 设置 事项来源(0.政务网，1.自定义)
     * @param sourceList
     */
    public MatterQuery sourceList(List<Integer> sourceList){
        this.sourceList = sourceList;
        return this;
    }

    /**
     * 设置 事项来源(0.政务网，1.自定义)
     * @param sourceNotList
     */
    public MatterQuery sourceNotList(List<Integer> sourceNotList){
        this.sourceNotList = sourceNotList;
        return this;
    }


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

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

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

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

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

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



    /**
     * 设置 部门名称
     * @param deptName
     */
    public MatterQuery deptName(String deptName){
        setDeptName(deptName);
        return this;
    }

    /**
     * 设置 部门名称
     * @param deptNameList
     */
    public MatterQuery deptNameList(List<String> deptNameList){
        this.deptNameList = deptNameList;
        return this;
    }


    /**
     * 设置 评价地址
     * @param evaluationUrl
     */
    public MatterQuery evaluationUrl(String evaluationUrl){
        setEvaluationUrl(evaluationUrl);
        return this;
    }

    /**
     * 设置 评价地址
     * @param evaluationUrlList
     */
    public MatterQuery evaluationUrlList(List<String> evaluationUrlList){
        this.evaluationUrlList = evaluationUrlList;
        return this;
    }


    /**
     * 设置 申请地址
     * @param netApplyUrl
     */
    public MatterQuery netApplyUrl(String netApplyUrl){
        setNetApplyUrl(netApplyUrl);
        return this;
    }

    /**
     * 设置 申请地址
     * @param netApplyUrlList
     */
    public MatterQuery netApplyUrlList(List<String> netApplyUrlList){
        this.netApplyUrlList = netApplyUrlList;
        return this;
    }


    /**
     * 设置 区域名称
     * @param areaName
     */
    public MatterQuery areaName(String areaName){
        setAreaName(areaName);
        return this;
    }

    /**
     * 设置 区域名称
     * @param areaNameList
     */
    public MatterQuery areaNameList(List<String> areaNameList){
        this.areaNameList = areaNameList;
        return this;
    }

    /**
     * 设置  区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevel
     */
    public MatterQuery areaLevel(Integer areaLevel){
        setAreaLevel(areaLevel);
        return this;
    }

    /**
     * 设置 开始 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelStart
     */
    public MatterQuery areaLevelStart(Integer areaLevelStart){
        this.areaLevelStart = areaLevelStart;
        return this;
    }

    /**
     * 设置 结束 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelEnd
     */
    public MatterQuery areaLevelEnd(Integer areaLevelEnd){
        this.areaLevelEnd = areaLevelEnd;
        return this;
    }

    /**
     * 设置 增加 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelIncrement
     */
    public MatterQuery areaLevelIncrement(Integer areaLevelIncrement){
        this.areaLevelIncrement = areaLevelIncrement;
        return this;
    }

    /**
     * 设置 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelList
     */
    public MatterQuery areaLevelList(List<Integer> areaLevelList){
        this.areaLevelList = areaLevelList;
        return this;
    }

    /**
     * 设置 区域等级(1.省，2.地市州，3.区县，4.街道，5.社区)
     * @param areaLevelNotList
     */
    public MatterQuery areaLevelNotList(List<Integer> areaLevelNotList){
        this.areaLevelNotList = areaLevelNotList;
        return this;
    }

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

}