shenzhicheng_xh/zlkj_PERF/script_modules/@constellation/hrmp/index.d.ts

/// <reference types="../../@cosmic/bos-script" />
/// <reference types="../../@cosmic/bos-core" />
declare global {
    namespace $ {
        namespace kd.hr.hbp.business.application.common{
            interface ISortingArrayService_S {
            }
            interface ISortingArrayService$ {
                /**
                 * 比较两个对象，如果obj1等于 ojb2，则返回true, 否则返回false
                 * @param obj1
                 * @param obj2
                 * @return
                 */
                compareEqual(obj1:any,obj2:any):boolean;
                /**
                 * 比较两个对象，  要实现升序，如果 obj1 > ojb2，则返回true, 否则返回false
                 *              要实现降序，如果 obj1 < ojb2，则返回true, 否则返回false
                 * @param obj1
                 * @param obj2
                 * @return
                 */
                compareLarge(obj1:any,obj2:any):boolean;
                /**
                 * 数组排序
                 * @param arr
                 */
                quickSort(arr:any[]):void;
                /**
                 * 数组排序
                 * @param arr
                 * @param start 起始位置,一般为0
                 * @param end   结束位置
                 */
                quickSort(arr:any[],start:number,end:number):void;
            }
            type ISortingArrayService_T = ISortingArrayService_S & ISortingArrayService$;
            interface ISortingArrayService extends ISortingArrayService_T {
            }
            interface ICompareDiffController_S {
            }
            interface ICompareDiffController$ {
                /**
                 * 批量比较动态对象是否在数据库中，是否存在相同的数据
                 * @param compareDiffApiBatchInputParam 批量比较 数据差异接口入参
                 * @return 比较 数据差异接口 出参
                 */
                batchIsNewData(compareDiffApiBatchInputParam:kd.hr.hbp.business.domain.model.newhismodel.api.comparediff.CompareDiffApiBatchInputParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 比较动态对象是否在数据库中，是否存在相同的数据
                 * @param compareDiffApiParam 比较 数据差异接口入参
                 * @return 比较 数据差异接口 出参
                 */
                isNewData(compareDiffApiParam:kd.hr.hbp.business.domain.model.newhismodel.api.comparediff.CompareDiffApiInputParam):kd.hr.hbp.common.api.HrApiResponse;
            }
            type ICompareDiffController_T = ICompareDiffController_S & ICompareDiffController$;
            interface ICompareDiffController extends ICompareDiffController_T {
            }
            interface IDynamicObjectCommonService_S {
            }
            interface IDynamicObjectCommonService$ {
                /**
                 * 初始化设置创建人信息为当前登录人，创建时间为当前时间s
                 * @param dynamicObject
                 */
                initCreatorInfo(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 如果没有创建人信息，则设置创建人信息为当前登录人，创建时间为当前时间
                 * @param dynamicObject
                 */
                setCreatorInfoNoReplace(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 设置 master ID
                 * @param dynamicObject
                 */
                setMastId(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 批量设置 master ID
                 * @param dynamicObjects
                 */
                setMastId(dynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * 修改信息： 修改人、修改时间
                 * @param dynamicObject
                 */
                setSimpleModifyInfo(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 创建信息: 创建人，创建时间、 修改人、修改时间
                 * @param dynamicObject
                 */
                setSimpleNewInfo(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 创建信息: 创建人，创建时间、 修改人、修改时间, 指定的创建时间，修改时间
                 * @param dynamicObject
                 * @param date  指定的创建时间，修改时间
                 */
                setSimpleNewInfoByTime(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject,date:Date):void;
                /**
                 * 操作用户信息： 操作人、操作时间
                 *
                 * @param dynamicObject
                 */
                setSimpleOperateInfo(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 *  操作用户信息： 操作人、操作时间，指定的创建时间
                 * @param dynamicObject
                 * @param date 指定的创建时间
                 */
                setSimpleOperateInfoByTime(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject,date:Date):void;
            }
            type IDynamicObjectCommonService_T = IDynamicObjectCommonService_S & IDynamicObjectCommonService$;
            interface IDynamicObjectCommonService extends IDynamicObjectCommonService_T {
            }
        }
        namespace kd.hr.hbp.business.application.impl.common{
            interface CompareDiffController_S {
            }
            type CompareDiffController_ST = kd.hr.hbp.business.application.common.ICompareDiffController_S & CompareDiffController_S;
            interface CompareDiffController_C extends CompareDiffController_ST {
                new():CompareDiffController;
            }
            interface CompareDiffController$ {
            }
            type CompareDiffController_T = kd.hr.hbp.business.application.common.ICompareDiffController & CompareDiffController_S & CompareDiffController$;
            interface CompareDiffController extends CompareDiffController_T {
            }
            interface AbstractSortingArrayService_S {
            }
            type AbstractSortingArrayService_ST = kd.hr.hbp.business.application.common.ISortingArrayService_S & AbstractSortingArrayService_S;
            interface AbstractSortingArrayService_C extends AbstractSortingArrayService_ST {
                new():AbstractSortingArrayService;
            }
            interface AbstractSortingArrayService$ {
            }
            type AbstractSortingArrayService_T = kd.hr.hbp.business.application.common.ISortingArrayService & AbstractSortingArrayService_S & AbstractSortingArrayService$;
            interface AbstractSortingArrayService extends AbstractSortingArrayService_T {
            }
            interface DynamicObjectCommonService_S {
                /**
                 * 双重检查加锁 懒汉式
                 *
                 * @return 对象单例
                 */
                getInstance():DynamicObjectCommonService;
            }
            type DynamicObjectCommonService_ST = kd.hr.hbp.business.application.common.IDynamicObjectCommonService_S & DynamicObjectCommonService_S;
            interface DynamicObjectCommonService_C extends DynamicObjectCommonService_ST {
                new():DynamicObjectCommonService;
            }
            interface DynamicObjectCommonService$ {
            }
            type DynamicObjectCommonService_T = kd.hr.hbp.business.application.common.IDynamicObjectCommonService & DynamicObjectCommonService_S & DynamicObjectCommonService$;
            interface DynamicObjectCommonService extends DynamicObjectCommonService_T {
            }
        }
        namespace kd.hr.hbp.business.application.impl.newhismodel{
            interface HRHisModelModule_S {
            }
            type HRHisModelModule_ST = $.kd.sdk.module.Module & HRHisModelModule_S;
            interface HRHisModelModule_C extends HRHisModelModule_ST {
                new():HRHisModelModule;
            }
            interface HRHisModelModule$ {
            }
            type HRHisModelModule_T = $.kd.sdk.module.Module & HRHisModelModule_S & HRHisModelModule$;
            interface HRHisModelModule extends HRHisModelModule_T {
            }
            interface HisModelController_S {
                /**
                 * 双重检查加锁 懒汉式
                 *
                 * @return 对象单例
                 */
                getInstance():HisModelController;
            }
            type HisModelController_ST = kd.hr.hbp.business.application.newhismodel.IHisModelController_S & HisModelController_S;
            interface HisModelController_C extends HisModelController_ST {
                new():HisModelController;
            }
            interface HisModelController$ {
            }
            type HisModelController_T = kd.hr.hbp.business.application.newhismodel.IHisModelController & HisModelController_S & HisModelController$;
            interface HisModelController extends HisModelController_T {
            }
            interface HisModelAttachController_S {
                /**
                 * 双重检查加锁 懒汉式
                 *
                 * @return 对象单例
                 */
                getInstance():HisModelAttachController;
            }
            type HisModelAttachController_ST = kd.hr.hbp.business.application.newhismodel.IHisModelAttachController_S & HisModelAttachController_S;
            interface HisModelAttachController_C extends HisModelAttachController_ST {
                new():HisModelAttachController;
            }
            interface HisModelAttachController$ {
            }
            type HisModelAttachController_T = kd.hr.hbp.business.application.newhismodel.IHisModelAttachController & HisModelAttachController_S & HisModelAttachController$;
            interface HisModelAttachController extends HisModelAttachController_T {
            }
            interface HisModelInitController_S {
                /**
                 * 双重检查加锁 懒汉式
                 *
                 * @return 对象单例
                 */
                getInstance():HisModelInitController;
            }
            type HisModelInitController_ST = kd.hr.hbp.business.application.newhismodel.IHisModelInitController_S & HisModelInitController_S;
            interface HisModelInitController_C extends HisModelInitController_ST {
                new():HisModelInitController;
            }
            interface HisModelInitController$ {
            }
            type HisModelInitController_T = kd.hr.hbp.business.application.newhismodel.IHisModelInitController & HisModelInitController_S & HisModelInitController$;
            interface HisModelInitController extends HisModelInitController_T {
            }
        }
        namespace kd.hr.hbp.business.application.newhismodel{
            interface IHisModelController_S {
            }
            interface IHisModelController$ {
                /**
                 * 批量废弃数据服务
                 *
                 * @param hisBatchDiscardApiBo
                 */
                batchDiscardBoData(hisBatchDiscardApiBo:kd.hr.hbp.business.domain.model.newhismodel.api.HisBatchDiscardApiBo):void;
                /**
                 * 批量历史版本修订，包括时序性，非时序性版本变更
                 *
                 * @param hisVersionParamListBo
                 */
                batchHisVersionChange(hisVersionParamListBo:kd.hr.hbp.business.domain.model.newhismodel.HisVersionParamListBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 根据实体编码和F7字段，判断F7 是否是 历史版本F7
                 *
                 * @param mainEntityNumber 主实体
                 * @param f7FieldName      主实体F7字段
                 * @param baseEntityNumber F7字段的实体编码
                 * @return HisImportBo
                 */
                buildImportFilter(mainEntityNumber:string,f7FieldName:string,baseEntityNumber:string):kd.hr.hbp.business.domain.model.newhismodel.HisInitReturnBo;
                /**
                 * 删除 bo数据
                 *
                 * @param hisBaseBo
                 */
                deleteBo(hisBaseBo:kd.hr.hbp.business.domain.model.newhismodel.HisBaseBo):void;
                deleteBoByInitBatch(hisDelVersionApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisDelVersionApiParam):$.java.util.List;
                deleteBoByInitBatchAndBoid(hisDelVersionApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisDelVersionApiParam):$.java.util.List;
                /**
                 * 启用禁用
                 *
                 * @param hisEnableParamBo
                 */
                disableOrEnableBo(hisEnableParamBo:kd.hr.hbp.business.domain.model.newhismodel.enable.HisEnableParamBo):void;
                /**
                 * 废弃数据服务
                 *
                 * @param hisDiscardApiBo
                 */
                discardBoData(hisDiscardApiBo:kd.hr.hbp.business.domain.model.newhismodel.api.HisDiscardApiBo):void;
                /**
                 * 判断实体继承关系：普通实体、历史时序型实体、历史非时序型实体
                 *
                 * @param entityNumber
                 * @return enum EnumEntityTpl {
                 * COMMON_TPL("0"),    // 普通实体
                 * LINETIMESEQ_TPL("1"),   // 继承历史时序型实体
                 * NONLINETIMESEQ_TPL("2");    // 继承历史非时序型实体
                 */
                entityInhRelation(entityNumber:string):string;
                /**
                 * 获取修订记录
                 *
                 * @param hisVersionReviseParamBo 版本修订参数
                 */
                getReviseRecord(hisVersionReviseParamBo:kd.hr.hbp.business.domain.model.newhismodel.api.revise.HisReviseRecordParamBo):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 时序性导入操作接口
                 *
                 * @param hisImportBo 导入bo
                 * @return 接口响应结果
                 */
                hisLineImportData(hisImportBo:kd.hr.hbp.business.domain.model.newhismodel.HisImportBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 非时序性导入操作接口
                 *
                 * @param hisImportBo 导入bo
                 */
                hisNonLineImportData(hisImportBo:kd.hr.hbp.business.domain.model.newhismodel.HisImportBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 时序性历史版本修订，包括保存版本，立即生效版本，修改生效日期等服务
                 *
                 * @param hisVersionParamBo
                 */
                hisVersionChange(hisVersionParamBo:kd.hr.hbp.business.domain.model.newhismodel.HisVersionParamBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 版本保存计算
                 *
                 * @param hisVersionCalcApiParam 版本切割计算入参
                 * @return
                 */
                hisVersionSaveCalc(hisVersionCalcApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisVersionCalcApiParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 非序性历史版本修订，包括保存版本，立即生效版本
                 *
                 * @param hisVersionParamBo
                 * @return HisResponse<VersionChangeRespData>
                 */
                noLineTimeHisVersionChange(hisVersionParamBo:kd.hr.hbp.business.domain.model.newhismodel.HisVersionParamBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 版本修订服务
                 *
                 * @param hisVersionReviseParamBo
                 */
                reviseVersion(hisVersionReviseParamBo:kd.hr.hbp.business.domain.model.newhismodel.HisVersionReviseParamBo):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * @param hisTransRevocationListBo 全量/部分撤销事务集合
                 */
                revocationEvent(hisTransRevocationListBo:kd.hr.hbp.business.domain.model.newhismodel.HisTransRevocationListBo):void;
                /**
                 * 查询更晚事务
                 *
                 * @param hisSearchLaterEventParam
                 * @return
                 */
                searchLaterEvent(hisSearchLaterEventParam:kd.hr.hbp.business.domain.model.newhismodel.event.HisSearchLaterEventParam):kd.hr.hbp.common.api.HrApiResponse;
            }
            type IHisModelController_T = IHisModelController_S & IHisModelController$;
            interface IHisModelController extends IHisModelController_T {
            }
            interface IHisModelAttachController_S {
            }
            interface IHisModelAttachController$ {
                /**
                 * 查询数据库中的附件数据，并组装成历史模型需要的附件格式
                 * @param hisAttachmentParamBo 附件对外API入参
                 * @return
                 */
                generateAttachmentMap(hisAttachmentParamBo:kd.hr.hbp.business.domain.model.newhismodel.api.attachment.HisAttachmentParamBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 附件上传数据库
                 *
                 * @param hisAttachmentDataBo  历史摸摸要求的入参格式
                 * @return
                 */
                uploadAttachmentMap(hisAttachmentDataBo:kd.hr.hbp.business.domain.model.newhismodel.api.attachment.HisAttachmentDataBo):void;
            }
            type IHisModelAttachController_T = IHisModelAttachController_S & IHisModelAttachController$;
            interface IHisModelAttachController extends IHisModelAttachController_T {
            }
            interface IHisModelInitController_S {
            }
            interface IHisModelInitController$ {
                HisInitDeleteByBatch(hisInitDeleteByBatchBo:kd.hr.hbp.business.domain.model.newhismodel.init.HisInitDeleteByBatchBo):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 新增BO
                 *
                 * @param hisInitBoApiParam 初始化新增参数入库
                 * @return 数据及错误信息
                 */
                initBo(hisInitBoApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisInitBoApiParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 新增BO校验服务
                 *
                 * @param hisInitBoApiParam 初始化新增参数
                 * @return 数据及错误信息
                 */
                initBoValidate(hisInitBoApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisInitBoApiParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 初始化新增版本，确认变更
                 *
                 * @param hisInitVersionApiParam 初始化新增版本参数
                 * @return 数据及错误信息
                 */
                initVersionConfirm(hisInitVersionApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisInitVersionApiParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 初始化新增版本
                 *
                 * @param hisInitVersionApiParam 初始化新增版本参数
                 * @return 数据及错误信息
                 */
                initVersionSave(hisInitVersionApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisInitVersionApiParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 初始化新增版本校验
                 *
                 * @param hisInitVersionApiParam 初始化新增版本参数
                 * @return 数据及错误信息
                 */
                initVersionValidate(hisInitVersionApiParam:kd.hr.hbp.business.domain.model.newhismodel.calc.api.HisInitVersionApiParam):kd.hr.hbp.common.api.HrApiResponse;
            }
            type IHisModelInitController_T = IHisModelInitController_S & IHisModelInitController$;
            interface IHisModelInitController extends IHisModelInitController_T {
            }
        }
        namespace kd.hr.hbp.business.bgtask{
            interface HRBackgroundTaskHelper_S {
                readonly ENTITY_BGTASKRECORD:string;
                readonly ENTITY_BGTASKREGISTER:string;
                readonly ENTITY_BGTASKSESSION:string;
                readonly HRBACKGROUND_TASKPROCESS:string;
                readonly HRBACKGROUND_TASKPROGRESSPAGEID:string;
                readonly TASK_SERVICEAPP:string;
                /**
                 * 获取悬浮球执行实例
                 *
                 * @return
                 */
                getInstance():HRBackgroundTaskHelper;
            }
            interface HRBackgroundTaskHelper_C extends HRBackgroundTaskHelper_S {
                new():HRBackgroundTaskHelper;
            }
            interface HRBackgroundTaskHelper$ {
                /**
                 * 任务执行会话添加
                 *
                 * @param taskId 任务ID
                 * @param sessionId 当前登录会话
                 */
                addTaskSession(taskId:string,sessionId:string):void;
                /**
                 * 按不同的状态向前端发送任务进度
                 *
                 * @param taskInfo
                 * @param name
                 * @param taskStatus
                 */
                buildTaskInfo(taskInfo:$.kd.bos.schedule.api.TaskInfo,name:string,taskStatus:string):void;
                /**
                 * 确认已结束的任务
                 *
                 * @param taskId
                 * @param taskStatus
                 */
                confirmEndTask(taskId:string,taskStatus:string):void;
                /**
                 * 确认已结束的任务
                 *
                 * @param taskId 任务ID
                 * @param taskStatus 任务状态
                 * @param delTask 关闭悬浮球
                 */
                confirmEndTask(taskId:string,taskStatus:string,delTask:boolean):void;
                /**
                 * 创建一个悬浮球任务，不加载到前端，后续使用showBaskgroundTask(String taskId)方法加载到前端中执行 （发布到当前首页，旧的其他首页不会出现悬浮球，后续打开的页面也会有悬浮球）
                 *
                 * @param bgTaskNumber 注册编码
                 * @param name 悬浮球进度名称显示
                 * @param useBizTask 是否通过业务线程更新进度，为true时，平台任务直接返回，在业务线程中更新进度
                 * @param rootPageId 首页ID
                 * @param parentPageId 进度条打开页面的父页面ID，用于打开进度条，如果父页面关闭时，从首页打开进度条
                 * @param params 进度刷新可以使用的参数
                 * @return taskId 任务ID
                 */
                createBaskgroundTask(bgTaskNumber:string,name:string,useBizTask:boolean,rootPageId:string,parentPageId:string,params:$.java.util.Map):string;
                /**
                 * 结束完成任务
                 *
                 * @param taskId
                 * @param status
                 */
                endTask(taskId:string,status:string):void;
                /**
                 * 业务线程更新进度
                 *
                 * @param taskId 任务ID
                 * @param progress 任务进度0-100之间的数值
                 * @param desc 说明
                 * @param customData 自定义参数暂时预留，可传入null
                 */
                feedbackProgress(taskId:string,progress:number,desc:string,customData:$.java.util.Map):void;
                /**
                 * 业务线程更新状态
                 *
                 * @param taskId 任务ID
                 * @param status 任务状态ID，使用TaskStatusConstant常量获取
                 * @param desc 说明
                 * @param customData 自定义参数暂时预留，可传入null
                 */
                feedbackStatus(taskId:string,status:string,desc:string,customData:$.java.util.Map):void;
                /**
                 * 通过平台任务ID查询任务记录
                 *
                 * @param taskId
                 * @return
                 */
                getBgTaskRecordByTaskId(taskId:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取业务线程进度
                 *
                 * @param taskId
                 * @return
                 */
                getBizTaskResult(taskId:string):TaskResult;
                /**
                 * 将字符串jobforminfo反序列化成对象JobFormInfo
                 *
                 * @param jobforminfo
                 * @return
                 */
                getJobFormInfo(jobforminfo:string):$.kd.bos.schedule.form.JobFormInfo;
                /**
                 * 通过平台任务ID查询JobFormInfo
                 *
                 * @param taskId
                 * @return
                 */
                getJobFormInfoByTaskId(taskId:string):$.kd.bos.schedule.form.JobFormInfo;
                /**
                 * 获取进度页面缓存
                 *
                 * @param mainView 当前应用首页
                 * @param taskId 任务ID
                 * @return 返回进度页面ID
                 */
                getProgressPageId(mainView:$.kd.bos.form.IFormView,taskId:string):string;
                /**
                 * 获取悬浮球任务进度信息
                 *
                 * @param taskId
                 * @return
                 */
                getTaskInfo(taskId:string):$.kd.bos.schedule.api.TaskInfo;
                /**
                 * 获取悬浮球任务进度结果信息(包含自定义参数信息)
                 *
                 * @param taskId
                 * @return
                 */
                getTaskResult(taskId:string):TaskResult;
                /**
                 * 获取是否适用业务线程更新进度
                 *
                 * @param jobFormInfo
                 * @return
                 */
                getUseBizTask(jobFormInfo:$.kd.bos.schedule.form.JobFormInfo):boolean;
                /**
                 * 获取是否适用业务线程更新进度
                 *
                 * @param taskId
                 * @return
                 */
                getUseBizTaskByTaskId(taskId:string):boolean;
                /**
                 * 封装回调函数返回信息
                 * code/hrmp-hbp-business/src/main/java/kd/hr/hbp/business/bgtask/HRBackgroundTaskHelper.java
                 * @param taskInfo
                 * @return
                 */
                packageReturnResult(taskInfo:$.kd.bos.schedule.api.TaskInfo):$.java.util.Map;
                /**
                 * 删除进度页面缓存
                 *
                 * @param mainView 当前应用首页
                 * @param taskId 任务ID
                 */
                removeProgressPageId(mainView:$.kd.bos.form.IFormView,taskId:string):void;
                /**
                 * 设置进度页面缓存
                 *
                 * @param mainView 当前应用首页
                 * @param taskId 任务ID
                 * @param progressPageId 进度页面ID
                 */
                setProgressPageId(mainView:$.kd.bos.form.IFormView,taskId:string,progressPageId:string):void;
                /**
                 * 通过一个创建好的悬浮球任务打开一个新的悬浮球,任务转为后台时调用
                 *
                 * @param taskId 通过已经存在悬浮球任务
                 */
                showBaskgroundTask(taskId:string):void;
                /**
                 * 打开一个新的悬浮球（发布到当前首页，旧的其他首页不会出现悬浮球，后续打开的页面也会有悬浮球）
                 *
                 * @param bgTaskNumber 注册编码
                 * @param name 悬浮球进度名称显示
                 * @param useBizTask 是否通过业务线程更新进度，为true时，平台任务直接返回，在业务线程中更新进度
                 * @param rootPageId 首页ID
                 * @param parentPageId 进度条打开页面的父页面ID，用于打开进度条，如果父页面关闭时，从首页打开进度条
                 * @param params 进度刷新可以使用的参数
                 * @return taskId 任务ID
                 */
                showBaskgroundTask(bgTaskNumber:string,name:string,useBizTask:boolean,rootPageId:string,parentPageId:string,params:$.java.util.Map):string;
                /**
                 * 更新任务执行记录状态
                 *
                 * @param bgTaskRecord 悬浮球任务记录
                 * @param taskStatus 悬浮球状态
                 * @param isConfirm 是否已确认
                 */
                updateTaskRecordStatus(bgTaskRecord:$.kd.bos.dataentity.entity.DynamicObject,taskStatus:string,isConfirm:boolean):void;
            }
            type HRBackgroundTaskHelper_T = HRBackgroundTaskHelper_S & HRBackgroundTaskHelper$;
            interface HRBackgroundTaskHelper extends HRBackgroundTaskHelper_T {
            }
            interface TaskResult_S {
            }
            type TaskResult_ST = $.java.io.Serializable & TaskResult_S;
            interface TaskResult_C extends TaskResult_ST {
                new(taskInfo:$.kd.bos.schedule.api.TaskInfo,customData:$.java.util.Map):TaskResult;
            }
            interface TaskResult$ {
                getCustomData():$.java.util.Map;
                getTaskInfo():$.kd.bos.schedule.api.TaskInfo;
                setCustomData(customData:$.java.util.Map):void;
                setTaskInfo(taskInfo:$.kd.bos.schedule.api.TaskInfo):void;
            }
            type TaskResult_T = $.java.io.Serializable & TaskResult_S & TaskResult$;
            interface TaskResult extends TaskResult_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel{
            interface HisVersionReviseParamBo_S {
            }
            interface HisVersionReviseParamBo_C extends HisVersionReviseParamBo_S {
                new():HisVersionReviseParamBo;
            }
            interface HisVersionReviseParamBo$ {
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 获取 要处理的附件信息
                 *
                 * @return mapHisAttachmentBos 要处理的附件信息
                 */
                getMapHisAttachmentBos():$.java.util.Map;
                /**
                 * 获取 操作前的附件信息
                 *
                 * @return preHisAttachmentBos 操作前的附件信息
                 */
                getPreHisAttachmentBos():$.java.util.Map;
                /**
                 * 获取 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 *
                 * @return reviseDys 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 */
                getReviseDys():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取 是否是同步个性化数据
                 *
                 * @return isPersonalDataSyn 是否是同步个性化数据
                 */
                isPersonalDataSyn():boolean;
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置 要处理的附件信息
                 *
                 * @param mapHisAttachmentBos 要处理的附件信息
                 */
                setMapHisAttachmentBos(mapHisAttachmentBos:$.java.util.Map):void;
                /**
                 * 设置 是否是同步个性化数据
                 *
                 * @param isPersonalDataSyn 是否是同步个性化数据
                 */
                setPersonalDataSyn(isPersonalDataSyn:boolean):void;
                /**
                 * 设置 操作前的附件信息
                 *
                 * @param preHisAttachmentBos 操作前的附件信息
                 */
                setPreHisAttachmentBos(preHisAttachmentBos:$.java.util.Map):void;
                /**
                 * 设置 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 *
                 * @param reviseDys 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 */
                setReviseDys(reviseDys:$.kd.bos.dataentity.entity.DynamicObject[]):void;
            }
            type HisVersionReviseParamBo_T = HisVersionReviseParamBo_S & HisVersionReviseParamBo$;
            interface HisVersionReviseParamBo extends HisVersionReviseParamBo_T {
            }
            interface ImportRespData_S {
            }
            type ImportRespData_ST = VersionChangeRespData_S & ImportRespData_S;
            interface ImportRespData_C extends ImportRespData_ST {
                new():ImportRespData;
            }
            interface ImportRespData$ {
                /**
                 * 获取 导入方式
                 *
                 * @return importType 导入方式
                 */
                getImportType():string;
                /**
                 * 获取 导入成功的数据id
                 *
                 * @return pkIds 导入成功的数据id
                 */
                getPkIds():$.java.util.List;
                /**
                 * 设置 导入方式
                 *
                 * @param importType 导入方式
                 */
                setImportType(importType:string):void;
                /**
                 * 设置 导入成功的数据id
                 *
                 * @param pkIds 导入成功的数据id
                 */
                setPkIds(pkIds:$.java.util.List):void;
            }
            type ImportRespData_T = VersionChangeRespData & ImportRespData_S & ImportRespData$;
            interface ImportRespData extends ImportRespData_T {
            }
            interface HisBaseBo_S {
            }
            interface HisBaseBo_C extends HisBaseBo_S {
                new():HisBaseBo;
            }
            interface HisBaseBo$ {
                /**
                 * 获取 业务实体 boId 列表
                 *
                 * @return boIdList 业务实体 boId 列表
                 */
                getBoIdList():$.java.util.List;
                /**
                 * 获取 当前业务实体动态对象  boIdList与 dyCurrents共存时，优先取 dyCurrents ，不再用 dyCurrents 查询当前数据.      增加参数目的， 启用时有需求要传入修改的数据，而不是通过id去查询
                 *
                 * @return dyCurrents 当前业务实体动态对象  boIdList与 dyCurrents共存时，优先取 dyCurrents ，不再用 dyCurrents 查询当前数据.      增加参数目的， 启用时有需求要传入修改的数据，而不是通过id去查询
                 */
                getDyCurrents():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取 来源实体编码
                 *
                 * @return entityNumber 来源实体编码
                 */
                getEntityNumber():string;
                /**
                 * 设置 业务实体 boId 列表
                 *
                 * @param boIdList 业务实体 boId 列表
                 */
                setBoIdList(boIdList:$.java.util.List):void;
                /**
                 * 设置 当前业务实体动态对象  boIdList与 dyCurrents共存时，优先取 dyCurrents ，不再用 dyCurrents 查询当前数据.  增加参数目的， 启用时有需求要传入修改的数据，而不是通过id去查询
                 *
                 * @param dyCurrents 当前业务实体动态对象  boIdList与 dyCurrents共存时，优先取 dyCurrents ，不再用 dyCurrents 查询当前数据.  增加参数目的， 启用时有需求要传入修改的数据，而不是通过id去查询
                 */
                setDyCurrents(dyCurrents:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * 设置 来源实体编码
                 *
                 * @param entityNumber 来源实体编码
                 */
                setEntityNumber(entityNumber:string):void;
            }
            type HisBaseBo_T = HisBaseBo_S & HisBaseBo$;
            interface HisBaseBo extends HisBaseBo_T {
            }
            interface HisVersionParamBo_S {
            }
            interface HisVersionParamBo_C extends HisVersionParamBo_S {
                new():HisVersionParamBo;
            }
            interface HisVersionParamBo$ {
                /**
                 * 获取 业务自定义字段值
                 *
                 * @return customizedFiledValue 业务自定义字段值
                 */
                getCustomizedFiledValue():$.java.util.List;
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 获取 事务ID 返回此次生成的事务ID
                 *
                 * @return eventId 事务ID 返回此次生成的事务ID
                 */
                getEventId():long;
                /**
                 * 获取 首个复制版本ID 调用者可以自定义首个数据版本ID，如果为空，默认自动生成ID跟动态对象 hisDyns 必须顺序对应上 hisDyns 个数与 firstVersionIds 个数必须相等才生效
                 *
                 * @return firstVersionIds 首个复制版本ID 调用者可以自定义首个数据版本ID，如果为空，默认自动生成ID跟动态对象 hisDyns 必须顺序对应上 hisDyns 个数与 firstVersionIds 个数必须相等才生效
                 */
                getFirstVersionIds():long[];
                /**
                 * 获取 动态对象数组 (支持同一个实体，多条数据批量，例如批量导入场景)
                 *
                 * @return hisDyns 动态对象数组 (支持同一个实体，多条数据批量，例如批量导入场景)
                 */
                getHisDyns():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取 业务事务主实体id(entityData为多条时，且为原子事务时，必填)
                 *
                 * @return mainBoId 业务事务主实体id(entityData为多条时，且为原子事务时，必填)
                 */
                getMainBoId():long;
                /**
                 * 获取 要处理的附件信息
                 *
                 * @return mapHisAttachmentBos 要处理的附件信息
                 */
                getMapHisAttachmentBos():$.java.util.Map;
                /**
                 * 获取 接口调用类型
                 *
                 * @return operateType 接口调用类型
                 */
                getOperateType():string;
                /**
                 * 获取 是否包含个性化数据，  1:仅包含原始数据; 0: 两种兼有，或未可知，需查库校验4 不处理;
                 *
                 * @return personalDataType 是否包含个性化数据，  1:仅包含原始数据; 0: 两种兼有，或未可知，需查库校验4 不处理;
                 */
                getPersonalDataType():number;
                /**
                 * 获取 是否原子事务
                 *
                 * @return atomicTrans 是否原子事务
                 */
                isAtomicTrans():boolean;
                /**
                 * 获取 查询版本号 取消挂起事务标志
                 *
                 * @return cancel_notSupported 查询版本号 取消挂起事务标志
                 */
                isCancel_notSupported():boolean;
                /**
                 * 获取 变更是否立即生效
                 *
                 * @return effImmediately 变更是否立即生效
                 */
                isEffImmediately():boolean;
                /**
                 * 获取 是否处理附件 导入、启用、禁用不需要处理附件
                 *
                 * @return needProcessAttachment 是否处理附件 导入、启用、禁用不需要处理附件
                 */
                isNeedProcessAttachment():boolean;
                /**
                 * 获取 是否需要校验时间区间是否正确.  默认需要校验。 如果用了校验器校验，则无需再次校验(中台历史模型校验器 kd.hr.hbp.opplugin.web.hismodel.validator.HisSaveValidator)
                 *
                 * @return needValidateDate 是否需要校验时间区间是否正确.  默认需要校验。 如果用了校验器校验，则无需再次校验(中台历史模型校验器 kd.hr.hbp.opplugin.web.hismodel.validator.HisSaveValidator)
                 */
                isNeedValidateDate():boolean;
                /**
                 * 设置 是否原子事务
                 *
                 * @param atomicTrans 是否原子事务
                 */
                setAtomicTrans(atomicTrans:boolean):void;
                /**
                 * 设置 查询版本号 取消挂起事务标志
                 *
                 * @param cancel_notSupported 查询版本号 取消挂起事务标志
                 */
                setCancel_notSupported(cancel_notSupported:boolean):void;
                /**
                 * 设置 业务自定义字段值
                 *
                 * @param customizedFiledValue 业务自定义字段值
                 */
                setCustomizedFiledValue(customizedFiledValue:$.java.util.List):void;
                /**
                 * 设置 变更是否立即生效
                 *
                 * @param effImmediately 变更是否立即生效
                 */
                setEffImmediately(effImmediately:boolean):void;
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置 事务ID 返回此次生成的事务ID
                 *
                 * @param eventId 事务ID 返回此次生成的事务ID
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 首个复制版本ID 调用者可以自定义首个数据版本ID，如果为空，默认自动生成ID跟动态对象 hisDyns 必须顺序对应上 hisDyns 个数与 firstVersionIds 个数必须相等才生效
                 *
                 * @param firstVersionIds 首个复制版本ID 调用者可以自定义首个数据版本ID，如果为空，默认自动生成ID跟动态对象 hisDyns 必须顺序对应上 hisDyns 个数与 firstVersionIds 个数必须相等才生效
                 */
                setFirstVersionIds(firstVersionIds:long[]):void;
                /**
                 * 设置 动态对象数组 (支持同一个实体，多条数据批量，例如批量导入场景)
                 *
                 * @param hisDyns 动态对象数组 (支持同一个实体，多条数据批量，例如批量导入场景)
                 */
                setHisDyns(hisDyns:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * 设置 业务事务主实体id(entityData为多条时，且为原子事务时，必填)
                 *
                 * @param mainBoId 业务事务主实体id(entityData为多条时，且为原子事务时，必填)
                 */
                setMainBoId(mainBoId:long):void;
                /**
                 * 设置 要处理的附件信息
                 *
                 * @param mapHisAttachmentBos 要处理的附件信息
                 */
                setMapHisAttachmentBos(mapHisAttachmentBos:$.java.util.Map):void;
                /**
                 * 设置 是否处理附件 导入、启用、禁用不需要处理附件
                 *
                 * @param needProcessAttachment 是否处理附件 导入、启用、禁用不需要处理附件
                 */
                setNeedProcessAttachment(needProcessAttachment:boolean):void;
                /**
                 * 设置 是否需要校验时间区间是否正确.  默认需要校验。 如果用了校验器校验，则无需再次校验(中台历史模型校验器 kd.hr.hbp.opplugin.web.hismodel.validator.HisSaveValidator)
                 *
                 * @param needValidateDate 是否需要校验时间区间是否正确.  默认需要校验。 如果用了校验器校验，则无需再次校验(中台历史模型校验器 kd.hr.hbp.opplugin.web.hismodel.validator.HisSaveValidator)
                 */
                setNeedValidateDate(needValidateDate:boolean):void;
                /**
                 * 设置 接口调用类型
                 *
                 * @param operateType 接口调用类型
                 */
                setOperateType(operateType:string):void;
                /**
                 * 设置 是否包含个性化数据，  1:仅包含原始数据; 0: 两种兼有，或未可知，需查库校验4 不处理;
                 *
                 * @param personalDataType 是否包含个性化数据，  1:仅包含原始数据; 0: 两种兼有，或未可知，需查库校验4 不处理;
                 */
                setPersonalDataType(personalDataType:number):void;
            }
            type HisVersionParamBo_T = HisVersionParamBo_S & HisVersionParamBo$;
            interface HisVersionParamBo extends HisVersionParamBo_T {
            }
            interface HisVersionReviseReturnDataBo_S {
            }
            interface HisVersionReviseReturnDataBo_C extends HisVersionReviseReturnDataBo_S {
                new():HisVersionReviseReturnDataBo;
            }
            interface HisVersionReviseReturnDataBo$ {
                /**
                 * 获取 要处理的附件信息
                 *
                 * @return attachmentMap 要处理的附件信息
                 */
                getAttachmentMap():$.java.util.Map;
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 获取 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 *
                 * @return returnData 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 */
                getReturnData():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 设置 要处理的附件信息
                 *
                 * @param attachmentMap 要处理的附件信息
                 */
                setAttachmentMap(attachmentMap:$.java.util.Map):void;
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 *
                 * @param returnData 动态对象数组 (支持同一个实体，多条数据批量，例如个性化数据的源数据修改，可能影响多个个性化的版本，批量导入场景)
                 */
                setReturnData(returnData:$.kd.bos.dataentity.entity.DynamicObject[]):void;
            }
            type HisVersionReviseReturnDataBo_T = HisVersionReviseReturnDataBo_S & HisVersionReviseReturnDataBo$;
            interface HisVersionReviseReturnDataBo extends HisVersionReviseReturnDataBo_T {
            }
            interface BatchVersionChangeRespData_S {
            }
            interface BatchVersionChangeRespData_C extends BatchVersionChangeRespData_S {
                new():BatchVersionChangeRespData;
            }
            interface BatchVersionChangeRespData$ {
                /**
                 * 获取 事务ID
                 *
                 * @return eventId 事务ID
                 */
                getEventId():long;
                /**
                 * 获取 新的版本实体编码、数据集合
                 *
                 * @return versionChangeRespDataList 新的版本实体编码、数据集合
                 */
                getVersionChangeRespDataList():$.java.util.List;
                /**
                 * 设置 事务ID
                 *
                 * @param eventId 事务ID
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 新的版本实体编码、数据集合
                 *
                 * @param versionChangeRespDataList 新的版本实体编码、数据集合
                 */
                setVersionChangeRespDataList(versionChangeRespDataList:$.java.util.List):void;
            }
            type BatchVersionChangeRespData_T = BatchVersionChangeRespData_S & BatchVersionChangeRespData$;
            interface BatchVersionChangeRespData extends BatchVersionChangeRespData_T {
            }
            interface HisTransRevocationListBo_S {
            }
            interface HisTransRevocationListBo_C extends HisTransRevocationListBo_S {
                new():HisTransRevocationListBo;
            }
            interface HisTransRevocationListBo$ {
                /**
                 * 获取 事务组编码(优先从此获取事务组， 如果为空，则从应用ID中获取配置的事务组)
                 *
                 * @return eventGroupNumber 事务组编码(优先从此获取事务组， 如果为空，则从应用ID中获取配置的事务组)
                 */
                getEventGroupNumber():string;
                /**
                 * 获取 事务ID
                 *
                 * @return eventId 事务ID
                 */
                getEventId():long;
                /**
                 * 获取 事务撤销bo
                 *
                 * @return listHisTransRevocationBo 事务撤销bo
                 */
                getListHisTransRevocationBo():$.java.util.List;
                /**
                 * 获取 注册了事务组的应用ID  (如果为空，则从HisTransRevocationBo中获取实体编码，获取事务组，兼容第一次提供出去的接口参数定义)
                 *
                 * @return resisterEventGroupAppId 注册了事务组的应用ID  (如果为空，则从HisTransRevocationBo中获取实体编码，获取事务组，兼容第一次提供出去的接口参数定义)
                 */
                getResisterEventGroupAppId():string;
                /**
                 * 获取 注册了事务组的实体编码，没有实体注册事务，也可以通过实体所在的应用找到事务组 (如果为空，则从entityNumber获取配置的事务组 )
                 *
                 * @return resisterEventGroupEntityNumber 注册了事务组的实体编码，没有实体注册事务，也可以通过实体所在的应用找到事务组 (如果为空，则从entityNumber获取配置的事务组 )
                 */
                getResisterEventGroupEntityNumber():string;
                /**
                 * 设置 事务组编码(优先从此获取事务组， 如果为空，则从应用ID中获取配置的事务组)
                 *
                 * @param eventGroupNumber 事务组编码(优先从此获取事务组， 如果为空，则从应用ID中获取配置的事务组)
                 */
                setEventGroupNumber(eventGroupNumber:string):void;
                /**
                 * 设置 事务ID
                 *
                 * @param eventId 事务ID
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 事务撤销bo
                 *
                 * @param listHisTransRevocationBo 事务撤销bo
                 */
                setListHisTransRevocationBo(listHisTransRevocationBo:$.java.util.List):void;
                /**
                 * 设置 注册了事务组的应用ID  (如果为空，则从HisTransRevocationBo中获取实体编码，获取事务组，兼容第一次提供出去的接口参数定义)
                 *
                 * @param resisterEventGroupAppId 注册了事务组的应用ID  (如果为空，则从HisTransRevocationBo中获取实体编码，获取事务组，兼容第一次提供出去的接口参数定义)
                 */
                setResisterEventGroupAppId(resisterEventGroupAppId:string):void;
                /**
                 * 设置 注册了事务组的实体编码，没有实体注册事务，也可以通过实体所在的应用找到事务组 (如果为空，则从entityNumber获取配置的事务组 )
                 *
                 * @param resisterEventGroupEntityNumber 注册了事务组的实体编码，没有实体注册事务，也可以通过实体所在的应用找到事务组 (如果为空，则从entityNumber获取配置的事务组 )
                 */
                setResisterEventGroupEntityNumber(resisterEventGroupEntityNumber:string):void;
            }
            type HisTransRevocationListBo_T = HisTransRevocationListBo_S & HisTransRevocationListBo$;
            interface HisTransRevocationListBo extends HisTransRevocationListBo_T {
            }
            interface HisResponse_S {
            }
            interface HisResponse_C extends HisResponse_S {
                new():HisResponse;
            }
            interface HisResponse$ {
                /**
                 * 获取 返回编码 默认200
                 *
                 * @return code 返回编码 默认200
                 */
                getCode():string;
                /**
                 * 获取 返回数据
                 *
                 * @return data 返回数据
                 */
                getData():any;
                /**
                 * 获取 错误信息
                 *
                 * @return errorMessage 错误信息
                 */
                getErrorMessage():string;
                /**
                 * 设置 返回编码 默认200
                 *
                 * @param code 返回编码 默认200
                 */
                setCode(code:string):void;
                setData(arg0:any):void;
                /**
                 * 设置 错误信息
                 *
                 * @param errorMessage 错误信息
                 */
                setErrorMessage(errorMessage:string):void;
            }
            type HisResponse_T = HisResponse_S & HisResponse$;
            interface HisResponse extends HisResponse_T {
            }
            interface HisTransRevocationBo_S {
            }
            interface HisTransRevocationBo_C extends HisTransRevocationBo_S {
                new():HisTransRevocationBo;
            }
            interface HisTransRevocationBo$ {
                /**
                 * 获取 业务id
                 *
                 * @return boId 业务id
                 */
                getBoId():$.java.util.List;
                /**
                 * 获取 实体编码（用于一个事务影响多个实体的部分撤销）
                 *
                 * @return entityNumber 实体编码（用于一个事务影响多个实体的部分撤销）
                 */
                getEntityNumber():string;
                /**
                 * 设置 业务id
                 *
                 * @param boId 业务id
                 */
                setBoId(boId:$.java.util.List):void;
                /**
                 * 设置 实体编码（用于一个事务影响多个实体的部分撤销）
                 *
                 * @param entityNumber 实体编码（用于一个事务影响多个实体的部分撤销）
                 */
                setEntityNumber(entityNumber:string):void;
            }
            type HisTransRevocationBo_T = HisTransRevocationBo_S & HisTransRevocationBo$;
            interface HisTransRevocationBo extends HisTransRevocationBo_T {
            }
            interface HisVersionParamListBo_S {
            }
            interface HisVersionParamListBo_C extends HisVersionParamListBo_S {
                new():HisVersionParamListBo;
            }
            interface HisVersionParamListBo$ {
                /**
                 * 获取 事务ID
                 *
                 * @return eventId 事务ID
                 */
                getEventId():long;
                /**
                 * 获取 批量参数列表
                 *
                 * @return listHisVersionParamBo 批量参数列表
                 */
                getListHisVersionParamBo():$.java.util.List;
                /**
                 * 获取 业务事务主实体id(目前未用上，可不填)
                 *
                 * @return mainBoId 业务事务主实体id(目前未用上，可不填)
                 */
                getMainBoId():long;
                /**
                 * 获取 实体编码(entityData为多条时，且为原子事务时，必填)
                 *
                 * @return mainEntityNumber 实体编码(entityData为多条时，且为原子事务时，必填)
                 */
                getMainEntityNumber():string;
                /**
                 * 获取 是否原子事务
                 *
                 * @return atomicTrans 是否原子事务
                 */
                isAtomicTrans():boolean;
                /**
                 * 获取 变更是否立即生效
                 *
                 * @return effImmediately 变更是否立即生效
                 */
                isEffImmediately():boolean;
                /**
                 * 设置 是否原子事务
                 *
                 * @param atomicTrans 是否原子事务
                 */
                setAtomicTrans(atomicTrans:boolean):void;
                /**
                 * 设置 变更是否立即生效
                 *
                 * @param effImmediately 变更是否立即生效
                 */
                setEffImmediately(effImmediately:boolean):void;
                /**
                 * 设置 事务ID
                 *
                 * @param eventId 事务ID
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 批量参数列表
                 *
                 * @param listHisVersionParamBo 批量参数列表
                 */
                setListHisVersionParamBo(listHisVersionParamBo:$.java.util.List):void;
                /**
                 * 设置 业务事务主实体id(目前未用上，可不填)
                 *
                 * @param mainBoId 业务事务主实体id(目前未用上，可不填)
                 */
                setMainBoId(mainBoId:long):void;
                /**
                 * 设置 实体编码(entityData为多条时，且为原子事务时，必填)
                 *
                 * @param mainEntityNumber 实体编码(entityData为多条时，且为原子事务时，必填)
                 */
                setMainEntityNumber(mainEntityNumber:string):void;
            }
            type HisVersionParamListBo_T = HisVersionParamListBo_S & HisVersionParamListBo$;
            interface HisVersionParamListBo extends HisVersionParamListBo_T {
            }
            interface HisImportBo_S {
            }
            interface HisImportBo_C extends HisImportBo_S {
                new():HisImportBo;
            }
            interface HisImportBo$ {
                /**
                 * 获取 导入数据集
                 *
                 * @return dataEntities 导入数据集
                 */
                getDataEntities():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取 导入方式
                 *
                 * @return importType 导入方式
                 */
                getImportType():string;
                /**
                 * 设置 导入数据集
                 *
                 * @param dataEntities 导入数据集
                 */
                setDataEntities(dataEntities:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * 设置 导入方式
                 *
                 * @param importType 导入方式
                 */
                setImportType(importType:string):void;
            }
            type HisImportBo_T = HisImportBo_S & HisImportBo$;
            interface HisImportBo extends HisImportBo_T {
            }
            interface HisInitReturnBo_S {
            }
            interface HisInitReturnBo_C extends HisInitReturnBo_S {
                new():HisInitReturnBo;
            }
            interface HisInitReturnBo$ {
                /**
                 * 获取 导入Filter
                 *
                 * @return qFilter 导入Filter
                 */
                getqFilter():$.kd.bos.orm.query.QFilter;
                /**
                 * 获取 是否版本F7
                 *
                 * @return isF7Version 是否版本F7
                 */
                isF7Version():boolean;
                /**
                 * 获取 是否历史模型
                 *
                 * @return hisModel 是否历史模型
                 */
                isHisModel():boolean;
                /**
                 * 设置 是否版本F7
                 *
                 * @param f7Version 是否版本F7
                 */
                setF7Version(f7Version:boolean):void;
                /**
                 * 设置 是否历史模型
                 *
                 * @param hisModel 是否历史模型
                 */
                setHisModel(hisModel:boolean):void;
                /**
                 * 设置 导入Filter
                 *
                 * @param qFilter 导入Filter
                 */
                setqFilter(qFilter:$.kd.bos.orm.query.QFilter):void;
            }
            type HisInitReturnBo_T = HisInitReturnBo_S & HisInitReturnBo$;
            interface HisInitReturnBo extends HisInitReturnBo_T {
            }
            interface VersionChangeRespData_S {
            }
            interface VersionChangeRespData_C extends VersionChangeRespData_S {
                new():VersionChangeRespData;
            }
            interface VersionChangeRespData$ {
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 获取 事务ID
                 *
                 * @return eventId 事务ID
                 */
                getEventId():long;
                /**
                 * 获取 新的版本数据
                 *
                 * @return newDynamicObjects 新的版本数据
                 */
                getNewDynamicObjects():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置 事务ID
                 *
                 * @param eventId 事务ID
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 新的版本数据
                 *
                 * @param newDynamicObjects 新的版本数据
                 */
                setNewDynamicObjects(newDynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[]):void;
            }
            type VersionChangeRespData_T = VersionChangeRespData_S & VersionChangeRespData$;
            interface VersionChangeRespData extends VersionChangeRespData_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.api{
            interface HisBatchDiscardApiBo_S {
            }
            interface HisBatchDiscardApiBo_C extends HisBatchDiscardApiBo_S {
                new():HisBatchDiscardApiBo;
            }
            interface HisBatchDiscardApiBo$ {
                /**
                 * 获取 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下
                 *
                 * @return eventId 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下
                 */
                getEventId():long;
                /**
                 * 获取 废弃数据参数
                 *
                 * @return hisDiscardApiBoList 废弃数据参数
                 */
                getHisDiscardApiBoList():$.java.util.List;
                /**
                 * 设置 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下
                 *
                 * @param eventId 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 废弃数据参数
                 *
                 * @param hisDiscardApiBoList 废弃数据参数
                 */
                setHisDiscardApiBoList(hisDiscardApiBoList:$.java.util.List):void;
            }
            type HisBatchDiscardApiBo_T = HisBatchDiscardApiBo_S & HisBatchDiscardApiBo$;
            interface HisBatchDiscardApiBo extends HisBatchDiscardApiBo_T {
            }
            interface HisDiscardApiBo_S {
            }
            interface HisDiscardApiBo_C extends HisDiscardApiBo_S {
                new():HisDiscardApiBo;
            }
            interface HisDiscardApiBo$ {
                /**
                 * 获取 业务id列表
                 *
                 * @return boIdSet 业务id列表
                 */
                getBoIdSet():$.java.util.Set;
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 获取 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下 批量的事务id如果有值，则单个的事务id无效
                 *
                 * @return eventId 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下 批量的事务id如果有值，则单个的事务id无效
                 */
                getEventId():long;
                /**
                 * 设置 业务id列表
                 *
                 * @param boIdSet 业务id列表
                 */
                setBoIdSet(boIdSet:$.java.util.Set):void;
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下 批量的事务id如果有值，则单个的事务id无效
                 *
                 * @param eventId 事务ID 如果有已存在的事务ID则把事务数据存到该事务ID下 批量的事务id如果有值，则单个的事务id无效
                 */
                setEventId(eventId:long):void;
            }
            type HisDiscardApiBo_T = HisDiscardApiBo_S & HisDiscardApiBo$;
            interface HisDiscardApiBo extends HisDiscardApiBo_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.api.attachment{
            interface HisAttachmentDataBo_S {
            }
            interface HisAttachmentDataBo_C extends HisAttachmentDataBo_S {
                new():HisAttachmentDataBo;
            }
            interface HisAttachmentDataBo$ {
                getEntityNumber():string;
                getMapHisAttachmentBos():$.java.util.Map;
                setEntityNumber(entityNumber:string):void;
                setMapHisAttachmentBos(mapHisAttachmentBos:$.java.util.Map):void;
            }
            type HisAttachmentDataBo_T = HisAttachmentDataBo_S & HisAttachmentDataBo$;
            interface HisAttachmentDataBo extends HisAttachmentDataBo_T {
            }
            interface HisAttachmentParamBo_S {
            }
            interface HisAttachmentParamBo_C extends HisAttachmentParamBo_S {
                new():HisAttachmentParamBo;
            }
            interface HisAttachmentParamBo$ {
                getEntityNumber():string;
                getIdSet():$.java.util.Set;
                setEntityNumber(entityNumber:string):void;
                setIdSet(idSet:$.java.util.Set):void;
            }
            type HisAttachmentParamBo_T = HisAttachmentParamBo_S & HisAttachmentParamBo$;
            interface HisAttachmentParamBo extends HisAttachmentParamBo_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.api.comparediff{
            interface CompareDiffApiOutPutParam_S {
            }
            interface CompareDiffApiOutPutParam_C extends CompareDiffApiOutPutParam_S {
                new():CompareDiffApiOutPutParam;
            }
            interface CompareDiffApiOutPutParam$ {
                /**
                 * 获取 数据库找到的相同数据
                 *
                 * @return dyFromDatabase 数据库找到的相同数据
                 */
                getDyFromDatabase():$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取 入参传入的原始数据
                 *
                 * @return dyOriginal 入参传入的原始数据
                 */
                getDyOriginal():$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 设置 数据库找到的相同数据
                 *
                 * @param dyFromDatabase 数据库找到的相同数据
                 */
                setDyFromDatabase(dyFromDatabase:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 设置 入参传入的原始数据
                 *
                 * @param dyOriginal 入参传入的原始数据
                 */
                setDyOriginal(dyOriginal:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
            }
            type CompareDiffApiOutPutParam_T = CompareDiffApiOutPutParam_S & CompareDiffApiOutPutParam$;
            interface CompareDiffApiOutPutParam extends CompareDiffApiOutPutParam_T {
            }
            interface CompareDiffApiInputParam_S {
            }
            interface CompareDiffApiInputParam_C extends CompareDiffApiInputParam_S {
                new():CompareDiffApiInputParam;
            }
            interface CompareDiffApiInputParam$ {
                /**
                 * 获取 动态对象数组 (支持同一个实体，多条数据批量传入)
                 *
                 * @return dynamicObjects 动态对象数组 (支持同一个实体，多条数据批量传入)
                 */
                getDynamicObjects():$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取 实体编码
                 *
                 * @return entityNumber 实体编码
                 */
                getEntityNumber():string;
                /**
                 * 获取 要比较差异忽略的字段， 默认字段要累加此忽略的字段
                 *
                 * @return ignoreFields 要比较差异忽略的字段， 默认字段要累加此忽略的字段
                 */
                getIgnoreFields():$.java.util.Set;
                /**
                 * 获取 要比对差异的唯一性标识字段，通过此字段去查找数据库中的数据行 非历史模型默认 用 id 历史模型默认用 boId;
                 *
                 * @return keyField 要比对差异的唯一性标识字段，通过此字段去查找数据库中的数据行 非历史模型默认 用 id 历史模型默认用 boId;
                 */
                getKeyField():string;
                /**
                 * 获取 字符型字段 null与 ""或者" " 是否相等， true：相等  false: 不相等
                 * @return
                 */
                isStringNullEqualsEmpty():boolean;
                /**
                 * 设置 动态对象数组 (支持同一个实体，多条数据批量传入)
                 *
                 * @param dynamicObjects 动态对象数组 (支持同一个实体，多条数据批量传入)
                 */
                setDynamicObjects(dynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * 设置 实体编码
                 *
                 * @param entityNumber 实体编码
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置 要比较差异忽略的字段， 默认字段要累加此忽略的字段
                 *
                 * @param ignoreFields 要比较差异忽略的字段， 默认字段要累加此忽略的字段
                 */
                setIgnoreFields(ignoreFields:$.java.util.Set):void;
                /**
                 * 设置 要比对差异的唯一性标识字段，通过此字段去查找数据库中的数据行 非历史模型默认 用 id 历史模型默认用 boId;
                 *
                 * @param keyField 要比对差异的唯一性标识字段，通过此字段去查找数据库中的数据行 非历史模型默认 用 id 历史模型默认用 boId;
                 */
                setKeyField(keyField:string):void;
                /**
                 * 设置 字符型字段 null与 ""或者" " 是否相等， true：相等  false: 不相等
                 * @param stringNullEqualsEmpty 字符型字段 null, ""或者" " 是否相等， true：相等  false: 不相等
                 */
                setStringNullEqualsEmpty(stringNullEqualsEmpty:boolean):void;
            }
            type CompareDiffApiInputParam_T = CompareDiffApiInputParam_S & CompareDiffApiInputParam$;
            interface CompareDiffApiInputParam extends CompareDiffApiInputParam_T {
            }
            interface CompareDiffApiBatchInputParam_S {
            }
            interface CompareDiffApiBatchInputParam_C extends CompareDiffApiBatchInputParam_S {
                new():CompareDiffApiBatchInputParam;
            }
            interface CompareDiffApiBatchInputParam$ {
                /**
                 * 获取 数据差异接口入参列表
                 *
                 * @return compareDiffApiInputParamList 数据差异接口入参列表
                 */
                getCompareDiffApiInputParamList():$.java.util.List;
                /**
                 * 设置 数据差异接口入参列表
                 *
                 * @param compareDiffApiInputParamList 数据差异接口入参列表
                 */
                setCompareDiffApiInputParamList(compareDiffApiInputParamList:$.java.util.List):void;
            }
            type CompareDiffApiBatchInputParam_T = CompareDiffApiBatchInputParam_S & CompareDiffApiBatchInputParam$;
            interface CompareDiffApiBatchInputParam extends CompareDiffApiBatchInputParam_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.api.revise{
            interface HisReviseRecordParamBo_S {
            }
            interface HisReviseRecordParamBo_C extends HisReviseRecordParamBo_S {
                new():HisReviseRecordParamBo;
            }
            interface HisReviseRecordParamBo$ {
                /**
                 * 获取业务id
                 * @return
                 */
                getBoId():long;
                /**
                 * 获取实体编码
                 * @return
                 */
                getEntityNumber():string;
                /**
                 * 获取版本主键列表
                 * @return
                 */
                getVersionIds():$.java.util.List;
                /**
                 * 设置业务id
                 * @param boId
                 */
                setBoId(boId:long):void;
                /**
                 * 设置
                 * @param entityNumber
                 */
                setEntityNumber(entityNumber:string):void;
                /**
                 * 设置版本主键列表
                 * @param versionIds
                 */
                setVersionIds(versionIds:$.java.util.List):void;
            }
            type HisReviseRecordParamBo_T = HisReviseRecordParamBo_S & HisReviseRecordParamBo$;
            interface HisReviseRecordParamBo extends HisReviseRecordParamBo_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.calc.api{
            interface HisInitBoApiParam_S {
            }
            interface HisInitBoApiParam_C extends HisInitBoApiParam_S {
                new():HisInitBoApiParam;
            }
            interface HisInitBoApiParam$ {
                getBoGroupFields():any;
                getDynamicObjects():$.kd.bos.dataentity.entity.DynamicObject[];
                isSkipBusinessValidate():boolean;
                isSkipDbValidate():boolean;
                isSkipHisFieldValidate():boolean;
                setBoGroupFields(boGroupFields:any):void;
                setDynamicObjects(dynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                setSkipBusinessValidate(skipBusinessValidate:boolean):void;
                setSkipDbValidate(skipDbValidate:boolean):void;
                setSkipHisFieldValidate(skipHisFieldValidate:boolean):void;
            }
            type HisInitBoApiParam_T = HisInitBoApiParam_S & HisInitBoApiParam$;
            interface HisInitBoApiParam extends HisInitBoApiParam_T {
            }
            interface HisVersionCalcApiParam_S {
            }
            interface HisVersionCalcApiParam_C extends HisVersionCalcApiParam_S {
                new():HisVersionCalcApiParam;
            }
            interface HisVersionCalcApiParam$ {
                getDynamicObject():$.kd.bos.dataentity.entity.DynamicObject;
                isValidateContinuity():boolean;
                setDynamicObject(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):void;
                setValidateContinuity(validateContinuity:boolean):void;
            }
            type HisVersionCalcApiParam_T = HisVersionCalcApiParam_S & HisVersionCalcApiParam$;
            interface HisVersionCalcApiParam extends HisVersionCalcApiParam_T {
            }
            interface HisDelVersionApiParam_S {
            }
            interface HisDelVersionApiParam_C extends HisDelVersionApiParam_S {
                new():HisDelVersionApiParam;
            }
            interface HisDelVersionApiParam$ {
                getEntityNumber():string;
                getHisDelVersionBOs():$.java.util.Set;
                getInitBatchs():$.java.util.Set;
                setEntityNumber(entityNumber:string):void;
                setHisDelVersionBOs(hisDelVersionBOs:$.java.util.Set):void;
                setInitBatchs(initBatchs:$.java.util.Set):void;
            }
            type HisDelVersionApiParam_T = HisDelVersionApiParam_S & HisDelVersionApiParam$;
            interface HisDelVersionApiParam extends HisDelVersionApiParam_T {
            }
            interface HisInitVersionApiParam_S {
            }
            interface HisInitVersionApiParam_C extends HisInitVersionApiParam_S {
                new():HisInitVersionApiParam;
            }
            interface HisInitVersionApiParam$ {
                getBoGroupFields():any;
                getDynamicObjects():$.kd.bos.dataentity.entity.DynamicObject[];
                isEffImmediately():boolean;
                isSkipBusinessValidate():boolean;
                isSkipHisFieldValidate():boolean;
                setBoGroupFields(boGroupFields:any):void;
                setDynamicObjects(dynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                setEffImmediately(effImmediately:boolean):void;
                setSkipBusinessValidate(skipBusinessValidate:boolean):void;
                setSkipHisFieldValidate(skipHisFieldValidate:boolean):void;
            }
            type HisInitVersionApiParam_T = HisInitVersionApiParam_S & HisInitVersionApiParam$;
            interface HisInitVersionApiParam extends HisInitVersionApiParam_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.enable{
            interface HisEnableParamBo_S {
            }
            interface HisEnableParamBo_C extends HisEnableParamBo_S {
                new():HisEnableParamBo;
            }
            interface HisEnableParamBo$ {
                /**
                 * 获取 启用、禁用生效时间 可以不填，默认为当天
                 *
                 * @return effectDate 启用、禁用生效时间 可以不填，默认为当天
                 */
                getEffectDate():Date;
                /**
                 * 获取 事务ID
                 *
                 * @return eventId 事务ID
                 */
                getEventId():long;
                /**
                 * 获取 实体编码 + 业务实体id列表
                 *
                 * @return hisBaseBo 实体编码 + 业务实体id列表
                 */
                getHisBaseBo():HisBaseBo;
                /**
                 * 获取 处理附件信息
                 *
                 * @return mapHisAttachmentBos 处理附件信息
                 */
                getMapHisAttachmentBos():$.java.util.Map;
                /**
                 * 获取 是否原子事务，默认为true
                 *
                 * @return atomicTrans 是否原子事务，默认为true
                 */
                isAtomicTrans():boolean;
                /**
                 * 获取 true 禁用  false 启用
                 *
                 * @return isDisabled true 禁用  false 启用
                 */
                isDisabled():boolean;
                /**
                 * 设置 是否原子事务，默认为true
                 *
                 * @param atomicTrans 是否原子事务，默认为true
                 */
                setAtomicTrans(atomicTrans:boolean):void;
                /**
                 * 设置 true 禁用  false 启用
                 *
                 * @param disabled true 禁用  false 启用
                 */
                setDisabled(disabled:boolean):void;
                /**
                 * 设置 启用、禁用生效时间 可以不填，默认为当天
                 *
                 * @param effectDate 启用、禁用生效时间 可以不填，默认为当天
                 */
                setEffectDate(effectDate:Date):void;
                /**
                 * 设置 事务ID
                 *
                 * @param eventId 事务ID
                 */
                setEventId(eventId:long):void;
                /**
                 * 设置 实体编码 + 业务实体id列表
                 *
                 * @param hisBaseBo 实体编码 + 业务实体id列表
                 */
                setHisBaseBo(hisBaseBo:HisBaseBo):void;
                /**
                 * 设置 处理附件信息
                 *
                 * @param mapHisAttachmentBos 处理附件信息
                 */
                setMapHisAttachmentBos(mapHisAttachmentBos:$.java.util.Map):void;
            }
            type HisEnableParamBo_T = HisEnableParamBo_S & HisEnableParamBo$;
            interface HisEnableParamBo extends HisEnableParamBo_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.event{
            interface HisSearchLaterEventParam_S {
            }
            interface HisSearchLaterEventParam_C extends HisSearchLaterEventParam_S {
                new():HisSearchLaterEventParam;
            }
            interface HisSearchLaterEventParam$ {
                getEventGroupNumber():string;
                getEventId():long;
                getResisterEventGroupAppId():string;
                getResisterEventGroupEntityNumber():string;
                setEventGroupNumber(eventGroupNumber:string):void;
                setEventId(eventId:long):void;
                setResisterEventGroupAppId(resisterEventGroupAppId:string):void;
                setResisterEventGroupEntityNumber(resisterEventGroupEntityNumber:string):void;
            }
            type HisSearchLaterEventParam_T = HisSearchLaterEventParam_S & HisSearchLaterEventParam$;
            interface HisSearchLaterEventParam extends HisSearchLaterEventParam_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.init{
            interface HisInitDeleteByBatchBo_S {
            }
            interface HisInitDeleteByBatchBo_C extends HisInitDeleteByBatchBo_S {
                new():HisInitDeleteByBatchBo;
            }
            interface HisInitDeleteByBatchBo$ {
                getHisInitDeleteParamBoList():$.java.util.List;
                setHisInitDeleteParamBoList(hisInitDeleteParamBoList:$.java.util.List):void;
            }
            type HisInitDeleteByBatchBo_T = HisInitDeleteByBatchBo_S & HisInitDeleteByBatchBo$;
            interface HisInitDeleteByBatchBo extends HisInitDeleteByBatchBo_T {
            }
        }
        namespace kd.hr.hbp.business.domain.model.newhismodel.task{
            interface HisSynDataStatusServicerHelper_S {
                readonly BOID:string;
                readonly IS_CURRENT_VERSION:string;
                /**
                 * 执行同步数据
                 *
                 * @param entityNumber 业务实体编码
                 * @param excludeBoId  排除的BO
                 */
                processData(entityNumber:string,excludeBoId:$.java.util.List,map:$.java.util.Map):HisSyncStatusEntityDataBo;
                synByBo(hisSyncStatusParamBo:HisSyncStatusParamBo):kd.hr.hbp.common.api.HrApiResponse;
                writeErrorLog(validateResultBoMap:$.java.util.Map):void;
            }
            interface HisSynDataStatusServicerHelper_C extends HisSynDataStatusServicerHelper_S {
                new():HisSynDataStatusServicerHelper;
            }
            interface HisSynDataStatusServicerHelper$ {
            }
            type HisSynDataStatusServicerHelper_T = HisSynDataStatusServicerHelper_S & HisSynDataStatusServicerHelper$;
            interface HisSynDataStatusServicerHelper extends HisSynDataStatusServicerHelper_T {
            }
            interface IHisSynDataStatusService_S {
            }
            interface IHisSynDataStatusService$ {
                /**
                 * 后置方法-用于子类复写
                 *
                 * @param appIds   appIds
                 */
                afterSyn(appIds:$.java.util.List):void;
                /**
                 * 前置方法-用于子类复写
                 *
                 * @param appIds   appIds
                 */
                beforeSyn(appIds:$.java.util.List):void;
                /**
                 * 法-用于子类复写
                 *
                 * @param appIds   appIds
                 */
                syn(appIds:$.java.util.List):void;
                synByBo?(hisSyncStatusParamBo:HisSyncStatusParamBo):void;
            }
            type IHisSynDataStatusService_T = IHisSynDataStatusService_S & IHisSynDataStatusService$;
            interface IHisSynDataStatusService extends IHisSynDataStatusService_T {
            }
            interface HisSyncStatusEntityDataBo_S {
            }
            type HisSyncStatusEntityDataBo_ST = $.java.io.Serializable & HisSyncStatusEntityDataBo_S;
            interface HisSyncStatusEntityDataBo_C extends HisSyncStatusEntityDataBo_ST {
                new():HisSyncStatusEntityDataBo;
            }
            interface HisSyncStatusEntityDataBo$ {
                getBoIds():$.java.util.List;
                getEntityNumber():string;
                setBoIds(boIds:$.java.util.List):void;
                setEntityNumber(entityNumber:string):void;
            }
            type HisSyncStatusEntityDataBo_T = $.java.io.Serializable & HisSyncStatusEntityDataBo_S & HisSyncStatusEntityDataBo$;
            interface HisSyncStatusEntityDataBo extends HisSyncStatusEntityDataBo_T {
            }
            interface HisSyncStatusParamBo_S {
            }
            type HisSyncStatusParamBo_ST = $.java.io.Serializable & HisSyncStatusParamBo_S;
            interface HisSyncStatusParamBo_C extends HisSyncStatusParamBo_ST {
                new():HisSyncStatusParamBo;
            }
            interface HisSyncStatusParamBo$ {
                getAppIds():$.java.util.List;
                getExcludeBoIdMap():$.java.util.Map;
                getIgnoreEntities():$.java.util.List;
                setAppIds(appIds:$.java.util.List):void;
                setExcludeBoIdMap(excludeBoIdMap:$.java.util.Map):void;
                setIgnoreEntities(ignoreEntities:$.java.util.List):void;
            }
            type HisSyncStatusParamBo_T = $.java.io.Serializable & HisSyncStatusParamBo_S & HisSyncStatusParamBo$;
            interface HisSyncStatusParamBo extends HisSyncStatusParamBo_T {
            }
        }
        namespace kd.hr.hbp.business.domain.repository{
            interface HisCommonEntityRepository_S {
                /**
                 * 根据id查询所有数据
                 *
                 * @param helper
                 * @param dataEntities
                 * @return DynamicObject[]
                 */
                byIdsAllFieldDys(helper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,dataEntities:$.kd.bos.dataentity.entity.DynamicObject[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 是否存在有效的当前数据
                 *
                 * @param serviceHelper
                 * @param boId
                 * @return
                 */
                exitsOldCurrentData(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:long):boolean;
                /**
                 * 根据 boId 查询所有的有效数据
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @return
                 */
                getAllCurrentValidDataByBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询出带实体标识的DynamicObject
                 *
                 * @param busiServiceHelper
                 * @param id
                 * @return
                 */
                getAllFieldsDy(busiServiceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,id:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 根据 boId 查询 有待生效的版本的 boid
                 *
                 * @param serviceHelper serviceHelper
                 * @param dys           动态对象数组
                 * @return Set
                 */
                getAllToBeEffectBoIdByBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,dys:$.kd.bos.dataentity.entity.DynamicObject[]):$.java.util.Set;
                /**
                 * 查询待确认数据：有待生效数据版本的数据（仅有一个待生效数据版本的数据不算）
                 *
                 * @param serviceHelper serviceHelper
                 * @param boIds         boIds
                 * @param disableDate   disableDate
                 * @return Set
                 */
                getAllToBeEffectBoIdByBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.Collection,disableDate:Date):$.java.util.Set;
                /**
                 * 查询某个实体是否允存在多个待生效的数据版本
                 *
                 * @param entityNum 实体编码
                 * @return 是否允存在多个待生效的数据版本
                 */
                getAllowMultiToBeEffData(entityNum:string):boolean;
                /**
                 * 根据应用查询注册事务组
                 *
                 * @param appId 实体编码集合
                 * @return 应用事务组注册对象
                 */
                getAppDefaultEventDy(appId:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 根据应用查询注册事务组
                 *
                 * @param appIds 实体编码集合
                 * @return 应用事务组注册对象
                 */
                getAppDefaultEventDys(appIds:string[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询附件信息
                 *
                 * @param serviceHelper
                 * @param id
                 * @return DynamicObject[]
                 */
                getAttachments(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,id:long):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 根据 事务ID查询事务信息
                 *
                 * @param serviceHelper
                 * @param eventId
                 * @return
                 */
                getBusEventByEventId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,eventId:long):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 根据boid查询生效中的数据
                 *
                 * @param serviceHelper
                 * @param boids
                 * @return DynamicObject[]
                 */
                getBusiDysByBoid(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boids:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 根据事务id和实体编码查询已执行的业务事务关系对象
                 *
                 * @param busiEventHelper
                 * @param eventId
                 * @param entityNumber
                 * @param boIdList
                 * @return DynamicObject[]
                 */
                getBusiEventDys(busiEventHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,eventId:long,entityNumber:string,boIdList:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询当前版本数据的id和masterid
                 *
                 * @param busiServiceHelper
                 * @param boid
                 * @return
                 */
                getCurrentDy(busiServiceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boid:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 查询当前版本数据的id和masterid
                 *
                 * @param serviceHelper
                 * @param boid
                 * @return
                 */
                getCurrentDyName(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boid:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 查询基础资料历史列表中当前行的失效日期
                 *
                 * @param entityNum 实体编码
                 * @param pkId      主键id
                 * @return 失效日期
                 */
                getCurrentRowBsled(entityNum:string,pkId:any):Date;
                /**
                 * 获取当前数据的 生效日期
                 *
                 * @param serviceHelper
                 * @param boId
                 * @return
                 */
                getCurrentVersionEffStartDate(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:long):Date;
                /**
                 * 根据ID查询失效日期
                 *
                 * @param serviceHelper
                 * @param idSet
                 * @return
                 */
                getEffEndDateByIds(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,idSet:$.java.util.Set):$.java.util.Map;
                /**
                 * 根据ID查询暂存数据的生效日期
                 *
                 * @param serviceHelper
                 * @param idSet
                 * @return
                 */
                getEffStartDateByIds(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,idSet:$.java.util.Set):$.java.util.Map;
                /**
                 * 某个日期后是否存在有效的数据版本
                 *
                 * @param entityNum 实体编码
                 * @param boId      业务数据id
                 * @param date      Date
                 * @return 是否存在
                 */
                getEffectVersionAfterDate(entityNum:string,boId:any,date:Date):boolean;
                /**
                 * 是否存在生效的数据
                 *
                 * @param serviceHelper
                 * @param idSet
                 * @return
                 */
                getEffectVersionBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,idSet:$.java.util.Set):$.java.util.Set;
                /**
                 * 获取实体对应应用
                 *
                 * @param entityNumber 实体编码集合
                 * @return 实体对应应用对象
                 */
                getEntityToAppDy(entityNumber:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取实体对应应用
                 *
                 * @param entityNumberList 实体编码集合
                 * @return 实体对应应用对象
                 */
                getEntityToAppDys(entityNumberList:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 根据实体编码查询注册事务组
                 *
                 * @param entityNumber 实体编码
                 * @return 实体事务组注册对象
                 */
                getEntityToEventDy(entityNumber:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 根据实体编码集合查询注册事务组
                 *
                 * @param entityNumberList 实体编码集合
                 * @return 实体事务组注册对象
                 */
                getEntityToEventDys(entityNumberList:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 根据id查询事务对象
                 *
                 * @param eventHelper
                 * @param eventId
                 * @return dy
                 */
                getEventById(eventHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,eventId:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 根据id查询事务对象
                 *
                 * @param eventHelper
                 * @param eventIds
                 * @return dy
                 */
                getEventByIds(eventHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,eventIds:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject[];
                getExistsBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.Set):$.java.util.Set;
                /**
                 * 根据业务事务关系id获取历史版本对象
                 *
                 * @param hisEventHelper
                 * @param busiEventIds
                 * @return DynamicObject[]
                 */
                getHisEventDys(hisEventHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,busiEventIds:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 根据字段标识获取字段名
                 *
                 * @param uniqueValidatorBos 校验器bo集合
                 * @param entity             实体
                 * @return HashMap<String, String> k:字段标识，v:字段名称
                 */
                getNameByIdentify(uniqueValidatorBos:$.java.util.ArrayList,entity:string):$.java.util.HashMap;
                /**
                 * 获取非时序性数据
                 *
                 * @param busiServiceHelper
                 * @param id
                 * @return
                 */
                getNonLineDy(busiServiceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,id:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取非时序性关联当前生效版本数据
                 *
                 * @param busiServiceHelper
                 * @param boid
                 * @return
                 */
                getNonLineRelCurEffectingDy(busiServiceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boid:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取非时序性关联当前生效版本数据
                 *
                 * @param busiServiceHelper
                 * @param boids
                 * @return
                 */
                getNonLineRelCurEffectingDy(busiServiceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boids:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取非时序性关联生效版本数据
                 *
                 * @param busiServiceHelper
                 * @param boidList
                 * @return
                 */
                getNonLineRelEffectingDy(busiServiceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boidList:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取非时序性该bo下的所有数据
                 *
                 * @param serviceHelper
                 * @param boId
                 * @return
                 */
                getNonLineTimeByBoid(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取非时序性暂存版本数据，只有一条
                 *
                 * @param serviceHelper
                 * @param boId
                 * @return
                 */
                getNonLineTimeTempByBoid(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 取当前版本数据 数组
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @return
                 */
                getOldCurrentDataArray(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询旧的版本数据生失效日期区间
                 *
                 * @param serviceHelper
                 * @param boIdSet
                 * @return
                 */
                getOldEffVersionsByBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIdSet:$.java.util.Set):$.java.util.Map;
                /**
                 * 是否有暂存的数据版本，用来填充字段"是否变更中"
                 *
                 * @param serviceHelper
                 * @param idList        排除传递过来的暂存版本
                 * @param boIds
                 * @return
                 */
                getRestTempData(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,idList:$.java.util.List,boIds:$.java.util.Set):$.java.util.Set;
                /**
                 * 取版本数据行中，effDate所有时间段的失效时间
                 *
                 * @param serviceHelper
                 * @param pkIds
                 * @param mapBoIdGroupData
                 * @return
                 */
                getTempVersionEffEndDate(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,pkIds:$.java.util.List,mapBoIdGroupData:$.java.util.Map):void;
                /**
                 * 根据字段标识获取字段类型
                 *
                 * @param uniqueValidatorBos 校验器bo集合
                 * @param entity             实体
                 * @return HashMap<String, String> K:字段，V：字段类型
                 */
                getTypeByIdentify(uniqueValidatorBos:$.java.util.ArrayList,entity:string):$.java.util.HashMap;
                /**
                 * 根据日期获取有用的版本
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @param date
                 * @return
                 */
                getValidDataVersionByDate(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.List,date:Date):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 取版本数据行中，effDate所有时间段的失效时间 ,  用 group by , min 可以数据传输量
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @param effDate
                 * @return
                 */
                getVersionEffEndDate(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.List,effDate:Date):$.java.util.Map;
                /**
                 * 根据boId，查询版本id
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @return
                 */
                getVersionIdsByBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:long[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取版本号
                 *
                 * @param serviceHelper serviceHelper
                 * @param boIdSet       boIdSet
                 * @return Map<Long, List < String>>
                 */
                getVersionNumber(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIdSet:$.java.util.Set):$.java.util.Map;
                /**
                 * 根据qfilter查询所有属性
                 *
                 * @param entity  实体
                 * @param qFilter 过滤条件
                 * @return DynamicObject[]
                 */
                loadDynamicObjectArray(entity:string,qFilter:$.kd.bos.orm.query.QFilter):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取所有有效的版本数据、当前数据
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @return
                 */
                loadOldEffDataByBoIds(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询所有生效版本，并排序
                 *
                 * @param serviceHelper
                 * @param boId
                 */
                loadOldEffVersionByBoIdWithoutNoInit(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:long):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取所有有效的版本数据
                 *
                 * @param serviceHelper
                 * @param boIds
                 * @return
                 */
                loadOldEffVersionByBoIds(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询所有生效版本
                 *
                 * @param serviceHelper
                 * @param boIds
                 */
                loadOldEffVersionByBoIdsWithoutNoInit(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boIds:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject[];
                queryCurrentDataForEffDate(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,ids:$.java.util.Collection):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 查询业务数据对象
                 *
                 * @param entityNum 实体编码
                 * @param id        数据主键
                 * @return 动态对象
                 */
                queryHisLineDy(entityNum:string,id:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 查询业务数据的部分字段
                 *
                 * @param entityNum     实体编码
                 * @param id            数据主键
                 * @param selectedProps 查询字段
                 * @return 动态对象
                 */
                queryHisLineDy(entityNum:string,id:any,selectedProps:string):$.kd.bos.dataentity.entity.DynamicObject;
                queryOldEffVersionEffDateByBoId(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:long):$.java.util.Map;
                queryOldEffVersionEffDateByBoIdNew(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,boId:long):$.java.util.List;
                queryOriginalArray(entity:string,qFilter:$.kd.bos.orm.query.QFilter,validation:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 历史实体查询
                 *
                 * @param entity           实体
                 * @param qFilter          过滤条件
                 * @param selectProperties 查询属性
                 * @return DynamicObject[]
                 */
                queryOriginalArray(entity:string,qFilter:$.kd.bos.orm.query.QFilter,selectProperties:string):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 历史实体查询
                 *
                 * @param entity           实体
                 * @param qFilters         过滤条件集合
                 * @param selectProperties 查询属性
                 * @return DynamicObject[]
                 */
                queryOriginalArray(entity:string,qFilters:$.java.util.List,selectProperties:string):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 历史实体查询
                 *
                 * @param entity           实体
                 * @param qFilter          过滤条件
                 * @param selectProperties 查询属性
                 * @return DynamicObject[]
                 */
                queryOriginalOne(entity:string,qFilter:$.kd.bos.orm.query.QFilter,selectProperties:string):$.kd.bos.dataentity.entity.DynamicObject;
            }
            interface HisCommonEntityRepository_C extends HisCommonEntityRepository_S {
                new():HisCommonEntityRepository;
            }
            interface HisCommonEntityRepository$ {
            }
            type HisCommonEntityRepository_T = HisCommonEntityRepository_S & HisCommonEntityRepository$;
            interface HisCommonEntityRepository extends HisCommonEntityRepository_T {
            }
            interface HisSyncDataStatusRepository_S {
                getInstance():HisSyncDataStatusRepository;
            }
            interface HisSyncDataStatusRepository_C extends HisSyncDataStatusRepository_S {
                new():HisSyncDataStatusRepository;
            }
            interface HisSyncDataStatusRepository$ {
                getDataSet(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,qf:$.kd.bos.orm.query.QFilter,selectFields:string):$.kd.bos.algo.DataSet;
                getEntityMata(metaHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,appIds:$.java.util.List,parentFilter:$.kd.bos.orm.query.QFilter):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 获取关联的前置实体dataSet(实体依赖用)
                 *
                 * @param serviceHelper
                 * @return
                 */
                getJoinDataSet(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper,selectFields:string):$.kd.bos.algo.DataSet;
                /**
                 * 双表关联查询前置依赖实体生效状态
                 *
                 * @param joinDataSet
                 * @param conditionMap
                 * @return
                 */
                getJoinEntityStatus(dataSet:$.kd.bos.algo.DataSet,joinDataSet:$.kd.bos.algo.DataSet,conditionMap:$.java.util.Map,isVersion:boolean):$.java.util.Map;
                /**
                 * 取需要同步处理的数据的 boid, 分批处理
                 *
                 * @param serviceHelper
                 * @return
                 */
                getNeedSyncVersion(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper):$.java.util.List;
                /**
                 * 取需要同步处理的数据的 boid, 分批处理
                 *
                 * @param serviceHelper
                 * @return
                 */
                getNeedSyncVersionDataSet(serviceHelper:kd.hr.hbp.business.servicehelper.HRBaseServiceHelper):$.kd.bos.algo.DataSet;
            }
            type HisSyncDataStatusRepository_T = HisSyncDataStatusRepository_S & HisSyncDataStatusRepository$;
            interface HisSyncDataStatusRepository extends HisSyncDataStatusRepository_T {
            }
        }
        namespace kd.hr.hbp.business.domain.service.attachment{
            interface HisAttachmentService_S {
                /**
                 * 新增历史版本与当前版本附件
                 *
                 * @param jsonString
                 * @param existId
                 * @param copyId
                 * @param formId
                 */
                addDyAttachments(jsonString:string,existId:long,copyId:long,formId:string):void;
                /**
                 * 事务结束后处理附件
                 *
                 * @param operateOption OperateOption
                 */
                afterOpHandleAttachment(entityId:string,operateOption:$.kd.bos.dataentity.OperateOption):void;
                /**
                 * 通过附件信息的 json串组装附件对象 （分组的情况）
                 *
                 * @param jsonString 件信息的json
                 * @return Map<Long, List < HisAttachmentBo>>
                 */
                buildHisAttachmentBoList(jsonString:string):$.java.util.Map;
                /**
                 * 重构UID
                 * @param originUid
                 * @return
                 */
                buildNewUid(originUid:string):string;
                /**
                 * 复制一个动态对象的附件, 默认不清空旧数据下的所有附件
                 *
                 * @param copyObjId 复制的对象的id
                 * @param entityNum 复制对象的实体编码
                 * @param boList    附件信息
                 */
                copyAttachments(copyObjId:long,entityNum:string,boList:$.java.util.List):$.java.util.List;
                /**
                 * 复制一个动态对象的附件
                 *
                 * @param copyObjId 复制的对象的id
                 * @param entityNum 复制对象的实体编码
                 * @param boList    附件信息
                 * @param remove    是否需要清空旧数据下的所有附件
                 * @return 复制后的附件对象集合
                 */
                copyAttachments(copyObjId:long,entityNum:string,boList:$.java.util.List,remove:boolean):$.java.util.List;
                /**
                 * 删除当前版本原来所关联的附件
                 *
                 * @param dataEntity
                 */
                deleteCurDyAttachments(dataEntity:$.kd.bos.dataentity.entity.DynamicObject):void;
                generateAttachmentBo(attachKey:string,formId:string,pkId:long,attach:$.java.util.List,hisAttachBoMap:$.java.util.Map):void;
                generateAttachmentListMapById(dataIds:$.java.util.Set,entityNumber:string):$.java.util.Map;
                generateAttachmentMap(dataCol:$.kd.bos.dataentity.entity.DynamicObject[]):$.java.util.List;
                generateAttachmentMap(hisAttachmentParamBo:kd.hr.hbp.business.domain.model.newhismodel.api.attachment.HisAttachmentParamBo):kd.hr.hbp.business.domain.model.newhismodel.HisResponse;
                /**
                 * 根据ID 查询附件，并组装成 List数据
                 *
                 * @param dataIds
                 * @param entityNumber
                 * @return
                 */
                generateAttachmentMapById(dataIds:$.java.util.Set,entityNumber:string):$.java.util.List;
                /**
                 * 根据ID 查询附件
                 *
                 * @param dataIds
                 * @param entityNumber
                 * @return
                 */
                generateAttachmentMapByIdString(dataIds:$.java.util.Set,entityNumber:string):$.java.util.List;
                /**
                 * 查询单据上所有附件信息，封装成对象存入op参数
                 *
                 * @param dataCol 单据数据
                 * @param option  option
                 */
                getAttachmentsInfo(dataCol:$.kd.bos.dataentity.entity.DynamicObject[],option:$.kd.bos.dataentity.OperateOption):void;
                /**
                 * 序列化附件信息（不分组的情况）
                 *
                 * @param operateOption OperateOption
                 * @return List<HisAttachmentBo>
                 */
                getHisAttachmentBoListFromOpParam(operateOption:$.kd.bos.dataentity.OperateOption):$.java.util.List;
                handleTempAttachments(dataCol:$.kd.bos.dataentity.entity.DynamicObject[],operateOption:$.kd.bos.dataentity.OperateOption):void;
                /**
                 * 处理附件
                 *
                 * @param hisAttachmentSourceIdBoList
                 * @param entityNumber
                 */
                processAttachment(hisAttachmentSourceIdBoList:$.java.util.List,entityNumber:string):$.java.util.Map;
                /**
                 * 处理附件
                 *
                 * @param hisAttachmentSourceIdBoList
                 * @param mapHisAttachmentBos
                 */
                processAttachment(hisAttachmentSourceIdBoList:$.java.util.List,mapHisAttachmentBos:$.java.util.Map,entityNumber:string):$.java.util.Map;
                saveHisLineAttachmentsForOp(dy:$.kd.bos.dataentity.entity.DynamicObject,option:$.kd.bos.dataentity.OperateOption):void;
                /**
                 * 在op插件中保存页面上暂存的附件
                 *
                 * @param dy     当前页面的数据
                 * @param option option
                 */
                saveTempAttachments(dy:$.kd.bos.dataentity.entity.DynamicObject,option:$.kd.bos.dataentity.OperateOption):void;
                /**
                 * 在op插件中保存页面上暂存的附件
                 *
                 * @param dy     当前页面的数据
                 * @param option option
                 * @param remove 是否删除原来所关联的附件
                 */
                saveTempAttachments(dy:$.kd.bos.dataentity.entity.DynamicObject,option:$.kd.bos.dataentity.OperateOption,remove:boolean):void;
                /**
                 * 将平台的附件转换成历史模型需要的数据类型
                 *
                 * @param attachMapList
                 * @param entityNUmber
                 * @return
                 */
                transAttachmentsInfo(attachMapList:$.java.util.List,entityNUmber:string):$.java.util.Map;
                /**
                 * 将平台的附件转换成历史模型需要的数据类型( list)
                 *
                 * @param attachMapList
                 * @param entityNUmber
                 * @param strSourceId
                 * @return
                 */
                transAttachmentsInfoToList(attachMapList:$.java.util.List,entityNUmber:string,strSourceId:string):$.java.util.List;
                /**
                 * 上传附件，根据历史模型参数
                 *
                 * @param hisAttachmentDataBo 实体附件数据BO
                 */
                uploadAttachmentMap(hisAttachmentDataBo:kd.hr.hbp.business.domain.model.newhismodel.api.attachment.HisAttachmentDataBo):void;
                uploadReviseAttachment(operateOption:$.kd.bos.dataentity.OperateOption):void;
            }
            interface HisAttachmentService_C extends HisAttachmentService_S {
                new():HisAttachmentService;
            }
            interface HisAttachmentService$ {
            }
            type HisAttachmentService_T = HisAttachmentService_S & HisAttachmentService$;
            interface HisAttachmentService extends HisAttachmentService_T {
            }
        }
        namespace kd.hr.hbp.business.domain.service.impl.newhismodel.hisversion{
            interface HisVersionNumberService_S {
                /**
                 * 双重检查加锁 懒汉式
                 *
                 * @return HisVersionNumberService
                 */
                getInstance():HisVersionNumberService;
            }
            interface HisVersionNumberService_C extends HisVersionNumberService_S {
                new():HisVersionNumberService;
            }
            interface HisVersionNumberService$ {
                /**
                 * 计算版本号, 并保存数据
                 *
                 * @param entityNumber 实体编码
                 * @param dataCol      DynamicObject[]
                 */
                calcVersionNumber(entityNumber:string,dataCol:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * 计算版本号, 并保存数据
                 *
                 * @param entityNumber 实体编码
                 * @param dataCol      DynamicObject[]
                 */
                calcVersionNumber(entityNumber:string,dataCol:$.kd.bos.dataentity.entity.DynamicObject[],cancel_notSupported:boolean):void;
            }
            type HisVersionNumberService_T = HisVersionNumberService_S & HisVersionNumberService$;
            interface HisVersionNumberService extends HisVersionNumberService_T {
            }
        }
        namespace kd.hr.hbp.business.domain.util{
            interface HisModelNonEventUtil_S {
                /**
                 * 存放上一版本
                 *
                 * @param dy        变更前对象
                 * @return relMap   map集合，存放业务ID和前数据版本状态
                 */
                getRelToEventMap(dy:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
                /**
                 * 保存事务
                 *
                 * @param entityNumber      实体编码
                 * @param dynamicObjects    业务数据
                 * @param effectRelMap      关联历史版本集合
                 * @return Map<String, Object>
                 */
                saveNonDatasEvent(entityNumber:string,dynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[],effectRelMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 保存事务
                 *
                 * @param entityNumber      实体编码
                 * @param dynamicObjects    业务数据
                 * @param effectRelMap      关联历史版本集合
                 * @param eventId           事务id
                 * @return Map<String, Object>
                 */
                saveNonDatasEvent(entityNumber:string,dynamicObjects:$.kd.bos.dataentity.entity.DynamicObject[],effectRelMap:$.java.util.Map,eventId:long):$.java.util.Map;
            }
            interface HisModelNonEventUtil_C extends HisModelNonEventUtil_S {
                new():HisModelNonEventUtil;
            }
            interface HisModelNonEventUtil$ {
            }
            type HisModelNonEventUtil_T = HisModelNonEventUtil_S & HisModelNonEventUtil$;
            interface HisModelNonEventUtil extends HisModelNonEventUtil_T {
            }
        }
        namespace kd.hr.hbp.business.extpoint.permission.dyna{
            interface RuleMatchBO_S {
            }
            interface RuleMatchBO_C extends RuleMatchBO_S {
                new():RuleMatchBO;
            }
            interface RuleMatchBO$ {
                getBizDataMap():$.java.util.Map;
                getConditionMap():$.java.util.Map;
                getRuleParamMap():$.java.util.Map;
                setBizDataMap(bizDataMap:$.java.util.Map):void;
                setConditionMap(conditionMap:$.java.util.Map):void;
                setRuleParamMap(ruleParamMap:$.java.util.Map):void;
            }
            type RuleMatchBO_T = RuleMatchBO_S & RuleMatchBO$;
            interface RuleMatchBO extends RuleMatchBO_T {
            }
            interface IPermRuleMatchPlugin_S {
            }
            interface IPermRuleMatchPlugin$ {
                /**
                 * 匹配规则
                 *
                 * @param ruleMatchBO bo
                 * @return {key:方案id,value:{key:业务数据id,value:BO}}
                 */
                matchRule(ruleMatchBO:RuleMatchBO):$.java.util.Map;
            }
            type IPermRuleMatchPlugin_T = IPermRuleMatchPlugin_S & IPermRuleMatchPlugin$;
            interface IPermRuleMatchPlugin extends IPermRuleMatchPlugin_T {
            }
        }
        namespace kd.hr.hbp.business.extpoint.permission.hradmi{
            interface IAdminGroupListSubPlugin_S {
            }
            interface IAdminGroupListSubPlugin$ {
                /**
                 * 插件事件方法：业务逻辑执行时触发，重写此方法，可为用户F7添加自定义过滤器
                 *
                 * @param lsp 列表展示参数
                 */
                customUserF7ShowParameter?(lsp:$.kd.bos.list.ListShowParameter):void;
            }
            type IAdminGroupListSubPlugin_T = IAdminGroupListSubPlugin_S & IAdminGroupListSubPlugin$;
            interface IAdminGroupListSubPlugin extends IAdminGroupListSubPlugin_T {
            }
            interface AdminGroupPermSubBO_S {
            }
            interface AdminGroupPermSubBO_C extends AdminGroupPermSubBO_S {
                new():AdminGroupPermSubBO;
                new(model:$.kd.bos.entity.datamodel.IDataModel,view:$.kd.bos.form.IFormView):AdminGroupPermSubBO;
            }
            interface AdminGroupPermSubBO$ {
                getModel():$.kd.bos.entity.datamodel.IDataModel;
                getView():$.kd.bos.form.IFormView;
                setModel(model:$.kd.bos.entity.datamodel.IDataModel):void;
                setView(view:$.kd.bos.form.IFormView):void;
            }
            type AdminGroupPermSubBO_T = AdminGroupPermSubBO_S & AdminGroupPermSubBO$;
            interface AdminGroupPermSubBO extends AdminGroupPermSubBO_T {
            }
            interface IAdminGroupPermSubPlugin_S {
                readonly FLAG_SAVE_VALIDATE:string;
            }
            interface IAdminGroupPermSubPlugin$ {
                /**
                 * 插件事件方法：业务逻辑执行完后触发，同步处理其他数据
                 */
                afterSave?(bo:AdminGroupPermSubBO):void;
                /**
                 * 插件事件方法：业务逻辑执行前触发，提前准备参数，检查数据
                 *
                 * @param bo bean
                 * @return 是否通过校验
                 */
                beforeSave?(bo:AdminGroupPermSubBO):boolean;
                /**
                 * 插件事件方法：业务逻辑执行时触发，重写此方法，可改写业务实现逻辑
                 */
                doSave?(bo:AdminGroupPermSubBO):void;
            }
            type IAdminGroupPermSubPlugin_T = IAdminGroupPermSubPlugin_S & IAdminGroupPermSubPlugin$;
            interface IAdminGroupPermSubPlugin extends IAdminGroupPermSubPlugin_T {
            }
        }
        namespace kd.hr.hbp.business.extpoint.permission.role{
            interface IRoleAssignMemCusPlugin_S {
            }
            interface IRoleAssignMemCusPlugin$ {
                customPermFileF7?(lsp:$.kd.bos.list.ListShowParameter):void;
            }
            type IRoleAssignMemCusPlugin_T = IRoleAssignMemCusPlugin_S & IRoleAssignMemCusPlugin$;
            interface IRoleAssignMemCusPlugin extends IRoleAssignMemCusPlugin_T {
            }
            interface IMemAssignRoleCusPlugin_S {
            }
            interface IMemAssignRoleCusPlugin$ {
                customRoleF7?(showParameter:$.kd.bos.list.ListShowParameter):void;
            }
            type IMemAssignRoleCusPlugin_T = IMemAssignRoleCusPlugin_S & IMemAssignRoleCusPlugin$;
            interface IMemAssignRoleCusPlugin extends IMemAssignRoleCusPlugin_T {
            }
            interface IExportRolePermCusPlugin_S {
            }
            interface IExportRolePermCusPlugin$ {
                buildPermFileFilter():$.kd.bos.orm.query.QFilter;
            }
            type IExportRolePermCusPlugin_T = IExportRolePermCusPlugin_S & IExportRolePermCusPlugin$;
            interface IExportRolePermCusPlugin extends IExportRolePermCusPlugin_T {
            }
            interface IRoleDimF7CustomFilterPlugin_S {
            }
            interface IRoleDimF7CustomFilterPlugin$ {
                /**
                 *  @param evt
                 * @param currentHRbuCaFunc 当前职能
                 * @param dimId
                 */
                addBDDimCustomFilters(evt:$.kd.bos.form.field.events.BeforeF7SelectEvent,currentHRbuCaFunc:string,dimId:string):void;
                /**
                 * +
                 *
                 *  @param currentHRbuFunc 当前职能
                 *  @param dimId     维度id
                 *  @param enumMap      枚举值分录
                 */
                addEnumDimCustomFilters(currentHRbuFunc:string,dimId:string,enumMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 是否启用{不限}复选框
                 *
                 * @param currentHRbuFunc 职能
                 * @param dimId 维度
                 * @param originalValue 标品中复选框是否启用(查看状态下=false 编辑状态下=true)
                 * @return true=启用 false=禁用
                 */
                enableNotLimitCheckBox(currentHRbuFunc:string,dimId:string,originalValue:boolean):boolean;
                /**
                 * 业务组织、行政类组织团队、职能类型维度、通用树形 后处理器
                 * @param treeNodes 树形结构数据模型
                 * @return 处理后的数据模型
                 */
                postProcessTreeNode?(treeNodes:$.java.util.List,customParams:$.java.util.Map):$.java.util.List;
            }
            type IRoleDimF7CustomFilterPlugin_T = IRoleDimF7CustomFilterPlugin_S & IRoleDimF7CustomFilterPlugin$;
            interface IRoleDimF7CustomFilterPlugin extends IRoleDimF7CustomFilterPlugin_T {
            }
            interface IRoleMemCusListPlugin_S {
            }
            interface IRoleMemCusListPlugin$ {
                /**
                 * @return 角色成员过滤器，按照hrcs_userrolerelat中属性进行过滤
                 */
                filterRoleMemList():$.java.util.List;
            }
            type IRoleMemCusListPlugin_T = IRoleMemCusListPlugin_S & IRoleMemCusListPlugin$;
            interface IRoleMemCusListPlugin extends IRoleMemCusListPlugin_T {
            }
            interface ISchemeParamRuleCustomFilterPlugin_S {
            }
            interface ISchemeParamRuleCustomFilterPlugin$ {
                /**
                 * 枚举结果值支持二开过滤范围值
                 * @return map key:规则参数number ,value:对应枚举信息的key List
                 */
                addParamRuleEnumValueCustomFilters():$.java.util.Map;
                /**
                 * 基础资料及组织结果值支持二开过滤范围值
                 *  @return map key:规则参数number ,value:QFilter
                 */
                addParamRuleF7ValueCustomFilters():$.java.util.Map;
            }
            type ISchemeParamRuleCustomFilterPlugin_T = ISchemeParamRuleCustomFilterPlugin_S & ISchemeParamRuleCustomFilterPlugin$;
            interface ISchemeParamRuleCustomFilterPlugin extends ISchemeParamRuleCustomFilterPlugin_T {
            }
        }
        namespace kd.hr.hbp.business.extpoint.strategy{
            interface IStrategyExtService_S {
            }
            interface IStrategyExtService$ {
                /**
                 * 根据管理关系策略批量查询组织/员工所属业务单元（二开扩展）
                 *
                 * @param extParams 拓展参数
                 * @param result    map
                 *                  Key:adminOrgId，value：行政组织id
                 *                  Key:businessTypeId，value：业务类型id
                 *                  Key:hrBuId，value：默认业务单元id
                 * @return map
                 * Key:adminOrgId，value：行政组织id
                 * Key:businessTypeId，value：业务类型id
                 * Key:hrBuId，value：默认业务单元id
                 */
                getHRBUByBusinessTypeForExt?(result:$.java.util.List,extParams:$.java.util.Map):$.java.util.List;
                /**
                 * 根据管理关系策略查询人员所属业务单元（二开扩展）
                 *
                 * @param orgId               组织id
                 * @param bussinessFieldRelId 业务类型关系id
                 * @param extParams           拓展参数
                 * @return 人员所属业务单元
                 */
                getHRBUFromManageEmpStrategyForExt?(orgId:long,bussinessFieldRelId:long,extParams:$.java.util.Map,result:$.java.util.Map):$.java.util.Map;
                /**
                 * 根据管理关系策略查询组织所属业务单元（二开扩展）
                 *
                 * @param orgId               组织id
                 * @param bussinessFieldRelId 业务类型关系id
                 * @param extParams           拓展参数
                 * @return 人员所属业务单元
                 */
                getHRBUFromManageOrgStrategyForExt?(orgId:long,bussinessFieldRelId:long,extParams:$.java.util.Map,result:$.java.util.Map):$.java.util.Map;
            }
            type IStrategyExtService_T = IStrategyExtService_S & IStrategyExtService$;
            interface IStrategyExtService extends IStrategyExtService_T {
            }
        }
        namespace kd.hr.hbp.business.function_{
            interface HRDefineFunction_S {
            }
            type HRDefineFunction_ST = $.java.lang.Cloneable & HRDefineFunction_S;
            interface HRDefineFunction_C extends HRDefineFunction_ST {
                new():HRDefineFunction;
            }
            interface HRDefineFunction$ {
                /**
                 * Overrides Cloneable
                 */
                clone():any;
                /**
                 * 两个整数相除
                 *
                 * @param param1
                 * @param param2
                 * @return
                 * @throws Exception
                 */
                divide(param1:number,param2:number):$.java.math.BigDecimal;
                /**
                 * 两个数值相除
                 *
                 * @param param1
                 * @param param2
                 * @return
                 * @throws Exception
                 */
                divide(param1:$.java.math.BigDecimal,param2:$.java.math.BigDecimal):$.java.math.BigDecimal;
                /**
                 * 将对象转换为逻辑数组
                 *
                 * @param obj: 对象
                 * @return java.lang.Boolean[]
                 * @throw
                 */
                getBooleanArray(obj:any):boolean[];
                /**
                 * 将对象转换为日期数组
                 *
                 * @param obj: 对象
                 * @return java.util.Date[]
                 * @throw
                 */
                getDateArray(obj:any):Date[];
                /**
                 * 将对象转换为整数数组
                 *
                 * @param obj: 对象
                 * @return java.lang.Integer[]
                 * @throw
                 */
                getIntArray(obj:any):number[];
                gt(date1:Date,date2:Date):boolean;
                gt(param1:$.java.util.Calendar,param2:$.java.util.Calendar):boolean;
                gt(value1:number,value2:number):boolean;
                gt(value1:$.java.math.BigDecimal,value2:$.java.math.BigDecimal):boolean;
                /**
                 * 日期1是否大于日期2
                 *
                 * @param date1:                  日期1
                 * @param date2:                  日期2
                 * @param checkHourMinSec:是否比较时分秒
                 * @return boolean
                 */
                gt(date1:Date,date2:Date,checkHourMinSec:boolean):boolean;
                gtOrEqual(date1:Date,date2:Date):boolean;
                gtOrEqual(value1:number,value2:number):boolean;
                gtOrEqual(value1:$.java.math.BigDecimal,value2:$.java.math.BigDecimal):boolean;
                /**
                 * 日期1是否大于等于日期2
                 *
                 * @param date1:           日期1
                 * @param date2:           日期2
                 * @param checkHourMinSec: 是否比较时分秒
                 * @return boolean
                 */
                gtOrEqual(date1:Date,date2:Date,checkHourMinSec:boolean):boolean;
                /**
                 * 判断两个日期是否相等
                 *
                 * @param date1
                 * @param date2
                 * @return
                 */
                isEqual(date1:Date,date2:Date):boolean;
                /**
                 * 判断两个字符串是否相等
                 *
                 * @param string1
                 * @param string2
                 * @return
                 */
                isEqual(string1:string,string2:string):boolean;
                /**
                 * 判断两个对象是否相等
                 *
                 * @param value1
                 * @param value2
                 * @return
                 */
                isEqual(value1:any,value2:any):boolean;
                /**
                 * 判断两个布尔值是否相等
                 *
                 * @param value1
                 * @param value2
                 * @return
                 */
                isEqual(value1:boolean,value2:boolean):boolean;
                /**
                 * 判断两个整数是否相等
                 *
                 * @param value1
                 * @param value2
                 * @return
                 */
                isEqual(value1:number,value2:number):boolean;
                /**
                 * 判断两个动态对象是否相等
                 *
                 * @param value1
                 * @param value2
                 * @return
                 */
                isEqual(value1:$.kd.bos.dataentity.entity.DynamicObject,value2:$.kd.bos.dataentity.entity.DynamicObject):boolean;
                /**
                 * 判断两个数值是否相等
                 *
                 * @param value1
                 * @param value2
                 * @return
                 */
                isEqual(value1:$.java.math.BigDecimal,value2:$.java.math.BigDecimal):boolean;
                /**
                 * 判断两个日期是否相等
                 *
                 * @param date1           日期1
                 * @param date2           日期2
                 * @param checkHourMinSec 是否比较时分秒
                 * @return
                 */
                isEqual(date1:Date,date2:Date,checkHourMinSec:boolean):boolean;
                lt(date1:Date,date2:Date):boolean;
                lt(param1:$.java.util.Calendar,param2:$.java.util.Calendar):boolean;
                lt(value1:number,value2:number):boolean;
                lt(value1:$.java.math.BigDecimal,value2:$.java.math.BigDecimal):boolean;
                /**
                 * 比较日期1是否小于日期2
                 *
                 * @param date1:           日期1
                 * @param date2:           日期2
                 * @param checkHourMinSec: 是否比较时分秒
                 * @return boolean
                 */
                lt(date1:Date,date2:Date,checkHourMinSec:boolean):boolean;
                ltOrEqual(date1:Date,date2:Date):boolean;
                ltOrEqual(param1:$.java.util.Calendar,param2:$.java.util.Calendar):boolean;
                ltOrEqual(value1:number,value2:number):boolean;
                ltOrEqual(value1:$.java.math.BigDecimal,value2:$.java.math.BigDecimal):boolean;
                /**
                 * 日期1是否小于等于日期2
                 *
                 * @param date1:           日期1
                 * @param date2:           日期2
                 * @param checkHourMinSec: 是否比较时分秒
                 * @return boolean
                 */
                ltOrEqual(date1:Date,date2:Date,checkHourMinSec:boolean):boolean;
                /**
                 * 两个整数相乘
                 *
                 * @param param1
                 * @param param2
                 * @return
                 */
                multiply(param1:number,param2:number):$.java.math.BigDecimal;
                /**
                 * 两个数值相乘
                 *
                 * @param param1
                 * @param param2
                 * @return
                 */
                multiply(param1:$.java.math.BigDecimal,param2:$.java.math.BigDecimal):$.java.math.BigDecimal;
                /**
                 * 字符串类型转日期类型
                 *
                 * @param dateStr: 字符串
                 * @return java.util.Date
                 * @throw
                 */
                parseDate(dateStr:string):Date;
                /**
                 * 两个整数相加
                 *
                 * @param param1
                 * @param param2
                 * @return
                 * @throws Exception
                 */
                plus(param1:number,param2:number):number;
                /**
                 * 两个数值相加
                 *
                 * @param param1
                 * @param param2
                 * @return
                 */
                plus(param1:$.java.math.BigDecimal,param2:$.java.math.BigDecimal):$.java.math.BigDecimal;
                /**
                 * 数值精度处理
                 *
                 * @param value
                 * @param scale
                 * @return
                 */
                rounding(value:$.java.math.BigDecimal,scale:number):$.java.math.BigDecimal;
                /**
                 * 两个整数相减
                 *
                 * @param param1
                 * @param param2
                 * @return
                 * @throws Exception
                 */
                subtract(param1:number,param2:number):number;
                /**
                 * 两个数值相减
                 *
                 * @param param1
                 * @param param2
                 * @return
                 */
                subtract(param1:$.java.math.BigDecimal,param2:$.java.math.BigDecimal):$.java.math.BigDecimal;
                unEqual(date1:Date,date2:Date):boolean;
                unEqual(string1:string,string2:string):boolean;
                unEqual(value1:any,value2:any):boolean;
                unEqual(value1:boolean,value2:boolean):boolean;
                unEqual(value1:number,value2:number):boolean;
                unEqual(value1:$.java.math.BigDecimal,value2:$.java.math.BigDecimal):boolean;
                unEqual(value1:$.kd.bos.dataentity.entity.DynamicObject,value2:$.kd.bos.dataentity.entity.DynamicObject):boolean;
                /**
                 * 比较日期是否相等
                 *
                 * @param date1:                  日期1
                 * @param date2:                  日期2
                 * @param checkHourMinSec:是否检查时分秒
                 * @return boolean
                 */
                unEqual(date1:Date,date2:Date,checkHourMinSec:boolean):boolean;
            }
            type HRDefineFunction_T = $.java.lang.Cloneable & HRDefineFunction_S & HRDefineFunction$;
            interface HRDefineFunction extends HRDefineFunction_T {
            }
        }
        namespace kd.hr.hbp.business.history.util{
            interface HistoryEntityUtils_S {
                /**
                 * <p>批量校验非空字段是否都填写
                 * 1.所有集合</p>
                 *
                 * @param doc        待校验集合
                 * @param fieldNames 需校验字段
                 * @return true|false
                 */
                checkNullInDynamicCollection(doc:$.kd.bos.dataentity.entity.DynamicObjectCollection,fieldNames:$.java.util.Collection):boolean;
                /**
                 * <p>校验非空字段是否都填写</p>
                 *
                 * @param dyn        待校验数据
                 * @param fieldNames 校验属性
                 * @return true|false
                 */
                checkNullInDynamicObject(dyn:$.kd.bos.dataentity.entity.DynamicObject,fieldNames:$.java.util.Collection):boolean;
                /**
                 * 对比两个对象的值是否相同，如果不同，返回false，否则返回true
                 *
                 * @param newDyn       the new dyn
                 * @param effectingDyn the effecting dyn
                 * @return Boolean boolean
                 */
                compareDynamicObjectData(newDyn:$.kd.bos.dataentity.entity.DynamicObject,effectingDyn:$.kd.bos.dataentity.entity.DynamicObject):boolean;
                /**
                 * 对比修改的历史实体信息和生效中的历史实体信息是否有差异，有差异的需要写历史，否则不用
                 *
                 * @param newDataMap                    the new data map
                 * @param effectingDataMap              the effecting data map
                 * @param historyEntityModels           the history entity models
                 * @param addNewDataHisEffectingDataMap the add new data his effecting data map
                 * @return Map map
                 */
                compareHistoryDynamicObject(newDataMap:$.java.util.Map,effectingDataMap:$.java.util.Map,historyEntityModels:$.java.util.List,addNewDataHisEffectingDataMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 比较字段值
                 *
                 * @param newVal the new val
                 * @param oldVal the old val
                 * @return boolean boolean
                 */
                compareValues(newVal:any,oldVal:any):boolean;
                /**
                 * 复制历史表
                 *
                 * @param hisDy the his dy
                 * @return DynamicObject dynamic object
                 */
                copyHisDynamicObject(hisDy:$.kd.bos.dataentity.entity.DynamicObject):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 复制历史表
                 *
                 * @param hisDy         the his dy
                 * @param ignoreKeysSet the ignore keys set
                 * @return DynamicObject dynamic object
                 */
                copyHisDynamicObjectWithIgnoreKeySet(hisDy:$.kd.bos.dataentity.entity.DynamicObject,ignoreKeysSet:$.java.util.Set):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取历史实体非转化属性
                 *
                 * @return List compare ignore key list
                 */
                getCompareIgnoreKeyList():$.java.util.List;
                /**
                 * 获取动态对象字段id，为了兼容直接设置id而不是动态对象的情况，
                 *
                 * @param dataDyn   the data dyn
                 * @param fieldName the field name
                 * @return Long dynamic object field id
                 */
                getDynamicObjectFieldId(dataDyn:$.kd.bos.dataentity.entity.DynamicObject,fieldName:string):long;
                /**
                 * 获取字段集合
                 *
                 * @param entityNumber the entity number
                 * @return List fields name list
                 */
                getFieldsNameList(entityNumber:string):$.java.util.List;
                /**
                 * 获取字段集合
                 *
                 * @param entityType the entity type
                 * @return List fields name list
                 */
                getFieldsNameList(entityType:$.kd.bos.entity.MainEntityType):$.java.util.List;
                /**
                 * 获取字段集合的字符串
                 *
                 * @param entityNumber the entity number
                 * @return String fields names string
                 */
                getFieldsNamesString(entityNumber:string):string;
                /**
                 * 获取字段集合的字符串
                 *
                 * @param entityType the entity type
                 * @return String fields names string
                 */
                getFieldsNamesString(entityType:$.kd.bos.entity.MainEntityType):string;
                /**
                 * 获取历史实体非转化属性
                 *
                 * @return Set ignore keys set
                 */
                getIgnoreKeysSet():$.java.util.Set;
            }
            interface HistoryEntityUtils_C extends HistoryEntityUtils_S {
                new():HistoryEntityUtils;
            }
            interface HistoryEntityUtils$ {
            }
            type HistoryEntityUtils_T = HistoryEntityUtils_S & HistoryEntityUtils$;
            interface HistoryEntityUtils extends HistoryEntityUtils_T {
            }
        }
        namespace kd.hr.hbp.business.init{
            interface AbstractInitDomainDataService_S {
            }
            type AbstractInitDomainDataService_ST = AbstractConsumerHandleService_S & AbstractInitDomainDataService_S;
            interface AbstractInitDomainDataService_C extends AbstractInitDomainDataService_ST {
                new():AbstractInitDomainDataService;
            }
            interface AbstractInitDomainDataService$ {
                /**
                 * 获取当前页中间表数据条数
                 *
                 * @return count
                 */
                getCount():number;
                /**
                 * 获取当前分页总数
                 *
                 * @return pageCount
                 */
                getPageCount():number;
            }
            type AbstractInitDomainDataService_T = AbstractConsumerHandleService & AbstractInitDomainDataService_S & AbstractInitDomainDataService$;
            interface AbstractInitDomainDataService extends AbstractInitDomainDataService_T {
            }
            interface AbstractConsumerHandleService_S {
            }
            type AbstractConsumerHandleService_ST = IInitDomainDataService_S & AbstractConsumerHandleService_S;
            interface AbstractConsumerHandleService_C extends AbstractConsumerHandleService_ST {
                new():AbstractConsumerHandleService;
            }
            interface AbstractConsumerHandleService$ {
            }
            type AbstractConsumerHandleService_T = IInitDomainDataService & AbstractConsumerHandleService_S & AbstractConsumerHandleService$;
            interface AbstractConsumerHandleService extends AbstractConsumerHandleService_T {
            }
            interface ITransferConfPostMicroService_S {
            }
            interface ITransferConfPostMicroService$ {
                /**
                 * 生成校验属性值json串中存在引用基础资料不存在的场景
                 *
                 * @param transferRowDataBeanList 属性对应的数据行，只是校验不通过的属性对应的数据行集合
                 * @return {@link TransferErrPromptRowBean} 有校验不通过的数据行提示信息
                 */
                generatedErrPrompt?(transferRowDataBeanList:$.java.util.List):$.java.util.List;
                /**
                 * 业务后置同步传输配置迁移后的数据
                 *
                 * @param entityNumber         实体编码
                 * @param entityDataIdVsNumMap 实体数据id与number映射关系<id值,编码值>
                 * @return 数据同步结果
                 * 返回结果说明：
                 * HRMServiceResult.success : 是否成功标识
                 * HRMServiceResult.message : 异常场景，则为异常信息，非异常场景，则为空
                 * HRMServiceResult.returnCode : 同步数据全部成功，则为success，如果有同步失败数据，则为fail
                 * HRMServiceResult.returnData : 如果returnCode为success，则为空，如果returnCode为fail，
                 * 则为失败数据ID和失败信息的Map<Object,String>，格式为<ID,失败信息>
                 */
                postSync?(entityNumber:string,entityDataIdVsNumMap:$.java.util.Map):kd.hr.hbp.common.mservice.HRMServiceResult;
                /**
                 * 获取实体唯一键，
                 * 优先从配置池里获取对应的实体唯一键，如果配置池里不存在对应实体，则再从全局实体唯一键实体获取对应的实体唯一键，
                 * 如果也没有，则再看对应实体实体是否存在编码，如果存在编码，则以编码为唯一键，反之以实体主键id为唯一键
                 *
                 * @param entityNumber 实体编码
                 * @return 实体唯一键集合
                 */
                queryEntityKeyFields?(entityNumber:string):any;
                /**
                 * 实体特殊属性字段打包-接口
                 *
                 * @param entityNumber  实体编码
                 * @param rowDataBoList 实体数据行  {@link TransferRowDataBean}
                 * @return 数据同步结果
                 * 返回结果说明：
                 * HRMServiceResult.success : 是否成功标识
                 * HRMServiceResult.message : 异常场景，则为异常信息，非异常场景，则为空
                 * HRMServiceResult.returnCode : 同步数据全部成功，则为success，如果有同步失败数据，则为fail
                 * HRMServiceResult.returnData : 如果returnCode为success，则：returnData为{@link TransferRowDataBean}，
                 * 针对自定义打包属性字符，需要对{@link TransferFieldBean}的属性customValue进行数据设置值
                 * 如果returnCode为fail，则为失败数据ID和失败信息的Map<Object,String>，格式为<ID,失败信息>
                 */
                specialFieldPackaging?(entityNumber:string,rowDataBoList:$.java.util.List):kd.hr.hbp.common.mservice.HRMServiceResult;
                /**
                 * 数据校验转换-接口
                 * 如果数据校验通过，可能id需要转换，则转换，如果不需要转换，则不做任何处理
                 *
                 * @param entityNumber  实体编码
                 * @param rowDataBoList 实体数据行  {@link TransferRowDataBean}
                 * @return 数据同步结果
                 * 返回结果说明：
                 * HRMServiceResult.success : 是否成功标识
                 * HRMServiceResult.message : 异常场景，则为异常信息，非异常场景，则为空
                 * HRMServiceResult.returnCode : 同步数据全部成功，则为success，如果有同步失败数据，则为fail
                 * HRMServiceResult.returnData : 如果returnCode为success，则：returnData为{@link TransferRowDataBean}，
                 * 唯一键查询，可调用{@link ITransferConfPostMicroService#queryEntityKeyFields(java.lang.String)}，通过解析{@link TransferFieldBean}的属性customValue值
                 * 如果数据包里的id需要转换，则需要将对应属性{@link TransferFieldBean}的fieldValue值更新返回
                 * 如果returnCode为fail，则为失败数据ID和失败信息的List<TransferErrPromptRowBean> {@link TransferErrPromptRowBean}，生成提示信息可调用：{@link ITransferConfPostMicroService#generatedErrPrompt(java.util.List)}方法
                 */
                validationConversionData?(entityNumber:string,rowDataBoList:$.java.util.List):kd.hr.hbp.common.mservice.HRMServiceResult;
            }
            type ITransferConfPostMicroService_T = ITransferConfPostMicroService_S & ITransferConfPostMicroService$;
            interface ITransferConfPostMicroService extends ITransferConfPostMicroService_T {
            }
            interface IInitDomainDataService_S {
            }
            interface IInitDomainDataService$ {
                /**
                 * 初始化修改状态为进行中
                 * 微服务接口要做幂等处理
                 *
                 * @return InitOutParam
                 */
                changeProcessingStatus():void;
                /**
                 * 初始化业务数据状态修改
                 * 微服务接口要做幂等处理
                 *
                 * @return InitOutParam
                 */
                changeStatus():void;
                /**
                 * 初始化修改状态为成功
                 * 微服务接口要做幂等处理
                 *
                 * @return InitOutParam
                 */
                changeSuccessStatus():void;
                /**
                 * 初始化修改状态为已验证
                 * 微服务接口要做幂等处理
                 *
                 * @return InitOutParam
                 */
                changeValidatedStatus():void;
                /**
                 * @param initInParam 入参
                 */
                handle(initInParam:kd.hr.hbp.common.init.InitInParam):void;
                /**
                 * 结论： 按业务表的批次进行处理
                 *
                 * @return InitOutParam
                 */
                rollback():void;
                /**
                 * 初始化保存
                 * 微服务接口要做幂等处理
                 *
                 * @return InitOutParam
                 */
                save():void;
                /**
                 * 初始化校验方法
                 * @return InitOutParam
                 */
                validate():void;
            }
            type IInitDomainDataService_T = IInitDomainDataService_S & IInitDomainDataService$;
            interface IInitDomainDataService extends IInitDomainDataService_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.activity{
            interface HRActivityServiceHelper_S {
                /**
                 * 分配活动实例处理人
                 *
                 * @param requestMap 请求参数
                 * @return 分配活动实例处理人结果
                 */
                assignActivityIns(requestMap:$.java.util.Map):$.kd.bos.entity.operate.result.OperationResult;
                /**
                 * 同意活动实例
                 *
                 * @param requestMap 请求参数
                 * @return 同意活动实例结果
                 */
                consentActivityIns(requestMap:$.java.util.Map):$.kd.bos.entity.operate.result.OperationResult;
                /**
                 * 查询单个活动实例信息
                 *
                 * @param requestMap 请求参数
                 * @return 活动实例信息
                 */
                getActivityIns(requestMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 查询多个活动实例信息
                 *
                 * @param requestMap 请求参数
                 * @return 活动实例信息集合
                 */
                getActivityInstances(requestMap:$.java.util.Map):$.java.util.List;
                /**
                 * 查询活动方案信息
                 *
                 * @param requestMap 请求参数
                 * @return 活动方案信息
                 */
                getActivityScheme(requestMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 查询最新活动实例
                 *
                 * @param requestMap 请求参数
                 * @return 活动实例
                 */
                getLatestActivityIns(requestMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 驳回活动实例
                 *
                 * @param requestMap 请求参数
                 * @return 驳回活动实例结果
                 */
                rejectActivityIns(requestMap:$.java.util.Map):$.kd.bos.entity.operate.result.OperationResult;
                /**
                 * 终止活动
                 *
                 * @param requestMap 请求参数
                 * @return 终止活动结果
                 */
                terminateActivityIns(requestMap:$.java.util.Map):$.kd.bos.entity.operate.result.OperationResult;
                /**
                 * 转交活动实例
                 *
                 * @param requestMap 请求参数
                 * @return 转交活动实例结果
                 */
                transferActivityIns(requestMap:$.java.util.Map):$.kd.bos.entity.operate.result.OperationResult;
                /**
                 * 更新活动实例关联的业务单据的信息
                 *
                 * @param requestMap 请求参数
                 */
                updateActivityInsBindInfo(requestMap:$.java.util.Map):void;
            }
            interface HRActivityServiceHelper_C extends HRActivityServiceHelper_S {
                new():HRActivityServiceHelper;
            }
            interface HRActivityServiceHelper$ {
            }
            type HRActivityServiceHelper_T = HRActivityServiceHelper_S & HRActivityServiceHelper$;
            interface HRActivityServiceHelper extends HRActivityServiceHelper_T {
            }
            interface HRActivityModule_S {
            }
            type HRActivityModule_ST = $.kd.sdk.module.Module & HRActivityModule_S;
            interface HRActivityModule_C extends HRActivityModule_ST {
                new():HRActivityModule;
            }
            interface HRActivityModule$ {
            }
            type HRActivityModule_T = $.kd.sdk.module.Module & HRActivityModule_S & HRActivityModule$;
            interface HRActivityModule extends HRActivityModule_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.basedata{
            interface HRBaseDataModelModule_S {
            }
            type HRBaseDataModelModule_ST = $.kd.sdk.module.Module & HRBaseDataModelModule_S;
            interface HRBaseDataModelModule_C extends HRBaseDataModelModule_ST {
                new():HRBaseDataModelModule;
            }
            interface HRBaseDataModelModule$ {
            }
            type HRBaseDataModelModule_T = $.kd.sdk.module.Module & HRBaseDataModelModule_S & HRBaseDataModelModule$;
            interface HRBaseDataModelModule extends HRBaseDataModelModule_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.hcf{
            interface HCFModule_S {
            }
            type HCFModule_ST = $.kd.sdk.module.Module & HCFModule_S;
            interface HCFModule_C extends HCFModule_ST {
                new():HCFModule;
            }
            interface HCFModule$ {
            }
            type HCFModule_T = $.kd.sdk.module.Module & HCFModule_S & HCFModule$;
            interface HCFModule extends HCFModule_T {
            }
            interface HCFServiceHelper_S {
                /**
                 * 生成候选人
                 * <p>
                 * （1）创建候选人主对象
                 * （2）保存带历史和不带历史的附表数据，规则是根据对象是否同时包含boid，sourcevid和iscurrentversion字段来判断是否为带历史的附表
                 * 入参map的key为元数据标识，如下
                 * hcf_candidate 候选人
                 * hcf_canbaseinfo 候选人基本信息
                 * hcf_caneduexp 教育经历
                 * hcf_canprework 候选人前工作经历
                 * hcf_business 商业关系
                 * hcf_canaddress 地址信息
                 * hcf_canbankcard 银行卡信息
                 * hcf_cancontact 候选人紧急联系人
                 * hcf_cancontactinfo 候选人联系信息表
                 * hcf_cancre 证件信息
                 * hcf_canfamily 家庭成员
                 * hcf_canlgability 候选人语言技能
                 * hcf_canocpqual 候选人职业资格证书
                 * hcf_canotherinfo 候选人其他基本信息基础界面
                 * hcf_canprojectexp 候选人项目经历基础页面
                 * hcf_cantraining 候选人培训经历
                 * hcf_educertificate 教育证件表
                 * hcf_personalarea 候选人人员区域
                 * hcf_rsmacdachv 候选人学术成果
                 * hcf_rsmawrhon 候选人奖励荣誉
                 * hcf_rsmhobby 候选人兴趣爱好
                 * hcf_rsminterexp 候选人实习经历
                 * hcf_rsmpatinv 候选人专利发明
                 * hcf_rsmproskl 候选人专业技能
                 * hcf_rsmschjob 校内职务
                 * hcf_rsmvolexp 志愿者经历
                 *
                 * @param candidateInfo 候选人数据Map<元数据标识,对应实体动态对象数据>
                 * @return 生成的候选人id
                 */
                geneCandidateInfo(candidateInfo:$.java.util.Map):long;
            }
            interface HCFServiceHelper_C extends HCFServiceHelper_S {
                new():HCFServiceHelper;
            }
            interface HCFServiceHelper$ {
            }
            type HCFServiceHelper_T = HCFServiceHelper_S & HCFServiceHelper$;
            interface HCFServiceHelper extends HCFServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.hrpi{
            interface HPRIPerBankCardServiceHelper_S {
                /**
                 * 新增银行卡
                 *
                 * @param mapList 银行卡列表map
                 * @return true-成功，false-失败
                 */
                addPerBankCard(mapList:$.java.util.List):boolean;
                /**
                 * 新增银行卡没有控权
                 *
                 * @param mapList 银行卡列表map
                 * @return true-成功，false-失败
                 */
                addPerBankCardNoPer(mapList:$.java.util.List):boolean;
                /**
                 * 新增银行卡
                 *
                 * @param param 银行卡列表map
                 * @return 操作结果map
                 */
                addPerBankCardResult(param:$.java.util.Map):$.java.util.Map;
                /**
                 * 删除银行卡
                 *
                 * @param mapList 银行卡列表map
                 * @return true-成功，false-失败
                 */
                deletePerBankCard(isHasRight:boolean,mapList:$.java.util.List):boolean;
                /**
                 * 变更银行卡
                 *
                 * @param mapList 银行卡列表map
                 * @return true-成功，false-失败
                 */
                modifyPerBankCard(mapList:$.java.util.List):boolean;
                /**
                 * 变更银行卡
                 *
                 * @param param 银行卡列表map
                 * @return 操作结果map
                 */
                modifyPerBankCardResult(param:$.java.util.Map):$.java.util.Map;
            }
            interface HPRIPerBankCardServiceHelper_C extends HPRIPerBankCardServiceHelper_S {
                new():HPRIPerBankCardServiceHelper;
            }
            interface HPRIPerBankCardServiceHelper$ {
            }
            type HPRIPerBankCardServiceHelper_T = HPRIPerBankCardServiceHelper_S & HPRIPerBankCardServiceHelper$;
            interface HPRIPerBankCardServiceHelper extends HPRIPerBankCardServiceHelper_T {
            }
            interface HRPIChargePersonServiceHelper_S {
            }
            interface HRPIChargePersonServiceHelper_C extends HRPIChargePersonServiceHelper_S {
                new():HRPIChargePersonServiceHelper;
            }
            interface HRPIChargePersonServiceHelper$ {
                /**
                 * 根据组织id和架构方案id查询某日期组织和父层组织负责人信息
                 *
                 * @param orgIds        组织id
                 * @param queryDate     查询日期
                 * @param structProject 架构方案id
                 * @return 负责人信息
                 */
                queryChargeWithParentByOrgId(orgIds:$.java.util.List,queryDate:Date,structProject:long):$.java.util.Map;
            }
            type HRPIChargePersonServiceHelper_T = HRPIChargePersonServiceHelper_S & HRPIChargePersonServiceHelper$;
            interface HRPIChargePersonServiceHelper extends HRPIChargePersonServiceHelper_T {
            }
            interface HRPIOrgWorkFlowServiceHelper_S {
                /**
                 * 负责人
                 *
                 * @param referencePersons
                 * @param businessKey
                 * @param entityNumber
                 * @param params
                 * @return List<Long> 负责人id集合
                 */
                getLeaderId(referencePersons:$.java.util.List,businessKey:string,entityNumber:string,params:$.java.util.Map):$.java.util.List;
                /**
                 * 上级负责人
                 *
                 * @param referencePersons
                 * @param businessKey
                 * @param entityNumber
                 * @param params
                 * @return List<Long> 上级负责人id集合
                 */
                getSuperiorLeaderId(referencePersons:$.java.util.List,businessKey:string,entityNumber:string,params:$.java.util.Map):$.java.util.List;
            }
            interface HRPIOrgWorkFlowServiceHelper_C extends HRPIOrgWorkFlowServiceHelper_S {
                new():HRPIOrgWorkFlowServiceHelper;
            }
            interface HRPIOrgWorkFlowServiceHelper$ {
            }
            type HRPIOrgWorkFlowServiceHelper_T = HRPIOrgWorkFlowServiceHelper_S & HRPIOrgWorkFlowServiceHelper$;
            interface HRPIOrgWorkFlowServiceHelper extends HRPIOrgWorkFlowServiceHelper_T {
            }
            interface HRPIModule_S {
            }
            type HRPIModule_ST = $.kd.sdk.module.Module & HRPIModule_S;
            interface HRPIModule_C extends HRPIModule_ST {
                new():HRPIModule;
            }
            interface HRPIModule$ {
            }
            type HRPIModule_T = $.kd.sdk.module.Module & HRPIModule_S & HRPIModule$;
            interface HRPIModule extends HRPIModule_T {
            }
            interface HRPIPersonGenericServiceHelper_S {
                /**
                 * 批量保存接口，默认将校验通过的数据进行写入
                 *
                 * @param paramMap 保存数据的入参<br/><br/>
                 *  <pre>{<br/>
                 *     "caller": 调用方来源：initialize-初始化，hfps-事物变动<br/>
                 *     "mustAllSuccess": 允许部分成功标记：true-全部成功，false-部分成功<br/>
                 *     "eventId": 事物ID-批量接口的所有数据都放在这一个事物里,<br/>
                 *     "data": [<br/>
                 *                {  // 第一个需要保存的对象<br/>
                 *     		"hisDyns": [{  // hisDyns = DynamicObjectCollection数据类型<br/>
                 *                 "bsed": 版本计划生效日期（时序性历史实体）,<br/>
                 *                 "bsled": 版本计划失效日期（时序性历史实体）,<br/>
                 *                 "id": 主键,<br/>
                 *                 "boid": 业务主键（如果是更新数据需要传，否则默认新增）<br/>
                 *                 ...(业务字段)<br/>
                 *             }]<br/>
                 * 		},<br/>
                 * 		{  // 第二个需要保存的对象<br/>
                 *     		"hisDyns": [{<br/>
                 *                 "bsed": 版本计划生效日期（时序性历史实体）,<br/>
                 *                 "bsled": 版本计划失效日期（时序性历史实体）,<br/>
                 *                 "id": 主键,<br/>
                 *                 "boid": 业务主键（如果是更新数据需要传，否则默认新增）<br/>
                 *                 ...(业务字段)<br/>
                 *             }]<br/>
                 * 		},<br/>
                 * 		{...}<br/>
                 *     ]<br/>
                 * }</pre>
                 * @return Map<String, Object> 保存结果<br/>
                 * <pre><br/>
                 * {<br/>
                 *     "success": 是否成功标记：true-接口全部成功，false-接口执行失败，包括数据校验失败、写入失败等异常场景<br/>
                 *     "message": 返回信息说明<br/>
                 *     "data": [<br/>
                 *                {<br/>
                 *     		"code": 200, // 历史模型接口返回成功编码<br/>
                 *     		"errorMessage": 历史模型接口返回错误信息<br/>
                 *     		"data" : {<br/>
                 *                 "eventId": 事物ID，<br/>
                 *                 "versionChangeRespDataList": [<br/>
                 *                     {<br/>
                 *                         "eventId": 事物ID,<br/>
                 *                         "entityNumber": 实体编码<br/>
                 *                         "newDynamicObjects": [新的版本数据] // dynamicObject数组<br/>
                 *                     }<br/>
                 *                 ]<br/>
                 *             }<br/>
                 * 		}<br/>
                 *     ],<br/>
                 * 	"errInfos": [<br/>
                 *         {<br/>
                 *             "entityNumber": 实体编码,<br/>
                 *             "exceptionMessage": 实体操作异常返回的错误信息（不能精确到哪一条数据）<br/>
                 *             "errorDatas": [<br/>
                 *                 {<br/>
                 *                     "id": 主键ID,<br/>
                 *                     "errMsg": 错误信息。<br/>
                 *                 }<br/>
                 *             ]<br/>
                 *         }<br/>
                 *     ]<br/>
                 * }<br/>
                 * </pre>
                 */
                saveBatch(paramMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 校验接口
                 *
                 * @param paramMap 待校验数据的入参
                 * @return Map<String, Object> 校验结果
                 */
                validate(paramMap:$.java.util.Map):$.java.util.Map;
            }
            interface HRPIPersonGenericServiceHelper_C extends HRPIPersonGenericServiceHelper_S {
                new():HRPIPersonGenericServiceHelper;
            }
            interface HRPIPersonGenericServiceHelper$ {
            }
            type HRPIPersonGenericServiceHelper_T = HRPIPersonGenericServiceHelper_S & HRPIPersonGenericServiceHelper$;
            interface HRPIPersonGenericServiceHelper extends HRPIPersonGenericServiceHelper_T {
            }
            interface HRPIWorkRoleServiceHelper_S {
                /**
                 * 新增汇报关系
                 *
                 * @param addSuperiorList 汇报关系数据
                 * @return HrApiResponse<Map<String, Object>> code： 200成功 202：部分校验失败   success：true、false   data:错误信息
                 */
                addSuperior(addSuperiorList:$.java.util.List):$.java.util.List;
                /**
                 * 删除汇报关系
                 *
                 * @param delSuperiorList 汇报关系数据
                 * @return HrApiResponse<Map<String, Object>> code： 200成功 202：部分校验失败   success：true、false   data:错误信息
                 */
                delSuperior(delSuperiorList:$.java.util.List):$.java.util.List;
                /**
                 * 失效汇报关系
                 *
                 * @param expireSuperiorList 汇报关系数据
                 * @return HrApiResponse<Map<String, Object>> code： 200成功 202：部分校验失败   success：true、false   data:错误信息
                 */
                expireSuperior(expireSuperiorList:$.java.util.List):$.java.util.List;
                /**
                 * 综合查询汇报人上级
                 *
                 * @param personIds 自然人id
                 * @return Map<Long, List<Map<String, Object>>> 汇报人上级
                 */
                getDirectSuperior(personIds:$.java.util.List):$.java.util.Map;
                /**
                 * 通过组织人综合查询汇报人上级
                 *
                 * @param depempIds 组织人
                 * @return Map<Long, List<Map<String, Object>>> 汇报人上级
                 */
                getDirectSuperiorByDepempId(depempIds:$.java.util.List):$.java.util.Map;
                /**
                 * 获取生效中行政组织主负责人信息
                 *
                 * @param orgIdList 组织集合
                 * @return List<Map<String, Object>> 生效中行政组织主负责人信息
                 */
                getMainChargeByOrg(orgIdList:$.java.util.List):$.java.util.List;
                /**
                 * 根据查询时间获取行政组织主负责人信息
                 *
                 * @param orgIdList 组织集合
                 * @return List<Map<String, Object>> 行政组织主负责人信息
                 */
                getMainChargeInfoByOrg(orgIdList:$.java.util.List,queryDate:Date):$.java.util.List;
                /**
                 * 上级行政组织汇报人
                 *
                 * @param orgIds 行政组织
                 * @return List<Map<String, Object>> 上级行政组织汇报人
                 */
                getSuperiorByOrg(orgIds:$.java.util.List):$.java.util.List;
                /**
                 * 查找上级工作角色的汇报人
                 *
                 * @param roles 角色id集合
                 * @return List<Map<String, Object>> 上级工作角色的汇报人
                 */
                getSuperiorByRole(roles:$.java.util.List):$.java.util.List;
                /**
                 * 上级工作角色汇报人
                 *
                 * @param roleIds 角色id
                 * @return Map<Long, List<Map<String, Object>>> 上级工作角色汇报人
                 */
                listSuperiorByOrg(roleIds:$.java.util.List):$.java.util.Map;
                /**
                 * 变更汇报关系
                 *
                 * @param updateSuperiorList 汇报关系数据
                 * @return HrApiResponse<Map<String, Object>> code： 200成功 202：部分校验失败   success：true、false   data:错误信息
                 */
                updateSuperior(updateSuperiorList:$.java.util.List):$.java.util.List;
            }
            interface HRPIWorkRoleServiceHelper_C extends HRPIWorkRoleServiceHelper_S {
                new():HRPIWorkRoleServiceHelper;
            }
            interface HRPIWorkRoleServiceHelper$ {
            }
            type HRPIWorkRoleServiceHelper_T = HRPIWorkRoleServiceHelper_S & HRPIWorkRoleServiceHelper$;
            interface HRPIWorkRoleServiceHelper extends HRPIWorkRoleServiceHelper_T {
            }
            interface HRPIEmployeeServiceHelper_S {
                /**
                 * 是否离职
                 *
                 * @param checkList
                 * @param checkProp number personid employeeid
                 * @return Map
                 */
                checkEmployeeStatus(checkList:$.java.util.List,checkProp:string):$.java.util.Map;
                /**
                 * 根据用工关系类型分类和用工关系状态分类查询生效的职业信息数
                 *
                 * @param labreltypeclsList   用工关系类型分类ID列表（必填）
                 * @param labrelstatusclsList 用工关系状态分类ID列表（必填）
                 * @return int 生效的职业信息数
                 */
                countEmpentrelByByTypeclsAndStatusCls(labreltypeclsList:$.java.util.List,labrelstatusclsList:$.java.util.List):number;
                /**
                 * 获取职业信息
                 *
                 * @param employeeId 企业人id
                 * @return Map<String, Object> 职业信息
                 */
                getEmpentrel(employeeId:long):$.java.util.Map;
                /**
                 * 获取企业人信息
                 *
                 * @param employeeId 企业人id
                 * @return Map<String, Object>企业人信息
                 */
                getEmployee(employeeId:long):$.java.util.Map;
                /**
                 * 获取用工状态信息
                 *
                 * @param employeeIds 企业人id集合
                 * @return Map<Long, DynamicObject> 用工状态信息
                 */
                getEmployeeStatus(employeeIds:$.java.util.List):$.java.util.Map;
                /**
                 * 组织结构图显示当前和历史时间的岗位下的人员数
                 *
                 * @param queryDate   查询日期
                 * @param positionIds 岗位id
                 * @return List<Map<String, Object>> 查询到的人员信息
                 */
                getOrgHisPerson(queryDate:Date,positionIds:$.java.util.List):$.java.util.List;
                /**
                 * 批量获取企业人附表信息
                 *
                 * @param employeeIds 企业人id集合
                 * @param qFilter          自定义条件
                 * @param attachEntityName
                 * @return List<Map<String, Object>>
                 */
                listBatchEmployeeAttachs(employeeIds:$.java.util.List,qFilter:$.kd.bos.orm.query.QFilter,attachEntityName:string):$.java.util.List;
                /**
                 * 通过自然人批量获取企业人附表信息
                 *
                 * @param personIds 自然人id
                 * @param qFilter
                 * @param attachEntityName
                 * @return List<Map<String, Object>> 企业人附表信息
                 */
                listBatchEmployeeByPerson(personIds:$.java.util.List,qFilter:$.kd.bos.orm.query.QFilter,attachEntityName:string):$.java.util.List;
                /**
                 * 企业人附表
                 *
                 * @param employeeIds 企业人id
                 * @param selectProps
                 * @param attachEntityName
                 * @return List<Map<String, Object>> 企业人附表
                 */
                listBatchPropEmployeeAttachs(employeeIds:$.java.util.List,selectProps:string,attachEntityName:string):$.java.util.List;
                /**
                 * 根据用工关系类型分类和用工关系状态分类查询生效的职业信息
                 *
                 * @param labreltypeclsList   用工关系类型分类ID列表（必填）
                 * @param labrelstatusclsList 用工关系状态分类ID列表（必填）
                 * @param start               分页条件
                 * @param limit               分页条件
                 * @return List<Map<String, Object>> 生效的职业信息
                 */
                listEmpentrelByByTypeclsAndStatusCls(labreltypeclsList:$.java.util.List,labrelstatusclsList:$.java.util.List,start:number,limit:number):$.java.util.List;
                /**
                 * 企业人附表
                 *
                 * @param employeeId 企业人id
                 * @param attachEntityName
                 * @return List<Map<String, Object>> 企业人附表
                 */
                listEmployeeAttachs(employeeId:long,attachEntityName:string):$.java.util.List;
                /**
                 * 获取企业人信息
                 *
                 * @param employeeIds 企业人id集合
                 * @return 企业人信息
                 */
                listEmployees(employeeIds:$.java.util.List):$.java.util.List;
                /**
                 * 工号查询企业人
                 *
                 * @param numbers 工号集合
                 * @return List<Map<String, Object>> 企业人
                 */
                listEmployeesByNumber(numbers:$.java.util.List):$.java.util.List;
            }
            interface HRPIEmployeeServiceHelper_C extends HRPIEmployeeServiceHelper_S {
                new():HRPIEmployeeServiceHelper;
            }
            interface HRPIEmployeeServiceHelper$ {
            }
            type HRPIEmployeeServiceHelper_T = HRPIEmployeeServiceHelper_S & HRPIEmployeeServiceHelper$;
            interface HRPIEmployeeServiceHelper extends HRPIEmployeeServiceHelper_T {
            }
            interface HRPIPersonServiceHelper_S {
                /**
                 * 校验是否存在指定人员的信息
                 *
                 * @param checkList
                 * @return List<Map<String, Object>>
                 */
                checkPerson(checkList:$.java.util.List):$.java.util.List;
                /**
                 * 校验员工是否存在 查询bos或者hr
                 *
                 * @param checkList 查询信息
                 * @param queryType 查询类型 0:所有包括平台和hr，1：只校验bos,2:只校验hr
                 * @return 成功失败
                 */
                checkPersonByOpt(checkList:$.java.util.List,queryType:string):$.java.util.List;
                /**
                 * 获取当前组织下生效的在职人员信息
                 *
                 * @param adminOrgId 行政组织Id
                 * @return Map<String, Object> 当前组织下生效的在职人员信息
                 */
                getActivePersonByOrg(adminOrgId:long):$.java.util.Map;
                /**
                 * 获取当前组织团队下生效的在职人员信息
                 *
                 * @param orgteamId 组织团队Id
                 * @return Map<String, Object> 当前组织团队下生效的在职人员信息
                 */
                getActivePersonByOrgteam(orgteamId:long):$.java.util.Map;
                /**
                 * 获取指定职责分工角色下人员信息
                 *
                 * @param posType     1：1：获取全部类型； 其他：根据传入的任职类型编码查询
                 * @param dutyworkrolesIds 职责分工角色ids
                 * @return 员工信息集合
                 */
                getAllUsersOfDutyworkroles(posType:string,dutyworkrolesIds:$.java.util.List):$.java.util.Map;
                /**
                 * 获取指定组织下所有生效的人员信息
                 *
                 * @param posType       1：获取全部类型； 其他：根据传入的任职类型编码查询
                 * @param orgIds        组织IDS
                 * @param includeSubOrg 是否包含下级
                 * @return Map<Long, Set<Long>>
                 */
                getAllUsersOfOrg(posType:string,orgIds:$.java.util.List,includeSubOrg:boolean):$.java.util.Map;
                /**
                 * 获取指定组织团队下所有生效的人员信息
                 *
                 * @param posType       1：获取全部类型； 其他：根据传入的任职类型编码查询
                 * @param orgteamIds    组织团队IDS
                 * @param includeSubOrg 是否包含下级
                 * @return Map<Long, Set<Long>>
                 */
                getAllUsersOfOrgteam(posType:string,orgteamIds:$.java.util.List,includeSubOrg:boolean):$.java.util.Map;
                /**
                 * 获取指定岗位下人员信息
                 *
                 * @param posType     1：1：获取全部类型； 其他：根据传入的任职类型编码查询
                 * @param positionIds 岗位ids
                 * @return Map<Long, Set<Long>> 员工信息集合
                 */
                getAllUsersOfPosition(posType:string,positionIds:$.java.util.List):$.java.util.Map;
                /**
                 * 查询自然人基本信息
                 *
                 * @param personId 自然人id
                 * @return Map<String, Object>
                 */
                getPersonBaseInfo(personId:long):$.java.util.Map;
                /**
                 * 获取当前组织下在职人员信息
                 *
                 * @param adminOrgIds 行政组织Id
                 * @return List<Map<String, Object>> 当前组织下在职人员信息
                 */
                getPersonByOrgs(adminOrgIds:$.java.util.List,queryDate:Date):$.java.util.List;
                /**
                 * 获取当前组织团队下在职人员信息
                 *
                 * @param orgteamIds 组织团队Id
                 * @return List<Map<String, Object>> 当前组织团队下在职人员信息
                 */
                getPersonByOrgteams(orgteamIds:$.java.util.List,queryDate:Date):$.java.util.List;
                /**
                 * 主负责人信息
                 *
                 * @param adminOrgIds 组织
                 * @param queryDate 查询日期
                 * @return List<Map<String, Object>>
                 */
                getPersonChargeInfo(adminOrgIds:$.java.util.List,queryDate:Date):$.java.util.List;
                /**
                 * 获取当前组织下在职人员信息数量和负责人信息
                 *
                 * @param adminOrgIds 行政组织Id
                 * @return List<Map<String, Object>>
                 */
                getPersonCountAndChargeInfo(adminOrgIds:$.java.util.List,queryDate:Date):$.java.util.List;
                /**
                 * 查询自然人基本信息(包含任职信息)
                 *
                 * @param personId 自然人id
                 * @return Map<String, Object>
                 */
                getPersonInfo(personId:long):$.java.util.Map;
                /**
                 * 获取人员的主任职部门ID
                 *
                 * @param personId 自然人id
                 * @return Long 主任职部门ID
                 */
                getPersonMainOrgId(personId:long):long;
                /**
                 * 通过用户id获取自然人和企业人信息
                 *
                 * @param userId 用户id
                 * @return 用户信息
                 */
                getPersonModelIdByUserId(userId:long):$.java.util.Map;
                /**
                 * 获取人员的主任职信息
                 *
                 * @param personId 自然人id
                 * @return Map<String, Object> 主任职信息
                 */
                getPrimaryEmpposorgrel(personId:long):$.java.util.Map;
                /**
                 * 通过自然人或者企业人id查询系统用户
                 *
                 * @return 系统用户
                 */
                getUserIdByPersonInfo(idMaps:$.java.util.Map):$.java.util.Map;
                /**
                 * 主任职部门是否属于指定行政组织
                 *
                 * @param personId    人员ID
                 * @param orgId       行政组织ID
                 * @param checkSubOrg 是否校验下级
                 * @return boolean 是否属于指定行政组织
                 */
                isBelongOrg(personId:long,orgId:long,checkSubOrg:boolean):boolean;
                /**
                 * 主任职岗位是否属于指定岗位
                 *
                 * @param personId   人员ID
                 * @param positionId 岗位ID
                 * @return boolean 是否属于指定岗位
                 */
                isBelongPosition(personId:long,positionId:long):boolean;
                /**
                 * 获取指定自然人附表信息
                 *
                 * @param personIds
                 * @param qFilter
                 * @param attachEntityName
                 * @return List<Map<String, Object>> 自然人附表信息
                 */
                listBatchPersonAttachs(personIds:$.java.util.List,qFilter:$.kd.bos.orm.query.QFilter,attachEntityName:string):$.java.util.List;
                /**
                 * 获取指定自然人附表信息
                 *
                 * @param personIds
                 * @param qFilter
                 * @param attachEntityName
                 * @return List<Map<String, Object>>
                 */
                listBatchPropHisPersonAttachs(personIds:$.java.util.List,selectProps:string,qFilter:$.kd.bos.orm.query.QFilter,attachEntityName:string):$.java.util.List;
                /**
                 * 获取指定自然人附表信息
                 *
                 * @param personIds
                 * @param qFilter
                 * @param attachEntityName
                 * @return List<Map<String, Object>>
                 */
                listBatchPropPersonAttachs(personIds:$.java.util.List,selectProps:string,qFilter:$.kd.bos.orm.query.QFilter,attachEntityName:string):$.java.util.List;
                /**
                 * 获取人员的全部任职信息
                 *
                 * @param personId 自然人id
                 * @return List<Map < String, Object>> 任职信息
                 */
                listEmpposorgrels(personId:long):$.java.util.List;
                /**
                 * 根据任职类型批量获取人员的全部任职信息
                 *
                 * @param postType  任职类型
                 * @param personIds 自然人ids
                 * @return List<Map < String, Object>> 任职信息
                 */
                listEmpposorgrels(postType:string,personIds:$.java.util.List):$.java.util.List;
                /**
                 * 获取指定自然人附表信息
                 *
                 * @param personId 自然人id
                 * @return List<Map<String, Object>>  附表信息
                 */
                listPersonAttachs(personId:long,attachEntityName:string):$.java.util.List;
                /**
                 * 批量获取人员基本信息
                 *
                 * @param personIds 人员ids
                 * @return List<Map<String, Object>> 人员基本信息集合
                 */
                listPersonInfos(personIds:$.java.util.List):$.java.util.List;
                /**
                 * 获取人员模型ID
                 *
                 * @param personId 人员id
                 * @param isAll    是否获取全部(包含业务状态为已失效)
                 * @return List<Map<String, Long>> 人员的各层模型ID
                 */
                listPersonModelIds(personId:long,isAll:boolean):$.java.util.List;
                /**
                 * 获取人员的全部部门ID
                 *
                 * @param personId 自然人id
                 * @return List<Long> 全部部门ID
                 */
                listPersonOrgIds(personId:long):$.java.util.List;
                /**
                 * 通过用户id获取自然人和企业人信息批量
                 *
                 * @param userIds 用户id
                 * @return Map<String, Object>用户信息
                 */
                queryPersonInfoByUserIds(userIds:$.java.util.List):$.java.util.Map;
                /**
                 * 附件删除
                 *
                 * @param formId
                 * @param pkId
                 * @return void
                 */
                removeTempAttachments(formId:string,pkId:any,fileUid:any):void;
                /**
                 * 批量保存人员附表信息
                 *
                 * @param attachMap
                 * @return Map<String, Object>
                 */
                saveOrUpdateInfo(attachMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 附件保存
                 *
                 * @param formId
                 * @param pkId
                 * @param appid
                 * @param att
                 * @return DynamicObjectCollection
                 */
                saveTempAttachments(formId:string,pkId:any,appid:string,att:$.java.util.Map):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * HR人员同步平台
                 *
                 * @param userList 用户信息 map的key 为工号、同步类型
                 * @return Map<String, Object>
                 */
                syncPersonToSysUer(userList:$.java.util.List):$.java.util.Map;
                /**
                 * 更新用工关系记录
                 *
                 * @param updateList
                 *          personid:自然人id
                 *          orgid:用工组织id
                 *          lawentityid:法律实体id
                 *          startdate：开始日期
                 * @return Map<String, Object> 成功失败
                 */
                updateLaborRelRecord(updateList:$.java.util.List):$.java.util.Map;
            }
            interface HRPIPersonServiceHelper_C extends HRPIPersonServiceHelper_S {
                new():HRPIPersonServiceHelper;
            }
            interface HRPIPersonServiceHelper$ {
            }
            type HRPIPersonServiceHelper_T = HRPIPersonServiceHelper_S & HRPIPersonServiceHelper$;
            interface HRPIPersonServiceHelper extends HRPIPersonServiceHelper_T {
            }
            interface HRPIApplyServiceHelper_S {
                /**
                 * 通过接口新增HR人员<br/>
                 * 新增员工信息示例入参格式<br/>
                 * | 参数名                   | 参数类型                     | 是否必填     | 说明                                             |<br/>
                 * | ------------------------ | ---------------------------- | ------------ | ------------------------------------------------ |<br/>
                 * | person                   | Long                         | 是           | 自然人ID                                         |<br/>
                 * | number                   | String                       | 是           | 工号                                             |<br/>
                 * | name                     | String                       | 是           | 姓名                                             |<br/>
                 * | phone                    | String                       | 是           | 手机号码(格式 +86-15000000000)                   |<br/>
                 * | oldperson                | Long                         | 否           | 上一个自然人id                                   |<br/>
                 * | **\*baseinfo\***         | ***\*Map<String,Object>\**** | 是           | ***\*员工基本信息\****                           |<br/>
                 * | >employee                | Long                         | 是           | 企业人ID                                         |<br/>
                 * | >depemp                  | Long                         | 是           | 组织人ID                                         |<br/>
                 * | >cepmp                   | Long                         | 是           | 所属管理范围ID                                   |<br/>
                 * | >oldempnumber            | String                       | 否           | 前工号                                           |<br/>
                 * | >inheritnumber           | String                       | 否           | 是否继承工号(1:否;2:是)用于再入职相关的业务      |<br/>
                 * | >startdate               | Date                         | 是           | 入职日期                                         |<br/>
                 * | >enterprise              | Long                         | 是           | 用人单位ID                                       |<br/>
                 * | >laborreltype            | Long                         | 是           | 用工关系类型ID                                   |<br/>
                 * | >laborrelstatus          | Long                         | 是           | 用工关系状态ID                                   |<br/>
                 * | >labrelstatusprd         | Long                         | 是           | 用工关系阶段ID(由laborrelstatus基础资料带出)     |<br/>
                 * | >isprobation             | Boolean                      | 是           | 是否有试用期                                     |<br/>
                 * | >managingscope           | Long                         | 是           | 所属管理范围ID                                   |<br/>
                 * | >***\*empposorgrels\**** | ***\*List\****               | 是           | ***\*任职经历\*(目前仅支持传一条任职经历数据)*** |<br/>
                 * | >>adminorg               | Long                         | 是           | 行政组织ID                                       |<br/>
                 * | >>posstatus              | Long                         | 是           | 任职状态                                         |<br/>
                 * | >>postype                | Long                         | 是           | 任职类型                                         |<br/>
                 * | >>startdate              | Date                         | 是           | 任期开始日期                                     |<br/>
                 * | >>enddate                | Date                         | 否           | 任职结束日期(不传则默认系统最大日期2999-12-31)   |<br/>
                 * | >>isprimary              | Boolean                      | 是           | 是否主任职                                       |<br/>
                 * | >>position               | Long                         | 是           | 岗位(岗位/标准岗位/职位 至少一个)                |<br/>
                 * | >>stdposition            | Long                         | 是           | 标准岗位(岗位/标准岗位/职位 至少一个)            |<br/>
                 * | >>job                    | Long                         | 是           | 职位(岗位/标准岗位/职位 至少一个)                |<br/>
                 * | >>workplace              | Long                         | 否           | 工作地                                           |<br/>
                 * | >>variationtype          | Long                         | 否           | 变动类型                                         |<br/>
                 * | ***\*pertsprop\****      | Map<String,Object>           | 否           | ***\*人员时序信息(对应人员时序性属性表)\****     |<br/>
                 * | >healthstatus            | Long                         | 否           | 健康状况ID                                       |<br/>
                 * | >marriagestatus          | Long                         | 否           | 婚姻状况ID                                       |<br/>
                 * | >procreatstatus          | Long                         | 否           | 生育状况ID                                       |<br/>
                 * | >childrennumber          | Int                          | 否           | 子女数                                           |<br/>
                 * | ***\*pernontsprop\****   | Map                          | 是           | ***\*人员基本信息(对应人员非时序性属性表)\****   |<br/>
                 * | >gender                  | Long                         | 是           | 性别ID                                           |<br/>
                 * | >nationality             | Long                         | 是           | 国籍ID                                           |<br/>
                 * | >birthday                | Date                         | 否           | 出生日期 **(在6.0版本由必填修改为非必填)**       |<br/>
                 * | >folk                    | Long                         | 否           | 民族ID                                           |<br/>
                 * | >constellation           | Long                         | 否           | 星座ID                                           |<br/>
                 * | >bloodtype               | String                       | 否           | 血型                                             |<br/>
                 * | >height                  | Int                          | 否           | 身高(cm)                                         |<br/>
                 * | >lunarcalendarbirthday   | Date                         | 否           | 农历生日                                         |<br/>
                 * | >***\*formername\****    | Map<String,Object>           | 否           | ***\*曾用名\*(多语言字段)***                     |<br/>
                 * | >>zh_CN                  | String                       | 否           | 简体中文                                         |<br/>
                 * | >>zh_TW                  | String                       | 否           | 繁体中文                                         |<br/>
                 * | >>en_US                  | String                       | 否           | English                                          |<br/>
                 * | >***\*title\****         | Map                          | 否           | ***\*头衔\*(多语言字段)***                       |<br/>
                 * | >>zh_CN                  | String                       | 否           | 简体中文                                         |<br/>
                 * | >>zh_TW                  | String                       | 否           | 繁体中文                                         |<br/>
                 * | >>en_US                  | String                       | 否           | English                                          |<br/>
                 * | >enname                  | String                       | 否           | 英文名                                           |<br/>
                 * | >julianbirthday          | Date                         | 否           | 公历生日                                         |<br/>
                 * | >symbolicanimals         | Long                         | 否           | 生肖ID                                           |<br/>
                 * | >nameen                  | String                       | 否           | 拼音名                                           |<br/>
                 * | >nativelngname           | String                       | 否           | 本地语言姓名                                     |<br/>
                 * | >displayname             | String                       | 否           | 显示名                                           |<br/>
                 * | >marriageregistdate      | Date                         | 否           | 结婚登记日期                                     |<br/>
                 * | ***\*percontact\****     | ***\*Map\****                | ***\*否\**** | ***\*联系信息(对应人员联系方式基础页面表)\****   |<br/>
                 * | >otherphone              | String                       | 否           | 其他手机(格式 +86-15000000000)                   |<br/>
                 * | >peremail                | String                       | 否           | 个人邮箱                                         |<br/>
                 * | ***\*perregion\****      | Map                          | 否           | ***\*人员其他信息(对应人员区域信息表)\****       |<br/>
                 * | >politicalstatus         | Long                         | 否           | 政治面貌ID                                       |<br/>
                 * | >party                   | Long                         | 否           | 所属党派ID                                       |<br/>
                 * | >joinpartydate           | Date                         | 否           | 入党日期                                         |<br/>
                 * | >***\*nativeplace\****   | Map                          | 否           | ***\*籍贯\*(多语言字段)***                       |<br/>
                 * | >>zh_CN                  | String                       | 否           | 简体中文                                         |<br/>
                 * | >>zh_TW                  | String                       | 否           | 繁体中文                                         |<br/>
                 * | >>en_US                  | String                       | 否           | English                                          |<br/>
                 * | >***\*birthplace\****    | Map                          | 否           | ***\*出生地\*(多语言字段)***                     |<br/>
                 * | >>zh_CN                  | String                       | 否           | 简体中文                                         |<br/>
                 * | >>zh_TW                  | String                       | 否           | 繁体中文                                         |<br/>
                 * | >>en_US                  | String                       | 否           | English                                          |<br/>
                 *
                 * @param employeeListInfo 参数列表 构造见上述示例
                 * @return 处理的返回结果 <br/>
                 * | 参数名       | 参数类型                  | 说明                                                       |<br/>
                 * | ------------ | ------------------------- | ---------------------------------------------------------- |<br/>
                 * | data         | Map<String, Object>       | 通用接口返回的保存结果                                     |<br/>
                 * | success      | boolean                   | 成功的标识；true：成功；false：失败                        |<br/>
                 * | errorInfoMsg | List<Map<String, Object>> | 错误信息集合（校验的错误信息不包含调用保存接口的错误返回） |<br/>
                 * | successInfo  | Map<String, Object>       | 包含成功的四层人id相关的信息                               |<br/>
                 */
                addEmployee(employeeListInfo:$.java.util.List):$.java.util.Map;
                /**
                 * 废弃任职经历
                 *
                 * @param param 入参
                 * @return Map<String, Object>
                 */
                discardEmpExp(param:$.java.util.Map):$.java.util.Map;
                /**
                 *  任职经历维护<br/>
                 *  传入的depemp 为当前系统中已存在的id则走更新;否则新增<br/>
                 *  入参示例<br/>
                 *  | 参数名        | 参数类型 | 是否必填 | 说明                                    |<br/>
                 *  | ------------- | -------- | -------- | --------------------------------------- |<br/>
                 *  | depemp        | Long     | 是       | 组织人ID                                |<br/>
                 *  | number        | String   | 是       | 工号                                    |<br/>
                 *  | adminorg      | Long     | 是       | 行政组织ID                              |<br/>
                 *  | posstatus     | Long     | 是       | 任职状态ID                              |<br/>
                 *  | postype       | Long     | 是       | 任职类型ID                              |<br/>
                 *  | position      | Long     | 是       | 岗位ID (岗位/标准岗位/职位 至少一个)    |<br/>
                 *  | stdposition   | Long     | 是       | 标准岗位ID(岗位/标准岗位/职位 至少一个) |<br/>
                 *  | job           | Long     | 是       | 职位ID(岗位/标准岗位/职位 至少一个)     |<br/>
                 *  | workplace     | Long     | 是       | 工作地ID                                |<br/>
                 *  | startdate     | Date     | 是       | 任职开始日期                            |<br/>
                 *  | enddate       | Date     | 是       | 任职结束日期                            |<br/>
                 *  | isprimary     | Boolean  | 是       | 是否主任职                              |<br/>
                 *  | variationtype | Long     | 否       | 变动类型                                |<br/>
                 * <br/>
                 *  @param empOrgrels 参数列表 构造见上述示例
                 *  @return 处理的返回结果 <br/>
                 *  | 参数名       | 参数类型                  | 说明                                                       |<br/>
                 *  | ------------ | ------------------------- | ---------------------------------------------------------- |<br/>
                 *  | data         | Map<String, Object>       | 通用接口返回的保存结果                                     |<br/>
                 *  | success      | boolean                   | 成功的标识；true：成功；false：失败                        |<br/>
                 *  | errorInfoMsg | List<Map<String, Object>> | 错误信息集合（校验的错误信息不包含调用保存接口的错误返回） |<br/>
                 *  | successInfo  | Map<String, Object>       | 包含成功的四层人id相关的信息                               |<br/>
                 */
                saveEmpOrgrels(empOrgrels:$.java.util.List):$.java.util.Map;
                /**
                 * 职业信息维护,仅支持职业信息更新,无法单独新增职业信息<br/>
                 * 入参参数结构:<br/>
                 * | 参数名          | 参数类型 | 是否必填                             | 说明                                         |<br/>
                 * | --------------- | -------- | ------------------------------------ | -------------------------------------------- |<br/>
                 * | employee        | Long     | 是                                   | 企业人ID                                     |<br/>
                 * | number          | String   | 是                                   | 工号                                         |<br/>
                 * | inheritnumber   | String   | 否                                   | 是否继承工号(1：是；2：否)                   |<br/>
                 * | enterprise      | Long     | 否                                   | 用人单位ID                                   |<br/>
                 * | laborreltype    | Long     | 否                                   | 用工关系类型ID                               |<br/>
                 * | laborrelstatus  | Long     | 否                                   | 用工关系状态ID                               |<br/>
                 * | labrelstatusprd | Long     | 否  (laborrelstatus如果传值，则必传) | 用工关系阶段ID(由laborrelstatus基础资料带出) |<br/>
                 * | isprobation     | Boolean  | 否                                   | 是否有试用期                                 |<br/>
                 * | startdate       | Date     | 否                                   | 开始日期                                     |<br/>
                 * | enddate         | Date     | 否                                   | 结束日期                                     |<br/>
                 * | adjustlength    | Double   | 否                                   | 调整年限                                     |<br/>
                 *
                 * @param empenTrels 参数列表 构造见上述示例
                 * @return 处理的返回结果 <br/>
                 * | 参数名       | 参数类型                  | 说明                                                       |<br/>
                 * | ------------ | ------------------------- | ---------------------------------------------------------- |<br/>
                 * | data         | Map<String, Object>       | 通用接口返回的保存结果                                     |<br/>
                 * | success      | boolean                   | 成功的标识；true：成功；false：失败                        |<br/>
                 * | errorInfoMsg | List<Map<String, Object>> | 错误信息集合（校验的错误信息不包含调用保存接口的错误返回） |<br/>
                 * | successInfo  | Map<String, Object>       | 包含成功的四层人id相关的信息                               |<br/>
                 */
                saveEmpentrels(empenTrels:$.java.util.List):$.java.util.Map;
                /**
                 *  基本信息维护 更新自然人相关的信息 <br/>
                 *  入参参数结构示例:<br/>
                 *  | 参数名                 | 参数类型           | 是否必填     | 说明                                           |<br/>
                 *  | ---------------------- | ------------------ | ------------ | ---------------------------------------------- |<br/>
                 *  | person                 | Long               | 是           | 自然人ID                                       |<br/>
                 *  | number                 | String             | 是           | 工号                                           |<br/>
                 *  | name                   | String             | 是           | 姓名                                           |<br/>
                 *  | phone                  | String             | 是           | 手机号码(格式 +86-15000000000)                 |<br/>
                 *  | ***\*pertsprop\****    | Map<String,Object> | 否           | ***\*人员时序信息(对应人员时序性属性表)\****   |<br/>
                 *  | >healthstatus          | Long               | 否           | 健康状况ID                                     |<br/>
                 *  | >marriagestatus        | Long               | 否           | 婚姻状况ID                                     |<br/>
                 *  | >procreatstatus        | Long               | 否           | 生育状况ID                                     |<br/>
                 *  | >childrennumber        | Int                | 否           | 子女数                                         |<br/>
                 *  | ***\*pernontsprop\**** | Map                | 是           | ***\*人员基本信息(对应人员非时序性属性表)\**** |<br/>
                 *  | >gender                | Long               | 是           | 性别ID                                         |<br/>
                 *  | >nationality           | Long               | 是           | 国籍ID                                         |<br/>
                 *  | >birthday              | Date               | 否           | 出生日期 **(在6.0版本由必填修改为非必填)**     |<br/>
                 *  | >folk                  | Long               | 否           | 民族ID                                         |<br/>
                 *  | >constellation         | Long               | 否           | 星座ID                                         |<br/>
                 *  | >bloodtype             | String             | 否           | 血型                                           |<br/>
                 *  | >height                | Int                | 否           | 身高(cm)                                       |<br/>
                 *  | >lunarcalendarbirthday | Date               | 否           | 农历生日                                       |<br/>
                 *  | >***\*formername\****  | Map<String,Object> | 否           | ***\*曾用名\*(多语言字段)***                   |<br/>
                 *  | >>zh_CN                | String             | 否           | 简体中文                                       |<br/>
                 *  | >>zh_TW                | String             | 否           | 繁体中文                                       |<br/>
                 *  | >>en_US                | String             | 否           | English                                        |<br/>
                 *  | >***\*title\****       | Map                | 否           | ***\*头衔\*(多语言字段)***                     |<br/>
                 *  | >>zh_CN                | String             | 否           | 简体中文                                       |<br/>
                 *  | >>zh_TW                | String             | 否           | 繁体中文                                       |<br/>
                 *  | >>en_US                | String             | 否           | English                                        |<br/>
                 *  | >enname                | String             | 否           | 英文名                                         |<br/>
                 *  | >julianbirthday        | Date               | 否           | 公历生日                                       |<br/>
                 *  | >symbolicanimals       | Long               | 否           | 生肖ID                                         |<br/>
                 *  | >nameen                | String             | 否           | 拼音名                                         |<br/>
                 *  | >nativelngname         | String             | 否           | 本地语言姓名                                   |<br/>
                 *  | >displayname           | String             | 否           | 显示名                                         |<br/>
                 *  | >marriageregistdate    | Date               | 否           | 结婚登记日期                                   |<br/>
                 *  | ***\*percontact\****   | ***\*Map\****      | ***\*否\**** | ***\*联系信息(对应人员联系方式基础页面表)\**** |<br/>
                 *  | >otherphone            | String             | 否           | 其他手机(格式 +86-15000000000)                 |<br/>
                 *  | >peremail              | String             | 否           | 个人邮箱                                       |<br/>
                 *  | ***\*perregion\****    | Map                | 否           | ***\*人员其他信息(对应人员区域信息表)\****     |<br/>
                 *  | >politicalstatus       | Long               | 否           | 政治面貌ID                                     |<br/>
                 *  | >party                 | Long               | 否           | 所属党派ID                                     |<br/>
                 *  | >joinpartydate         | Date               | 否           | 入党日期                                       |<br/>
                 *  | >***\*nativeplace\**** | Map                | 否           | ***\*籍贯\*(多语言字段)***                     |<br/>
                 *  | >>zh_CN                | String             | 否           | 简体中文                                       |<br/>
                 *  | >>zh_TW                | String             | 否           | 繁体中文                                       |<br/>
                 *  | >>en_US                | String             | 否           | English                                        |<br/>
                 *  | >***\*birthplace\****  | Map                | 否           | ***\*出生地\*(多语言字段)***                   |<br/>
                 *  | >>zh_CN                | String             | 否           | 简体中文                                       |<br/>
                 *  | >>zh_TW                | String             | 否           | 繁体中文                                       |<br/>
                 *  | >>en_US                | String             | 否           | English                                        |<br/>
                 * <br/>
                 *  @param personInfos 参数列表 构造见上述示例
                 *  @return 处理的返回结果 <br/>
                 *  | 参数名       | 参数类型                  | 说明                                                       |<br/>
                 *  | ------------ | ------------------------- | ---------------------------------------------------------- |<br/>
                 *  | data         | Map<String, Object>       | 通用接口返回的保存结果                                     |<br/>
                 *  | success      | boolean                   | 成功的标识；true：成功；false：失败                        |<br/>
                 *  | errorInfoMsg | List<Map<String, Object>> | 错误信息集合（校验的错误信息不包含调用保存接口的错误返回） |<br/>
                 *  | successInfo  | Map<String, Object>       | 包含成功的四层人id相关的信息                               |<br/>
                 */
                savePersonInfo(personInfos:$.java.util.List):$.java.util.Map;
            }
            interface HRPIApplyServiceHelper_C extends HRPIApplyServiceHelper_S {
                new():HRPIApplyServiceHelper;
            }
            interface HRPIApplyServiceHelper$ {
            }
            type HRPIApplyServiceHelper_T = HRPIApplyServiceHelper_S & HRPIApplyServiceHelper$;
            interface HRPIApplyServiceHelper extends HRPIApplyServiceHelper_T {
            }
            interface HRPIDepempServiceHelper_S {
                /**
                 * 传入非主任职的全职任职和结束时间，修改为主任职的全职任职，将原主任职的全职任职,切换为非主任职全职任职
                 *
                 * @param changeParams 参数 id :任职经历主键   depempid : 组织人id (其中id 和 depempid 传其中一个即可，都传则用id)  updatedate:更新时间
                 * @return 状态码：200：成功  201：全部数据校验异常 202：部分数据校验异常，部分成功 203：保存有误 500：程序异常
                 */
                changePrimaryEmpPosOrgRel(changeParams:$.java.util.List):$.java.util.Map;
                /**
                 * 组织的编制维度更改，需全量检查该组织的人员占编情况。
                 * 查询时间交集的数据：
                 * 1.startdate >= gteDate and startdate <= lteDate or
                 * 2.startdate <= gteDate and enddate >= lteDate or
                 * 3.enddate >= gteDate and enddate <= lteDate or
                 * 4.startdate >= gteDate and enddate <= lteDate
                 *
                 * @param gteDate   查询起始日期（含）
                 * @param lteDate   查询截止日期（含）
                 * @param paramMap: -- orgteamIdList 组织团队ID集合
                 *                  -- postypeIdList 任职类型ID集合
                 *                  -- postcategoryIdList 任职类型分类ID集合
                 * @return 业务版本数据集合
                 */
                countIntersectEmpOrgrels(gteDate:Date,lteDate:Date,paramMap:$.java.util.Map):number;
                /**
                 * 获取任职信息(历史模型生效数据)
                 *
                 * @param depempId 组织人id
                 * @return Map<String, Object> 任职信息
                 */
                getDataEmpOrgrel(depempId:long):$.java.util.Map;
                /**
                 * 获取组织人信息
                 *
                 * @param depempId 组织人id
                 * @return Map<String, Object> 组织人信息
                 */
                getDepemp(depempId:long):$.java.util.Map;
                /**
                 * 获取四层人员ID
                 *
                 * @param depempId 组织人id
                 * @return Map<String, Long> 四层人员ID
                 */
                getDepempIds(depempId:long):$.java.util.Map;
                /**
                 * 获取任职信息
                 *
                 * @param depempId 组织人id
                 * @return Map<String, Object> 任职信息
                 */
                getEmpOrgrel(depempId:long):$.java.util.Map;
                /**
                 * 获取任职信息(历史模型生效数据)
                 *
                 * @param depempIds 组织人id集合
                 * @return List<DynamicObject> 任职信息
                 */
                listDataEmpOrgrelDys(depempIds:$.java.util.List):$.java.util.List;
                /**
                 * 获取任职信息(历史模型生效数据)
                 *
                 * @param depempIds 组织人id集合
                 * @return List<Map<String, Object>> 任职信息
                 */
                listDataEmpOrgrels(depempIds:$.java.util.List):$.java.util.List;
                /**
                 * 获取任职信息
                 *
                 * @param depempIds 组织人id集合
                 * @return List<DynamicObject> 任职信息
                 */
                listEmpOrgrelDys(depempIds:$.java.util.List):$.java.util.List;
                /**
                 * 获取任职信息
                 *
                 * @param depempIds 组织人id集合
                 * @return List<Map<String, Object>>
                 */
                listEmpOrgrels(depempIds:$.java.util.List):$.java.util.List;
                /**
                 * 根据职责分工角色ID查询目前该职责分工角色上的人员信息
                 *
                 * @param dutyworkrolesIdList 职责分工角色ID列表
                 * @return List<Map<String, Object>>  人员信息：头像、姓名、工号、年龄、性别、工龄、司龄、职级、任职类型、岗位
                 */
                listEmpersonByDutyworkroles(dutyworkrolesIdList:$.java.util.List):$.java.util.List;
                /**
                 * 组织的编制维度更改，需全量检查该组织的人员占编情况。
                 * 查询时间交集的数据：
                 * 1.startdate >= gteDate and startdate <= lteDate or
                 * 2.startdate <= gteDate and enddate >= lteDate or
                 * 3.enddate >= gteDate and enddate <= lteDate or
                 * 4.startdate >= gteDate and enddate <= lteDate
                 *
                 * @param gteDate   查询起始日期（含）
                 * @param lteDate   查询截止日期（含）
                 * @param paramMap: -- orgteamIdList 组织团队ID集合
                 *                  -- postypeIdList 任职类型ID集合
                 * @param id        ID的大于条件
                 * @param top       查询条数
                 * @return List<Map<String, Object>> 业务版本数据集合
                 */
                listIntersectEmpOrgrels(gteDate:Date,lteDate:Date,paramMap:$.java.util.Map,id:long,top:number):$.java.util.List;
            }
            interface HRPIDepempServiceHelper_C extends HRPIDepempServiceHelper_S {
                new():HRPIDepempServiceHelper;
            }
            interface HRPIDepempServiceHelper$ {
            }
            type HRPIDepempServiceHelper_T = HRPIDepempServiceHelper_S & HRPIDepempServiceHelper$;
            interface HRPIDepempServiceHelper extends HRPIDepempServiceHelper_T {
            }
            interface HRPICmpempServiceHelper_S {
                /**
                 * 获取所属管理范围
                 *
                 * @param cmpempId
                 * @return
                 */
                getCmpemp(cmpempId:long):$.java.util.Map;
                /**
                 * 获取管理范围记录
                 *
                 * @param cmpempId
                 * @return
                 */
                getManagingScope(cmpempId:long):$.java.util.Map;
            }
            interface HRPICmpempServiceHelper_C extends HRPICmpempServiceHelper_S {
                new():HRPICmpempServiceHelper;
            }
            interface HRPICmpempServiceHelper$ {
            }
            type HRPICmpempServiceHelper_T = HRPICmpempServiceHelper_S & HRPICmpempServiceHelper$;
            interface HRPICmpempServiceHelper extends HRPICmpempServiceHelper_T {
            }
            interface HRPTMMServiceHelper_S {
                /**
                 * 根据人员的企业人id，查询出对应人员的所有项目团队任职履历信息
                 *
                 * @param inParam 请求参数，企业人id集合
                 * @return 任职履历详情
                 */
                listTeamMemberRole(inParam:$.java.util.Map):$.java.util.Map;
            }
            interface HRPTMMServiceHelper_C extends HRPTMMServiceHelper_S {
                new():HRPTMMServiceHelper;
            }
            interface HRPTMMServiceHelper$ {
            }
            type HRPTMMServiceHelper_T = HRPTMMServiceHelper_S & HRPTMMServiceHelper$;
            interface HRPTMMServiceHelper extends HRPTMMServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.lcs{
            interface LCSCostCenterModule_S {
            }
            type LCSCostCenterModule_ST = $.kd.sdk.module.Module & LCSCostCenterModule_S;
            interface LCSCostCenterModule_C extends LCSCostCenterModule_ST {
                new():LCSCostCenterModule;
            }
            interface LCSCostCenterModule$ {
            }
            type LCSCostCenterModule_T = $.kd.sdk.module.Module & LCSCostCenterModule_S & LCSCostCenterModule$;
            interface LCSCostCenterModule extends LCSCostCenterModule_T {
            }
            interface LCSCostCenterServiceHelper_S {
                /**
                 * 新增/修改成本中心
                 *
                 * @param param 单次最大处理1w条
                 * @return 返回入参，保证个数一致，增加部分返回属性，success：true/false  message:错误信息
                 */
                saveCostCenters(param:$.java.util.Map):$.java.util.Map;
            }
            interface LCSCostCenterServiceHelper_C extends LCSCostCenterServiceHelper_S {
                new():LCSCostCenterServiceHelper;
            }
            interface LCSCostCenterServiceHelper$ {
            }
            type LCSCostCenterServiceHelper_T = LCSCostCenterServiceHelper_S & LCSCostCenterServiceHelper$;
            interface LCSCostCenterServiceHelper extends LCSCostCenterServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.msgcollaboration{
            interface HRMsgCollaborationModule_S {
            }
            type HRMsgCollaborationModule_ST = $.kd.sdk.module.Module & HRMsgCollaborationModule_S;
            interface HRMsgCollaborationModule_C extends HRMsgCollaborationModule_ST {
                new():HRMsgCollaborationModule;
            }
            interface HRMsgCollaborationModule$ {
            }
            type HRMsgCollaborationModule_T = $.kd.sdk.module.Module & HRMsgCollaborationModule_S & HRMsgCollaborationModule$;
            interface HRMsgCollaborationModule extends HRMsgCollaborationModule_T {
            }
            interface HRMsgCollaborationServiceHelper_S {
                /**
                 * 获取已订阅/生效的API信息
                 *
                 * @param msgSubNo 订阅方唯一识别码
                 * @return 已订阅/生效的API信息
                 */
                getAPIInfoByMsgSubNo(msgSubNo:string):$.java.util.List;
                /**
                 * 订阅方通过中台获取消息变动信息
                 *
                 * @param apiId   api id
                 * @param qFilter 过滤器
                 * @param orderBy 排序
                 * @return 人员信息
                 */
                getDataBySub(apiId:long,qFilter:$.kd.bos.orm.query.QFilter,orderBy:string):$.java.util.List;
                /**
                 * 根据消息中心编号获取消息中心消费者消费反馈信息
                 *
                 * @param msgNumber: 消息中心编号
                 * @param actionId:  活动id
                 * @return 消息中心消费者消息反馈信息
                 */
                getMsgCenterInfo(msgNumber:string,actionId:long):$.java.util.List;
                /**
                 * 根据消息中心编号获取消息中心消费者消费反馈信息
                 *
                 * @param paramsList 消息编号和活动id列表
                 * @return 消息中心消费者消息反馈信息
                 */
                getMsgCenterListInfo(paramsList:$.java.util.List):$.java.util.List;
                /**
                 * 根据活动ID获取发布方信息
                 *
                 * @param actionId 活动ID
                 * @return 发布方信息
                 */
                getPubByActionId(actionId:long):$.java.util.List;
                /**
                 * 根据发布方唯一识别码获取简单活动信息
                 *
                 * @param msgPubNo 发布方唯一识别码
                 * @return 简单活动信息
                 */
                getSimpleActionInfo(msgPubNo:string):$.java.util.Map;
                /**
                 * 根据 API模板配置 ID, 获取对应的XML描述信息
                 *
                 * @param id 模板配置ID
                 * @return 对应的XML描述信息
                 */
                getXMLDescById(id:long):string;
                /**
                 * 业务领域将需要协作的活动信息推送至中台服务 （1）校验活动的合法性 （2）根据活动信息获取活动发布信息、活动订阅信息 （3）将活动信息、活动发布信息推送消息中心 （3）将活动信息、活动发布信息、活动订阅信息均写入生产者队列
                 * 将发布者需要发送给订阅方的消息通过MQ发送到中台
                 *
                 * @param actionInfo 活动信息
                 */
                publishAction(actionInfo:$.java.util.Map):void;
                /**
                 * 将发布者需要发送给订阅方的消息，以批量方式通过MQ发送到中台
                 *
                 * @param actionInfoList:
                 * @return 消息发送结果
                 */
                publishAction(actionInfoList:$.java.util.List):kd.hr.hbp.common.mservice.HRMSendMsgResult;
                /**
                 * 新增活动基础资料数据
                 *
                 * @param actionDy: 活动动态对象
                 * @return 新增后的actionId
                 */
                saveActionDy(actionDy:$.kd.bos.dataentity.entity.DynamicObject):long;
                /**
                 * 新增活动类型基础资料数据
                 *
                 * @param actionTypeDy: 活动类型动态对象
                 * @return 新增后的actionTypeId
                 */
                saveActionTypeDy(actionTypeDy:$.kd.bos.dataentity.entity.DynamicObject):long;
                /**
                 * 新增/修改发布中心数据
                 *
                 * @param publisherMap: 发布者map
                 * @param isModify: 是否修改
                 * @return long 新增后的发布者唯一识别码
                 */
                saveMsgPublisher(publisherMap:$.java.util.Map,isModify:boolean):string;
                /**
                 * 将消费方反馈的消费信息更新到消费中心的消息中
                 *
                 * @param consumeMsgMap:反馈的消费信息(msgCenterId:消息中心id,businessTypeId:业务类型id,consumeMsg:消费方反馈的文本消息,handleStatus:消费方业务处理的状态)
                 */
                updateConsumeMsgInfo(consumeMsgMap:$.java.util.Map):void;
            }
            interface HRMsgCollaborationServiceHelper_C extends HRMsgCollaborationServiceHelper_S {
                new():HRMsgCollaborationServiceHelper;
            }
            interface HRMsgCollaborationServiceHelper$ {
            }
            type HRMsgCollaborationServiceHelper_T = HRMsgCollaborationServiceHelper_S & HRMsgCollaborationServiceHelper$;
            interface HRMsgCollaborationServiceHelper extends HRMsgCollaborationServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.multientityquery{
            interface HRQueryEntityModule_S {
            }
            type HRQueryEntityModule_ST = $.kd.sdk.module.Module & HRQueryEntityModule_S;
            interface HRQueryEntityModule_C extends HRQueryEntityModule_ST {
                new():HRQueryEntityModule;
            }
            interface HRQueryEntityModule$ {
            }
            type HRQueryEntityModule_T = $.kd.sdk.module.Module & HRQueryEntityModule_S & HRQueryEntityModule$;
            interface HRQueryEntityModule extends HRQueryEntityModule_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.odc{
            interface AdminOrgServiceHelper_S {
                /**
                 * 行政组织 - 新增
                 * @param adminOrgs
                 * @return resultMap
                 */
                addAdminOrg(adminOrgs:$.java.util.ArrayList):$.java.util.Map;
                /**
                 * 行政组织基本信息查询（按照BOID）
                 * @param orgIdList 业务组织 BOID
                 * @param date 查询日期
                 * @return
                 */
                adminOrgInfoQuery(orgIdList:$.java.util.List,date:Date):$.java.util.Map;
                /**
                 * 批量获取行政组织结构信息
                 * @param idList 组织boid集合
                 * @param date 查询日期
                 * @param needLongInfo 是否需要查询长名称、长编码
                 * @return
                 */
                adminOrgStructQuery(idList:$.java.util.List,date:Date,needLongInfo:boolean):$.java.util.Map;
                /**
                 * 行政组织 - 信息变更
                 * @param adminOrgs
                 * @return
                 */
                change(adminOrgs:$.java.util.List):$.java.util.Map;
                /**
                 * 行政组织 - 上级调整
                 * @param adminOrgs
                 * @return
                 */
                changeParent(adminOrgs:$.java.util.List):$.java.util.Map;
                /**
                 * 行政组织 - 禁用
                 * @return
                 */
                disable(disableParams:$.java.util.Map):$.java.util.Map;
                /**
                 * 行政组织 - 禁用
                 * @param idList 行政组织BOID
                 * @param buId 业务组织
                 * @param effectDate 生效日期
                 * @return
                 */
                disable(idList:$.java.util.List,buId:long,effectDate:Date):$.java.util.Map;
                /**
                 * 行政组织 - 启用
                 * @param idList 行政组织BOID
                 * @param buId 业务组织
                 * @param effectDate 生效日期
                 * @return
                 */
                enable(idList:$.java.util.List,buId:long,effectDate:Date):$.java.util.Map;
                /**
                 * 行政组织基本信息查询（按照编码）
                 * @param orgNumberList 行政组织编码
                 * @param date 查询日期
                 * @return
                 */
                getAdminOrgInfoByNumber(orgNumberList:$.java.util.List,date:Date):$.java.util.Map;
                /**
                 * 根据boId或编码查询指定层级的组织信息
                 *
                 * @param orgIds 组织boId
                 * @param orgNumbers 组织编码
                 * @param level 指定层级
                 * @param date 查询日期
                 * @return 组织信息
                 */
                getAdminOrgInfoByNumber(orgIds:$.java.util.List,orgNumbers:$.java.util.List,level:number,date:Date):$.java.util.Map;
                /**
                 * 组织合并接口
                 *
                 * @param billDy   单据对象
                 * @param dyList   需要新增，信息变更，上级调整的动态对象
                 * @param mergeMap key为合并后组织编码，value为合并组织动态对象
                 */
                merge(billDy:$.kd.bos.dataentity.entity.DynamicObject,dyList:$.java.util.List,mergeMap:$.java.util.Map):$.java.util.Map;
            }
            interface AdminOrgServiceHelper_C extends AdminOrgServiceHelper_S {
                new():AdminOrgServiceHelper;
            }
            interface AdminOrgServiceHelper$ {
            }
            type AdminOrgServiceHelper_T = AdminOrgServiceHelper_S & AdminOrgServiceHelper$;
            interface AdminOrgServiceHelper extends AdminOrgServiceHelper_T {
            }
            interface HROdcModule_S {
            }
            type HROdcModule_ST = $.kd.sdk.module.Module & HROdcModule_S;
            interface HROdcModule_C extends HROdcModule_ST {
                new():HROdcModule;
            }
            interface HROdcModule$ {
            }
            type HROdcModule_T = $.kd.sdk.module.Module & HROdcModule_S & HROdcModule$;
            interface HROdcModule extends HROdcModule_T {
            }
            interface PositionServiceHelper_S {
                /**
                 *  新增岗位信息
                 * 入参为岗位基本信息动态对象集合
                 *
                 *  @param   positions      岗位基本信息动态对象集合
                 *  @return  Map<String, Object>
                 */
                addPosition(positions:$.java.util.List):$.java.util.Map;
                /**
                 * 变更岗位信息
                 * 入参为岗位基本信息动态对象集合，对象中只需要传入岗位Id和需要变更的属性
                 *
                 * @param           positions      岗位基本信息动态对象集合
                 * @return          Map<String, Object>
                 */
                changePosition(positions:$.java.util.List):$.java.util.Map;
                /**
                 * 禁用岗位
                 *
                 * @param   ids      岗位ID集合
                 * @return  Map<String, Object>
                 */
                disablePosition(ids:$.java.util.List):$.java.util.Map;
                /**
                 * 启用岗位
                 *
                 * @param   ids      岗位ID集合
                 * @return  Map<String, Object>
                 */
                enablePosition(ids:$.java.util.List):$.java.util.Map;
                /**
                 * 根据岗位boid，生效日期， 查询岗位的所有下级(一直往下查，查到叶子节点)
                 * @param positionIdList 岗位boid集合
                 * @param date 生效日期
                 * @param containsDarkpos  是否包含暗岗
                 * @return Map<String, Object> <岗位boid， 下级岗位数据>
                 */
                queryAllChildPositionHis(positionIdList:$.java.util.List,date:Date,containsDarkpos:boolean):$.java.util.Map;
            }
            interface PositionServiceHelper_C extends PositionServiceHelper_S {
                new():PositionServiceHelper;
            }
            interface PositionServiceHelper$ {
            }
            type PositionServiceHelper_T = PositionServiceHelper_S & PositionServiceHelper$;
            interface PositionServiceHelper extends PositionServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.permission{
            interface HRPermissionModule_S {
            }
            type HRPermissionModule_ST = $.kd.sdk.module.Module & HRPermissionModule_S;
            interface HRPermissionModule_C extends HRPermissionModule_ST {
                new():HRPermissionModule;
            }
            interface HRPermissionModule$ {
            }
            type HRPermissionModule_T = $.kd.sdk.module.Module & HRPermissionModule_S & HRPermissionModule$;
            interface HRPermissionModule extends HRPermissionModule_T {
            }
            interface HRPermissionServiceHelper_S {
                /**
                 * 同步权限档案
                 * @param userId 用户id
                 * @param orgId HR组织
                 * @param description description
                 * @return 操作返回结果
                 */
                createPermFile(userId:long,orgId:long,description:$.kd.bos.dataentity.entity.LocaleString):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 根据关联ID调整用户角色分配的开始和结束日期
                 * @param relatId 关联ID
                 * @param validStart 开始日期
                 * @param validEnd 结束日期
                 * @return 操作结果
                 */
                delayUserRoleByRelatId(relatId:long,validStart:Date,validEnd:Date):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 删除用户在当前角色上的所有权限+
                 *
                 * @param userId     用户id
                 * @param roleNumber 角色编码
                 * @return 操作返回结果
                 */
                deleteUserRole(userId:long,roleNumber:string):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 根据关联ID删除用户角色分配
                 * @param relatId 关联ID
                 * @return 操作结果
                 */
                deleteUserRoleByRelatId(relatId:long):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 获取列表上有权限的行政组织范围，ID明细列表
                 * @param userId       :用户ID
                 * @param appId        :应用ID
                 * @param entityNumber :实体编码
                 * @param permItemId   :权限项，可参考PermissionStatus
                 * @param propKey      :属性key
                 * @return 有权限的组织结果集
                 */
                getAuthorizedAdminOrgSet(userId:long,appId:string,entityNumber:string,permItemId:string,propKey:string):kd.hr.hbp.common.model.AuthorizedOrgResult;
                /**
                 * 获取F7上有权限的行政组织范围，ID明细列表
                 *
                 * @param userId       用户ID
                 * @param appId        应用ID
                 * @param entityNumber 实体编码
                 * @param permItemId   权限项
                 * @param propKey      基础资料属性key
                 * @return 有权限的组织结果集
                 */
                getAuthorizedAdminOrgsF7(userId:long,appId:string,entityNumber:string,permItemId:string,propKey:string):kd.hr.hbp.common.model.AuthorizedOrgResult;
                /**
                 * 获取F7上有权限的行政组织范围，带包含下级信息
                 *
                 * @param userId       用户ID
                 * @param appId        应用ID
                 * @param entityNumber 实体编码
                 * @param permItemId   权限项
                 * @param propKey      基础资料属性key
                 * @return 有权限的组织结果集
                 */
                getAuthorizedAdminOrgsF7WithSubInfo(userId:long,appId:string,entityNumber:string,permItemId:string,propKey:string):kd.hr.hbp.common.model.AuthorizedOrgResultWithSub;
                /**
                 * 获取列表上有权限的行政组织范围，带包含下级信息
                 *
                 * @param userId       用户ID
                 * @param appId        应用ID
                 * @param entityNumber 实体编码
                 * @param permItemId   权限项
                 * @param propKey      基础资料属性key
                 * @return 有权限的组织结果集
                 */
                getAuthorizedAdminOrgsWithSub(userId:long,appId:string,entityNumber:string,permItemId:string,propKey:string):kd.hr.hbp.common.model.AuthorizedOrgResultWithSub;
                /**
                 * 获取列表上有权限的组织团队，ID明细列表
                 * @param userId       :用户ID
                 * @param appId        :应用ID
                 * @param entityNumber :实体编码
                 * @param permItemId   :权限项
                 * @param propKey      :f7属性key
                 * @return 有权限的组织结果集
                 */
                getAuthorizedOrgTeams(userId:long,appId:string,entityNumber:string,permItemId:string,propKey:string):kd.hr.hbp.common.model.AuthorizedOrgTeamResult;
                /**
                 * 获取F7上有权限的组织团队, ID明细列表
                 *
                 * @param userId       :用户ID
                 * @param appId        :应用ID
                 * @param entityNumber :实体编码
                 * @param permItemId   :权限项
                 * @param propKey      :f7属性key
                 * @return 有权限的组织结果集
                 */
                getAuthorizedOrgTeamsF7(userId:long,appId:string,entityNumber:string,permItemId:string,propKey:string):kd.hr.hbp.common.model.AuthorizedOrgTeamResult;
                /**
                 * 通过角色取维度集合
                 * @param roleNumber 角色编码
                 * @return 维度集合
                 */
                getRoleDimsByRoleNumber(roleNumber:string):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 查询所有角色
                 * @param pageIndex 起始位置
                 * @param pageSize 每页记录行数
                 * @param enable 使用状态
                 * @return 结果列表
                 */
                getRoleList(pageIndex:string,pageSize:string,enable:string):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 用户分配角色（不包含高级配置及字段权限）
                 *
                 * @param userId       用户id
                 * @param roleNumber   角色编码
                 * @param validStart   有效期开始日期
                 * @param validEnd     有效期结束日期
                 * @param isCustomData 用户是否自定义范围
                 * @param bucaPermData 用户是否自定义范围
                 * @param creatorId    业务管理视图id：职能数据范围
                 * @return 操作返回结果
                 */
                userAssignRole(userId:long,roleNumber:string,validStart:Date,validEnd:Date,isCustomData:boolean,bucaPermData:$.java.util.Map,creatorId:long):kd.hr.hbp.common.api.HrApiResponse;
            }
            interface HRPermissionServiceHelper_C extends HRPermissionServiceHelper_S {
                new():HRPermissionServiceHelper;
            }
            interface HRPermissionServiceHelper$ {
            }
            type HRPermissionServiceHelper_T = HRPermissionServiceHelper_S & HRPermissionServiceHelper$;
            interface HRPermissionServiceHelper extends HRPermissionServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.prompt{
            interface HRPromptModule_S {
            }
            type HRPromptModule_ST = $.kd.sdk.module.Module & HRPromptModule_S;
            interface HRPromptModule_C extends HRPromptModule_ST {
                new():HRPromptModule;
            }
            interface HRPromptModule$ {
            }
            type HRPromptModule_T = $.kd.sdk.module.Module & HRPromptModule_S & HRPromptModule$;
            interface HRPromptModule extends HRPromptModule_T {
            }
            interface PromptServiceHelper_S {
                /**
                 * 获取提示语纯文本和html
                 *
                 * @param id 提示语id
                 * @return 结果
                 */
                getContentAndHtml(id:long):$.java.util.Map;
                /**
                 * 获取提示语富文本
                 *
                 * @param promptId 提示语id
                 * @return 富文本
                 */
                getPromptContent(promptId:long):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * id列表获取提示语
                 *
                 * @param PromptPks 主键
                 * @return DynamicObject[]
                 */
                getPrompts(PromptPks:$.java.util.List):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * 提示语是否存在
                 *
                 * @param promptId promptId
                 * @return 是否存在
                 */
                isExists(promptId:long):boolean;
                /**
                 * 获取提示语
                 *
                 * @param entityId  实体编码
                 * @param controlId 控件编码
                 * @return 提示语字段
                 */
                promptServiceHelper(entityId:string,controlId:string):$.java.util.List;
                /**
                 * 根据当前控件及数据模型获取对应规则下的提示语
                 *
                 * @param entityId   实体编码
                 * @param controlKey 控件编码
                 * @param dataModel  动态对象
                 * @return 符合条件的提示语内容
                 */
                queryPromptContent(entityId:string,controlKey:string,dataModel:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.List;
                /**
                 * 查询规则下提示语纯文本内容
                 *
                 * @param entityId   实体编码
                 * @param controlKey 控件标识
                 * @param dataModel  数据对象
                 * @return 提示语Map集合
                 */
                queryPromptForString(entityId:string,controlKey:string,dataModel:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.List;
                /**
                 * 查询规则下提示语id和内容
                 *
                 * @param entityId   实体编码
                 * @param controlKey 控件标识
                 * @param dataModel  数据对象
                 * @return 提示语Map集合
                 */
                queryPromptIdAndContent(entityId:string,controlKey:string,dataModel:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            interface PromptServiceHelper_C extends PromptServiceHelper_S {
                new():PromptServiceHelper;
            }
            interface PromptServiceHelper$ {
            }
            type PromptServiceHelper_T = PromptServiceHelper_S & PromptServiceHelper$;
            interface PromptServiceHelper extends PromptServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.ruleengine{
            interface RuleEngineServiceHelper_S {
                /**
                 * 新增一个策略
                 *
                 * @param policyMap 策略
                 * @return 结果
                 */
                addPolicyWithStatus(policyMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 批量新增策略
                 *
                 * @param policyMapList 策略列表
                 * @return 结果
                 */
                batchAddPolicyWithStatus(policyMapList:$.java.util.List):$.java.util.Map;
                /**
                 * 批量执行规则引擎
                 *
                 * @param requestMapList 请求参数列表
                 * @return 执行结果列表（如果出参中有配置动态对象会转换为动态对象，调用方可以直接用DynamicObject；如果没有配置动态对象，则不会有任何转换）
                 */
                batchCallRuleEngine(requestMapList:$.java.util.List):$.java.util.List;
                /**
                 * 批量修改策略
                 *
                 * @param policyMapList 策略列表
                 * @return 结果
                 */
                batchModifyPolicyWithStatus(policyMapList:$.java.util.List):$.java.util.Map;
                /**
                 * 根据输入参数，单次执行规则引擎
                 *
                 * @param requestMap 请求参数
                 * @return 执行结果（如果出参中有配置动态对象会转换为动态对象，调用方可以直接用DynamicObject；如果没有配置动态对象，则不会有任何转换）
                 */
                callRuleEngine(requestMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 根据输入参数，单次执行规则引擎
                 *
                 * @param requestMap 请求参数
                 * @return 执行原始结果（如果出参中有配置动态对象不会转换，需要调用方自己转换为DynamicObject）
                 */
                callRuleEngineForOriginal(requestMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 根据id删除策略
                 * @param policyIds 策略id集合
                 * @return 被删除的策略数量
                 */
                deletePolicy(policyIds:$.java.util.List):number;
                /**
                 * 修改一个策略
                 *
                 * @param policyMap 策略对象
                 * @return 结果
                 */
                modifyPolicyWithStatus(policyMap:$.java.util.Map):$.java.util.Map;
            }
            interface RuleEngineServiceHelper_C extends RuleEngineServiceHelper_S {
                new():RuleEngineServiceHelper;
            }
            interface RuleEngineServiceHelper$ {
            }
            type RuleEngineServiceHelper_T = RuleEngineServiceHelper_S & RuleEngineServiceHelper$;
            interface RuleEngineServiceHelper extends RuleEngineServiceHelper_T {
            }
            interface HRRuleEngineModule_S {
            }
            type HRRuleEngineModule_ST = $.kd.sdk.module.Module & HRRuleEngineModule_S;
            interface HRRuleEngineModule_C extends HRRuleEngineModule_ST {
                new():HRRuleEngineModule;
            }
            interface HRRuleEngineModule$ {
            }
            type HRRuleEngineModule_T = $.kd.sdk.module.Module & HRRuleEngineModule_S & HRRuleEngineModule$;
            interface HRRuleEngineModule extends HRRuleEngineModule_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.search{
            interface HRSmartSearchModule_S {
            }
            type HRSmartSearchModule_ST = $.kd.sdk.module.Module & HRSmartSearchModule_S;
            interface HRSmartSearchModule_C extends HRSmartSearchModule_ST {
                new():HRSmartSearchModule;
            }
            interface HRSmartSearchModule$ {
            }
            type HRSmartSearchModule_T = $.kd.sdk.module.Module & HRSmartSearchModule_S & HRSmartSearchModule$;
            interface HRSmartSearchModule extends HRSmartSearchModule_T {
            }
        }
        namespace kd.hr.hbp.business.openservicehelper.timeline{
            interface HRTimelineModule_S {
            }
            interface HRTimelineModule_C extends HRTimelineModule_S {
                new():HRTimelineModule;
            }
            interface HRTimelineModule$ {
            }
            type HRTimelineModule_T = HRTimelineModule_S & HRTimelineModule$;
            interface HRTimelineModule extends HRTimelineModule_T {
            }
            interface TimelineServiceHelper_S {
                /**
                 * 单个新增
                 *
                 * @param entityNumber 实体编码
                 * @param obj          对象
                 * @return HrApiResponse<TimelineResultInfo> 返回值
                 */
                createTimespan(entityNumber:string,obj:$.kd.bos.dataentity.entity.DynamicObject):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 批量新增
                 *
                 * @param entityNumber 实体编码
                 * @param objs         对象集合
                 * @return HrApiResponse<TimelineResultInfo> 返回值
                 */
                createTimespans(entityNumber:string,objs:$.kd.bos.dataentity.entity.DynamicObject[]):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 单个删除
                 *
                 * @param entityNumber 实体编码
                 * @param id           id
                 * @return HrApiResponse<TimelineResultInfo> 返回值
                 */
                deleteTimespan(entityNumber:string,id:long):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 批量删除
                 *
                 * @param entityNumber 实体编码
                 * @param ids          ids
                 * @return HrApiResponse<TimelineResultInfo> 返回值
                 */
                deleteTimespans(entityNumber:string,ids:$.java.util.List):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 判断是否继承了 HR时间轴最小模板
                 *
                 * @param entityNumber 实体编码
                 * @return 是否继承了 HR时间轴最小模板
                 */
                isInheritTpl(entityNumber:string):boolean;
                /**
                 * 批量判断是否继承了 HR时间轴最小模板
                 *
                 * @param entityNumbers 实体编码
                 * @return 是否继承了 HR时间轴最小模板
                 */
                isInheritTpls(entityNumbers:$.java.util.Set):$.java.util.Map;
                /**
                 * 获取时间轴实体的配置信息
                 *
                 * @param entityNumber 实体编码
                 * @return TimeLineEntityConf 实体的配置信息
                 */
                queryTimelineEntityConf(entityNumber:string):kd.hr.hbp.business.service.timeline.dao.TimelineEntityConf;
                /**
                 * 按逻辑主键批量查询
                 *
                 * @param entityNumber     实体编码
                 * @param logicKeyValsList 逻辑主键(一个逻辑主键一个map)
                 * @return 数据
                 */
                queryTimespanByLogicKey(entityNumber:string,logicKeyValsList:$.java.util.List):$.java.util.List;
                /**
                 * 按QFilter查询
                 *
                 * @param entityNumber 实体编码
                 * @param qfilter      查询条件
                 * @return 数据
                 */
                queryTimespanByQFilter(entityNumber:string,qfilter:$.kd.bos.orm.query.QFilter):$.java.util.List;
                /**
                 * 单个修改
                 *
                 * @param entityNumber 实体编码
                 * @param obj          对象集合
                 * @return HrApiResponse<TimelineResultInfo> 返回值
                 */
                updateTimespan(entityNumber:string,obj:$.kd.bos.dataentity.entity.DynamicObject):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 批量修改
                 *
                 * @param entityNumber 实体编码
                 * @param objs         对象集合
                 * @return HrApiResponse<TimelineResultInfo> 返回值
                 */
                updateTimespans(entityNumber:string,objs:$.kd.bos.dataentity.entity.DynamicObject[]):kd.hr.hbp.common.api.HrApiResponse;
            }
            interface TimelineServiceHelper_C extends TimelineServiceHelper_S {
                new():TimelineServiceHelper;
            }
            interface TimelineServiceHelper$ {
            }
            type TimelineServiceHelper_T = TimelineServiceHelper_S & TimelineServiceHelper$;
            interface TimelineServiceHelper extends TimelineServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.service.diff{
            interface HRPluginProxy_S {
            }
            interface HRPluginProxy_C extends HRPluginProxy_S {
                new(arg0:any,arg1:$.java.lang.Class,arg2:string,arg3:$.kd.bos.extplugin.PluginFilter):HRPluginProxy;
            }
            interface HRPluginProxy$ {
                callAfter(caller:$.kd.bos.extplugin.PluginCall):$.java.util.List;
                callBefore(caller:$.kd.bos.extplugin.PluginCall):$.java.util.List;
                callReplace(caller:$.kd.bos.extplugin.PluginCall):$.java.util.List;
                callReplaceIfPresent(caller:$.kd.bos.extplugin.PluginCall):$.java.util.List;
                getCaseName():string;
                getDefaultPlugin():any;
                getPluginList():$.java.util.List;
                getPlugins():$.java.util.List;
                setCaseName(caseName:string):void;
                setDefaultPlugin(arg0:any):void;
                setPluginList(pluginList:$.java.util.List):void;
            }
            type HRPluginProxy_T = HRPluginProxy_S & HRPluginProxy$;
            interface HRPluginProxy extends HRPluginProxy_T {
            }
            interface HRPlugInProxyFactory_S {
                create(arg0:any,arg1:$.java.lang.Class,arg2:string,arg3:$.kd.bos.extplugin.PluginFilter):HRPluginProxy;
            }
            interface HRPlugInProxyFactory_C extends HRPlugInProxyFactory_S {
                new():HRPlugInProxyFactory;
            }
            interface HRPlugInProxyFactory$ {
            }
            type HRPlugInProxyFactory_T = HRPlugInProxyFactory_S & HRPlugInProxyFactory$;
            interface HRPlugInProxyFactory extends HRPlugInProxyFactory_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula{
            interface HRFormulaPlatformModule_S {
            }
            type HRFormulaPlatformModule_ST = $.kd.sdk.module.Module & HRFormulaPlatformModule_S;
            interface HRFormulaPlatformModule_C extends HRFormulaPlatformModule_ST {
                new():HRFormulaPlatformModule;
            }
            interface HRFormulaPlatformModule$ {
            }
            type HRFormulaPlatformModule_T = $.kd.sdk.module.Module & HRFormulaPlatformModule_S & HRFormulaPlatformModule$;
            interface HRFormulaPlatformModule extends HRFormulaPlatformModule_T {
            }
            interface FormulaParseService_S {
                /**
                 * 在数据库查询构建selectItem表达式
                 *
                 * @param node:    节点对象
                 * @param calItem: 计算项目对象
                 * @return kd.hr.hbp.business.service.formula.entity.expression.Expression
                 */
                getBaseDataOrStrExpression(node:kd.hr.hbp.business.service.formula.entity.node.OriginalNode,calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):kd.hr.hbp.business.service.formula.entity.expression.Expression;
                /**
                 * 去元数据缓存获取枚举类型的selectItem对象
                 *
                 * @param node:    节点对象
                 * @param calItem: 计算项目对象
                 * @return kd.hr.hbp.business.service.formula.entity.expression.Expression
                 */
                getEnumOrStrExpression(node:kd.hr.hbp.business.service.formula.entity.node.OriginalNode,calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):kd.hr.hbp.business.service.formula.entity.expression.Expression;
            }
            interface FormulaParseService_C extends FormulaParseService_S {
                new():FormulaParseService;
            }
            interface FormulaParseService$ {
                /**
                 * 获取表达式的具体类型
                 *
                 * @param conditionExpression: 当前条件表达式
                 * @param nodes: 节点集合
                 * @param formula: 公式解析上下文
                 * @return java.util.List<kd.hr.hbp.business.service.formula.entity.expression.Expression>解析式集合
                 */
                getExpression(conditionExpression:kd.hr.hbp.business.service.formula.entity.expression.ConditionExpression,nodes:$.java.util.List,formula:kd.hr.hbp.business.service.formula.entity.FormulaInfo):$.java.util.List;
                /**
                 * 解析公式方法入口
                 *
                 * @param formula:   公式页面动态对象
                 * @param formulaId: 公式对象主键
                 * @param view:      当前页面视图对象
                 * @return kd.hr.hbp.business.service.formula.entity.FormulaInfo
                 */
                parseFormula(formula:$.kd.bos.dataentity.entity.DynamicObject,formulaId:long,view:$.kd.bos.form.IFormView):kd.hr.hbp.business.service.formula.entity.FormulaInfo;
                /**
                 * 公式解析sdk
                 *
                 * @param formula:                公式页面动态对象
                 * @param formulaId:              公式id
                 * @param bizAppNumber:           公式所在应用编码
                 * @param treeNodeItems:          计算项目集合
                 * @param resultItems:            结果项目集合
                 * @param dataGradeItems:         分级数据集合
                 * @param isParseByUniqueCodeExp: 是否根据uniqueCodeeExp解析
                 * @return kd.bos.dataentity.entity.DynamicObject
                 */
                parseFormulaDy(formula:$.kd.bos.dataentity.entity.DynamicObject,formulaId:long,bizAppNumber:string,treeNodeItems:$.java.util.List,resultItems:$.java.util.List,dataGradeItems:$.java.util.List,isParseByUniqueCodeExp:boolean):$.kd.bos.dataentity.entity.DynamicObject;
            }
            type FormulaParseService_T = FormulaParseService_S & FormulaParseService$;
            interface FormulaParseService extends FormulaParseService_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.cal.service{
            interface AbsHRMPCalcService_S {
            }
            type AbsHRMPCalcService_ST = IHRMPCalcService_S & AbsHRMPCalcService_S;
            interface AbsHRMPCalcService_C extends AbsHRMPCalcService_ST {
                new():AbsHRMPCalcService;
            }
            interface AbsHRMPCalcService$ {
                calc(paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO,paramIdList:$.java.util.List):$.java.util.Map;
            }
            type AbsHRMPCalcService_T = IHRMPCalcService & AbsHRMPCalcService_S & AbsHRMPCalcService$;
            interface AbsHRMPCalcService extends AbsHRMPCalcService_T {
            }
            interface IHRMPCalcService_S {
            }
            interface IHRMPCalcService$ {
                /**
                 * 计算入口
                 *
                 * @param formulaParse       公式计算实现类
                 * @param calProportionClass 占比公式计算实现类
                 * @param paramVO            输入参数
                 * @param paramIdList        参数Id集合
                 * @return java.util.Map<java.lang.String, CalResultDetailVO> <key:paramId,value:结果详情>
                 */
                calc(formulaParse:kd.hr.hbp.business.service.formula.cal.template.FormulaParse,calProportionClass:kd.hr.hbp.business.service.formula.cal.template.FormulaParse,paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO,paramIdList:$.java.util.List):$.java.util.Map;
                /**
                 * 回收动态生成的计算类
                 *
                 * @param formulaCode 计算类代码
                 */
                clear(formulaCode:string):void;
                /**
                 * 创建计算类，业务实现实现可选。
                 *
                 * @param className: 公式类名称标识
                 * @param paramVO:  参数集合（包含公式详情和函数详情集合）
                 * @return FormulaParse
                 * @throw
                 */
                createBizClassImpl(className:string,paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO):kd.hr.hbp.business.service.formula.cal.template.FormulaParse;
                /**
                 * 创建占比类，业务实现实现可选。
                 *
                 * @param className: 公式类名称标识
                 * @param paramVO:  参数集合（包含公式详情和函数详情集合）
                 * @return FormulaParse
                 * @throw
                 */
                createBizProportionClassImpl(className:string,paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO):kd.hr.hbp.business.service.formula.cal.template.FormulaParse;
                /**
                 * 动态创建计算类
                 *
                 * @param className:       公式类名称标识
                 * @param formulaInfoList: 公式详情集合
                 * @param fcDetailList:    函数详情集合
                 * @return FormulaParse
                 * @throw
                 */
                createClassImpl(className:string,formulaInfoList:$.java.util.List,fcDetailList:$.java.util.List):kd.hr.hbp.business.service.formula.cal.template.FormulaParse;
                /**
                 * 3.计算取数
                 *
                 * @param paramVO 取数请求参数
                 */
                getCalItemData(paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO):void;
                /**
                 * 4.执行计算
                 *
                 * @param formulaParse:       公式计算实现类对象
                 * @param calProportionClass: 占比公式计算实现类对象
                 * @param paramVO             取数请求参数
                 * @param paramIdList:        参数Id集合
                 * @return CalResultDetailVO <结果详情对象>
                 */
                handleCal(formulaParse:kd.hr.hbp.business.service.formula.cal.template.FormulaParse,calProportionClass:kd.hr.hbp.business.service.formula.cal.template.FormulaParse,paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO,paramIdList:$.java.util.List):$.java.util.Map;
                /**
                 * 2.处理分段
                 *
                 * @param paramVO 分段参数
                 */
                handleCalProportion(paramVO:kd.hr.hbp.business.service.formula.cal.vo.CalAllParamVO):void;
            }
            type IHRMPCalcService_T = IHRMPCalcService_S & IHRMPCalcService$;
            interface IHRMPCalcService extends IHRMPCalcService_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.cal.template{
            interface FormulaParse_S {
            }
            type FormulaParse_ST = ParentFormulaParse_S & FormulaParse_S;
            interface FormulaParse_C extends FormulaParse_ST {
                new():FormulaParse;
            }
            interface FormulaParse$ {
                /**
                 * 添加全局类型项目的数据到Map中
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                addCustomCalItemValue(uniqueCode:string,value:any):void;
                /**
                 * 添加自定义项目的数据到最后输出的Map中
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                addOutputCustomCalItemValue(uniqueCode:string,value:any):void;
                /**
                 * 添加对象类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value
                 */
                addResultValue(uniqueCode:string,value:any):void;
                /**
                 * 添加逻辑类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                addResultValue(uniqueCode:string,value:boolean):void;
                /**
                 * 添加整数类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                addResultValue(uniqueCode:string,value:number):void;
                /**
                 * 添加数值或金额类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                addResultValue(uniqueCode:string,value:$.java.math.BigDecimal):void;
                /**
                 * 添加动态类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value
                 */
                addResultValue(uniqueCode:string,value:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 添加日期类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                addResultValue(uniqueCode:string,value:Date):void;
                /**
                 * 添加文本类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value
                 */
                addResultValue(uniqueCode:string,value:string):void;
                /**
                 * 添加数值或金额类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:any,sectionKey:string):void;
                /**
                 * 添加逻辑类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:boolean,sectionKey:string):void;
                /**
                 * 添加整数类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:number,sectionKey:string):void;
                /**
                 * 添加动态类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:$.kd.bos.dataentity.entity.DynamicObject,sectionKey:string):void;
                /**
                 * 添加日期类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:Date,sectionKey:string):void;
                /**
                 * 添加数值或金额类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:$.java.math.BigDecimal,sectionKey:string):void;
                /**
                 * 添加文本类型的计算项目值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 * @param sectionKey 项目分段期间key
                 */
                addResultValue(uniqueCode:string,value:string,sectionKey:string):void;
                /**
                 * 在计算结束后计算累加器的值
                 *
                 * @return void
                 * @throw
                 */
                calAddSumValueAfterAllCal():void;
                getAddSumMap():$.java.util.Map;
                getClassNameKey():string;
                getCustomCalItemMap():$.java.util.Map;
                /**
                 * 取支持项目中全局变量的支持项目的值
                 *
                 * @param uniqueCode
                 * @return
                 */
                getCustomCalItemValue(uniqueCode:string):string;
                /**
                 * 取支持项目中全局变量的支持项目的值并转成动态对象
                 *
                 * @param uniqueCode
                 * @return
                 */
                getCustomCalItemValueAsDynamicObj(uniqueCode:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 从数据分级对象中获取对应的分级结果并转换成BigDecimal
                 *
                 * @param dataGradeUniqueCode: 数据分级对象唯一编码
                 * @param resultKey:           数据分级获取的结果key
                 * @param params:              数据分级入参数组
                 * @return java.math.BigDecimal
                 */
                getDataGradeResultToBigDecimal(dataGradeUniqueCode:string,resultKey:string,...params:any[]):$.java.math.BigDecimal;
                /**
                 * 从数据分级对象中获取对应的分级结果并转换成日期
                 *
                 * @param dataGradeUniqueCode: 数据分级对象唯一编码
                 * @param resultKey:           数据分级获取的结果key
                 * @param params:              数据分级入参数组
                 * @return java.util.Date
                 */
                getDataGradeResultToDate(dataGradeUniqueCode:string,resultKey:string,...params:any[]):Date;
                /**
                 * 从数据分级对象中获取对应的分级结果并转换成动态对象
                 *
                 * @param dataGradeUniqueCode: 数据分级对象唯一编码
                 * @param resultKey:           数据分级获取的结果key
                 * @param params:              数据分级入参数组
                 * @return kd.bos.dataentity.entity.DynamicObject
                 */
                getDataGradeResultToDynamicObject(dataGradeUniqueCode:string,resultKey:string,...params:any[]):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 从数据分级对象中获取对应的分级结果并转换成整数
                 *
                 * @param dataGradeUniqueCode: 数据分级对象唯一编码
                 * @param resultKey:           数据分级获取的结果key
                 * @param params:              数据分级入参数组
                 * @return java.lang.Integer
                 */
                getDataGradeResultToInteger(dataGradeUniqueCode:string,resultKey:string,...params:any[]):number;
                /**
                 * 从数据分级对象中获取对应的分级结果并转换成字符串
                 *
                 * @param dataGradeUniqueCode: 数据分级对象唯一编码
                 * @param resultKey:           数据分级获取的结果key
                 * @param params:              数据分级入参数组
                 * @return java.lang.String
                 */
                getDataGradeResultToString(dataGradeUniqueCode:string,resultKey:string,...params:any[]):string;
                getDynamicObjectByEntityNumberAndId(entityNumber:string,id:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取数值类型公式引入项目字段值
                 *
                 * @param uniqueCode        公式依赖项目字段唯一编码
                 * @param sectionKey        日期区间key
                 * @param calItemUniqueCode 计算项目唯一编码
                 * @return
                 */
                getFieldValueAsBigDecimal(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):$.java.math.BigDecimal;
                /**
                 * 获取数字数组类型公式依赖项目字段值
                 *
                 * @param uniqueCode:        公式依赖项目字段唯一编码
                 * @param sectionKey:        日期区间key
                 * @param calItemUniqueCode: 计算项目唯一编码
                 * @return java.math.BigDecimal[]
                 * @throw
                 */
                getFieldValueAsBigDecimalArray(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):$.java.math.BigDecimal[];
                /**
                 * 获取逻辑类型公式引入项目字段值
                 *
                 * @param uniqueCode        公式依赖项目字段唯一编码
                 * @param sectionKey        日期区间key
                 * @param calItemUniqueCode 计算项目唯一编码
                 * @return
                 */
                getFieldValueAsBoolean(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):boolean;
                /**
                 * 获取逻辑类型公式引入项目字段值
                 *
                 * @param uniqueCode:        公式依赖项目字段唯一编码
                 * @param sectionKey:        日期区间key
                 * @param calItemUniqueCode: 计算项目唯一编码
                 * @return java.lang.Boolean[]
                 * @throw
                 */
                getFieldValueAsBooleanArray(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):boolean[];
                /**
                 * 获取日期类型公式引入项目字段值
                 *
                 * @param uniqueCode        公式依赖项目字段唯一编码
                 * @param sectionKey        日期区间key
                 * @param calItemUniqueCode 计算项目唯一编码
                 * @return
                 */
                getFieldValueAsDate(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):Date;
                /**
                 * 获取日期数组类型公式引入项目字段值
                 *
                 * @param uniqueCode        公式依赖项目字段唯一编码
                 * @param sectionKey        日期区间key
                 * @param calItemUniqueCode 计算项目唯一编码
                 * @return
                 */
                getFieldValueAsDateArray(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):Date[];
                /**
                 * 从参数中获取动态对象类型的参数并转换为动态对象返回
                 *
                 * @param uniqueCode:        计算项目唯一编码
                 * @param sectionKey:        分段Key
                 * @param calItemUniqueCode: 计算结果项目唯一编码
                 * @return kd.bos.dataentity.entity.DynamicObject
                 */
                getFieldValueAsDynamicObject(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取整数类型公式引入项目字段值
                 *
                 * @param uniqueCode        公式依赖项目字段唯一编码
                 * @param sectionKey        日期区间key
                 * @param calItemUniqueCode 计算项目唯一编码
                 * @return
                 */
                getFieldValueAsInteger(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):number;
                /**
                 * 获取整数类型公式引入项目字段值
                 *
                 * @param uniqueCode:        公式依赖项目字段唯一编码
                 * @param sectionKey:        日期区间key
                 * @param calItemUniqueCode: 计算项目唯一编码
                 * @return java.lang.Integer[]
                 * @throw
                 */
                getFieldValueAsIntegerArray(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):number[];
                /**
                 * 获取Object类型公式依赖项目字段值
                 *
                 * @param uniqueCode:        公式依赖项目字段唯一编码
                 * @param sectionKey:        日期区间key
                 * @param calItemUniqueCode: 计算项目唯一编码
                 * @return java.lang.Object
                 */
                getFieldValueAsObject(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):any;
                /**
                 * 获取字符数组类型公式依赖项目字段值
                 *
                 * @param uniqueCode:        公式依赖项目字段唯一编码
                 * @param sectionKey:        日期区间key
                 * @param calItemUniqueCode: 计算项目唯一编码
                 * @return java.lang.String[]
                 * @throw
                 */
                getFieldValueAsObjectArray(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):any[];
                /**
                 * 获取字符类型公式依赖项目字段值
                 *
                 * @param uniqueCode        公式依赖项目字段唯一编码
                 * @param sectionKey        日期区间key
                 * @param calItemUniqueCode 计算项目唯一编码
                 * @return
                 */
                getFieldValueAsString(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):string;
                /**
                 * 获取字符数组类型公式依赖项目字段值
                 *
                 * @param uniqueCode:        公式依赖项目字段唯一编码
                 * @param sectionKey:        日期区间key
                 * @param calItemUniqueCode: 计算项目唯一编码
                 * @return java.lang.String[]
                 * @throw
                 */
                getFieldValueAsStringArray(uniqueCode:string,sectionKey:string,calItemUniqueCode:string):string[];
                /**
                 * 获取当前项目分段段数
                 *
                 * @param uniqueCode 项目唯一编码
                 * @return
                 */
                getItemSectionList(uniqueCode:string):$.java.util.List;
                getItemSectionMap():$.java.util.Map;
                getItemSectionResultMap():$.java.util.Map;
                getOutputCustomCalItemValueMap():$.java.util.Map;
                getProportionMap():$.java.util.Map;
                getSectionParamMap():$.java.util.Map;
                getSectionPriorResultMap():$.java.util.Map;
                getUniqueCodeCalItemMap():$.java.util.Map;
                isCalProportion():boolean;
                isSection():boolean;
                setAddSumMap(addSumMap:$.java.util.Map):void;
                setCalProportion(isCalProration:boolean):void;
                setClassNameKey(classNameKey:string):void;
                setCustomCalItemMap(customCalItemMap:$.java.util.Map):void;
                setDataGradeMap(dataGradeMap:$.java.util.Map):void;
                setItemSectionMap(itemSectionMap:$.java.util.Map):void;
                setItemSectionResultMap(itemSectionResultMap:$.java.util.Map):void;
                setOutputCustomCalItemValueMap(outputCustomCalItemValueMap:$.java.util.Map):void;
                setProportionMap(proportionMap:$.java.util.Map):void;
                setSection(isSection:boolean):void;
                setSectionParamMap(sectionParamMap:$.java.util.Map):void;
                setSectionPriorResultMap(sectionPriorResultMap:$.java.util.Map):void;
                setUniqueCodeCalItemMap(uniqueCodeCalItemMap:$.java.util.Map):void;
                /**
                 * 汇总项目分段结果值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 */
                sumItemResultValue(uniqueCode:string):void;
                /**
                 * 更新计算项目的值
                 *
                 * @param uniqueCode 计算项目唯一编码
                 * @param value      项目值
                 */
                updateCalItemValue(uniqueCode:string,value:any):void;
                /**
                 * 更新计算项目的值
                 *
                 * @param uniqueCode        计算项目唯一编码
                 * @param value             项目值
                 * @param sectionKey        项目分段期间key
                 * @param calItemUniqueCode 结果项目唯一编码
                 */
                updateCalItemValue(uniqueCode:string,value:any,sectionKey:string,calItemUniqueCode:string):void;
            }
            type FormulaParse_T = ParentFormulaParse & FormulaParse_S & FormulaParse$;
            interface FormulaParse extends FormulaParse_T {
            }
            interface ParentFormulaParse_S {
            }
            type ParentFormulaParse_ST = kd.hr.hbp.business.function_.HRDefineFunction_S & ParentFormulaParse_S;
            interface ParentFormulaParse_C extends ParentFormulaParse_ST {
                new():ParentFormulaParse;
            }
            interface ParentFormulaParse$ {
                /**
                 * 计算入口，子类重写此方法
                 */
                calculate():void;
                /**
                 * 获取数值类型公式引入项目字段值
                 *
                 * @param uniqueCode 公式依赖项目字段唯一编码
                 * @return
                 */
                getFieldValueAsBigDecimal(uniqueCode:string):$.java.math.BigDecimal;
                /**
                 * 获取数值数组类型公式引入项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.math.BigDecimal[]
                 * @throw
                 */
                getFieldValueAsBigDecimalArray(uniqueCode:string):$.java.math.BigDecimal[];
                /**
                 * 获取逻辑类型公式引入项目字段值
                 *
                 * @param uniqueCode 公式依赖项目字段唯一编码
                 * @return
                 */
                getFieldValueAsBoolean(uniqueCode:string):boolean;
                /**
                 * 获取逻辑数组类型公式引入项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.lang.Boolean[]
                 * @throw
                 */
                getFieldValueAsBooleanArray(uniqueCode:string):boolean[];
                /**
                 * 获取日期类型公式引入项目字段值
                 *
                 * @param uniqueCode 公式依赖项目字段唯一编码
                 * @return
                 */
                getFieldValueAsDate(uniqueCode:string):Date;
                /**
                 * 获取日期数组类型公式引入项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.util.Date[]
                 * @throw
                 */
                getFieldValueAsDateArray(uniqueCode:string):Date[];
                /**
                 * 获取日期类型公式引入项目字段值
                 *
                 * @param uniqueCode 公式依赖项目字段唯一编码
                 * @return
                 */
                getFieldValueAsDynamicObject(uniqueCode:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 获取整数类型公式引入项目字段值
                 *
                 * @param uniqueCode 公式依赖项目字段唯一编码
                 * @return
                 */
                getFieldValueAsInteger(uniqueCode:string):number;
                /**
                 * 获取整数数组类型公式引入项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.lang.Integer[]
                 * @throw
                 */
                getFieldValueAsIntegerArray(uniqueCode:string):number[];
                /**
                 * 获取Object类型公式依赖项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.lang.Object
                 */
                getFieldValueAsObject(uniqueCode:string):any;
                /**
                 * 获取对象数组类型公式依赖项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.lang.String[]
                 * @throw
                 */
                getFieldValueAsObjectArray(uniqueCode:string):any[];
                /**
                 * 获取字符类型公式依赖项目字段值
                 *
                 * @param uniqueCode 公式依赖项目字段唯一编码
                 * @return
                 */
                getFieldValueAsString(uniqueCode:string):string;
                /**
                 * 获取字符数组类型公式依赖项目字段值
                 *
                 * @param uniqueCode: 公式依赖项目字段唯一编码
                 * @return java.lang.String[]
                 * @throw
                 */
                getFieldValueAsStringArray(uniqueCode:string):string[];
                getLoopLimit():number;
                getParams():$.java.util.Map;
                getResultLog():$.java.util.Map;
                getResultMap():$.java.util.Map;
                /**
                 * 获取数值或金额类型的项目值
                 *
                 * @param uniqueCode 项目唯一编码
                 * @return
                 */
                getResultValueAsBigDecimal(uniqueCode:string):$.java.math.BigDecimal;
                /**
                 * 获取逻辑类型的项目值
                 *
                 * @param uniqueCode 项目唯一编码
                 * @return
                 */
                getResultValueAsBoolean(uniqueCode:string):boolean;
                /**
                 * 获取日期类型的项目值
                 *
                 * @param uniqueCode 项目唯一编码
                 * @return
                 */
                getResultValueAsDate(uniqueCode:string):Date;
                /**
                 * 获取整数类型的项目值
                 *
                 * @param uniqueCode 项目唯一编码
                 * @return
                 */
                getResultValueAsInteger(uniqueCode:string):number;
                /**
                 * 获取文本类型的项目值
                 *
                 * @param uniqueCode 项目唯一编码
                 * @return
                 */
                getResultValueAsString(uniqueCode:string):string;
                isOpenLog():boolean;
                /**
                 * 记录计算日志
                 *
                 * formulaLog:公式计算日志对象
                 */
                logResult(formulaLog:FormulaLog):void;
                setLoopLimit(loopLimit:number):void;
                setOpenLog(openLog:boolean):void;
                setParams(params:$.java.util.Map):void;
                setResultLog(resultLog:$.java.util.Map):void;
                setResultMap(resultMap:$.java.util.Map):void;
                throwLoopException():void;
            }
            type ParentFormulaParse_T = kd.hr.hbp.business.function_.HRDefineFunction & ParentFormulaParse_S & ParentFormulaParse$;
            interface ParentFormulaParse extends ParentFormulaParse_T {
            }
            interface FormulaLog_S {
            }
            type FormulaLog_ST = $.java.io.Serializable & FormulaLog_S;
            interface FormulaLog_C extends FormulaLog_ST {
                new(id:string,name:string,param:string,result:string,msg:string):FormulaLog;
                new(id:string,name:string,param:string,result:string,msg:string,exception:$.java.lang.Exception):FormulaLog;
            }
            interface FormulaLog$ {
                getException():$.java.lang.Exception;
                getId():string;
                getMsg():string;
                getName():string;
                getParam():string;
                getResult():string;
                getTraceInfo():string;
                setException(exception:$.java.lang.Exception):void;
                setId(id:string):void;
                setMsg(msg:string):void;
                setName(name:string):void;
                setParam(param:string):void;
                setResult(result:string):void;
                setTraceInfo(traceInfo:string):void;
            }
            type FormulaLog_T = $.java.io.Serializable & FormulaLog_S & FormulaLog$;
            interface FormulaLog extends FormulaLog_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.cal.vo{
            interface CalAllParamVO_S {
            }
            type CalAllParamVO_ST = $.java.io.Serializable & CalAllParamVO_S;
            interface CalAllParamVO_C extends CalAllParamVO_ST {
                new():CalAllParamVO;
            }
            interface CalAllParamVO$ {
                getCalParamIdRelationMap():$.java.util.Map;
                getCalParamMap():$.java.util.Map;
                getCustomCalItemMap():$.java.util.Map;
                getDataGradeVOMap():$.java.util.Map;
                getFormulaVOList():$.java.util.List;
                getFunctionVOList():$.java.util.List;
                getItemSectionMap():$.java.util.Map;
                getItemSectionProportionRuleMap():$.java.util.Map;
                getLoopLimit():number;
                getParamIdAddSumMap():$.java.util.Map;
                getParamIdToConvertSectionMap():$.java.util.Map;
                getParamIdToParamMap():$.java.util.Map;
                getParamIdToSectionParamMap():$.java.util.Map;
                getProportionFormulaVOList():$.java.util.List;
                getSectionPriorResultMap():$.java.util.Map;
                getTraceId():string;
                getUniqueCodeCalItemMap():$.java.util.Map;
                isOpenLog():boolean;
                setCalParamIdRelationMap(calParamIdRelationMap:$.java.util.Map):void;
                setCalParamMap(calParamMap:$.java.util.Map):void;
                setCustomCalItemMap(customCalItemMap:$.java.util.Map):void;
                setDataGradeVOMap(dataGradeVOMap:$.java.util.Map):void;
                setFormulaVOList(formulaVOList:$.java.util.List):void;
                setFunctionVOList(functionVOList:$.java.util.List):void;
                setItemSectionMap(itemSectionMap:$.java.util.Map):void;
                setItemSectionProportionRuleMap(itemSectionProportionRuleMap:$.java.util.Map):void;
                setLoopLimit(loopLimit:number):void;
                setOpenLog(openLog:boolean):void;
                setParamIdAddSumMap(paramIdAddSumMap:$.java.util.Map):void;
                setParamIdToConvertSectionMap(paramIdToConvertSectionMap:$.java.util.Map):void;
                setParamIdToParamMap(paramIdToParamMap:$.java.util.Map):void;
                setParamIdToSectionParamMap(paramIdToSectionParamMap:$.java.util.Map):void;
                setProportionFormulaVOList(proportionFormulaVOList:$.java.util.List):void;
                setSectionPriorResultMap(sectionPriorResultMap:$.java.util.Map):void;
                setTraceId(traceId:string):void;
                setUniqueCodeCalItemMap(uniqueCodeCalItemMap:$.java.util.Map):void;
            }
            type CalAllParamVO_T = $.java.io.Serializable & CalAllParamVO_S & CalAllParamVO$;
            interface CalAllParamVO extends CalAllParamVO_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.entity{
            interface FormulaInfo_S {
            }
            type FormulaInfo_ST = $.java.io.Serializable & FormulaInfo_S;
            interface FormulaInfo_C extends FormulaInfo_ST {
                new():FormulaInfo;
            }
            interface FormulaInfo$ {
                /**
                 * 添加公式依赖的基础资料唯一编码
                 *
                 * @param uniqueCode: 唯一编码
                 * @return void
                 */
                addBaseDataUniqueCodeSet(uniqueCode:string):void;
                /**
                 * 添加当前node到自定义计算项目映射map中
                 *
                 * @param calItem: 自定义计算项目对象
                 * @return void
                 */
                addCalCustomItemInfoToMap(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                /**
                 * 添加自定义计算项目唯一编码
                 *
                 * @param uniqueCode: 唯一编码
                 * @return void
                 */
                addCalCustomUniqueCode(uniqueCode:string):void;
                /**
                 * 添加数据分级依赖的计算项目
                 *
                 * @param calItem: 计算项目
                 * @return void
                 */
                addCalDependForDataGrade(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                /**
                 * 添加函数依赖的计算项目
                 *
                 * @param calItem: 计算项目
                 * @return void
                 */
                addCalDependForFunc(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                /**
                 * 添加被重新赋值的计算项目
                 *
                 * @param calItem: 计算项目
                 * @return void
                 */
                addCalItemValueChange(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                /**
                 * 添加数据分级唯一编码
                 *
                 * @param uniqueCode: 唯一编码
                 * @return void
                 */
                addDataGradeUniqueCode(uniqueCode:string):void;
                /**
                 * 添加依赖的计算项目
                 *
                 * @param calItem: 计算项目
                 * @return void
                 */
                addDependCalItem(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                /**
                 * 添加公式依赖的枚举唯一编码
                 *
                 * @param uniqueCode: 唯一编码
                 * @return void
                 */
                addEnumUniqueCodeSet(uniqueCode:string):void;
                /**
                 * 添加函数唯一编码
                 *
                 * @param uniqueCode: 唯一编码
                 * @return void
                 */
                addFcUniqueCode(uniqueCode:string):void;
                addKey(key:kd.hr.hbp.business.service.formula.entity.node.OriginalNode):void;
                addOriginalKey(originalKey:kd.hr.hbp.business.service.formula.entity.node.OriginalNode):void;
                /**
                 * 添加需要输出的计算项目
                 *
                 * @param calItem: 计算项目
                 * @return void
                 */
                addOutputCalItem(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                /**
                 * 添加需要输出的自定义计算项目
                 *
                 * @param calItem: 计算项目
                 * @return void
                 */
                addOutputCustomCalItem(calItem:kd.hr.hbp.business.service.formula.entity.item.CalItem):void;
                addResultCount():void;
                /**
                 * 添加临时变量到map映射中
                 *
                 * @param tempVariable: 临时变量
                 * @param node:         节点
                 * @return void
                 */
                addTempVariable(tempVariable:string,node:kd.hr.hbp.business.service.formula.entity.node.OriginalNode):void;
                getBaseDataUniqueCodeSet():$.java.util.Set;
                getCalCustomItemMap():$.java.util.Map;
                getCalCustomUniqueCodeSet():$.java.util.Set;
                getCalForDataGradeUniqueCodeKeyMap():$.java.util.Map;
                getCalForFuncUniqueCodeKeyMap():$.java.util.Map;
                getCalItemMap():$.java.util.Map;
                getCalItemValueChangeMap():$.java.util.Map;
                getCalUniqueCodeKeyMap():$.java.util.Map;
                getDataGradeMap():$.java.util.Map;
                getDataGradeUniqueCodeSet():$.java.util.Set;
                getEntityNumberBaseDataCalItemMap():$.java.util.Map;
                getEnumUniqueCodeSet():$.java.util.Set;
                getEnumValueToCalItemMap():$.java.util.Map;
                getExecuteCode():string;
                getFcMap():$.java.util.Map;
                getFcUniqueCodeSet():$.java.util.Set;
                getId():string;
                getItemCategorySet():$.java.util.Set;
                getKeys():$.java.util.List;
                getLines():string[];
                getLocaleCodes():$.java.util.Map;
                getName():string;
                getOriginalCode():string;
                getOriginalKeys():$.java.util.List;
                getOriginalLines():string[];
                getOriginalNodes():$.java.util.List;
                getOutputCalItemMap():$.java.util.Map;
                getOutputCustomCalItemMap():$.java.util.Map;
                getResultCount():number;
                getResultItem():kd.hr.hbp.business.service.formula.entity.item.ResultItem;
                getResultItemMap():$.java.util.Map;
                getResultItemPropertyName():string;
                getTempVariableMap():$.java.util.Map;
                getUniqueKeyCode():string;
                isProrateItemFormula():boolean;
                setBaseDataUniqueCodeSet(baseDataUniqueCodeSet:$.java.util.Set):void;
                setCalCustomUniqueCodeSet(calCustomUniqueCodeSet:$.java.util.Set):void;
                setCalItemMap(calItemMap:$.java.util.Map):void;
                setDataGradeMap(dataGradeMap:$.java.util.Map):void;
                setEntityNumberBaseDataCalItemMap(entityNumberBaseDataCalItemMap:$.java.util.Map):void;
                setEnumUniqueCodeSet(enumUniqueCodeSet:$.java.util.Set):void;
                setEnumValueToCalItemMap(enumValueToCalItemMap:$.java.util.Map):void;
                setExecuteCode(executeCode:string):void;
                setFcMap(fcMap:$.java.util.Map):void;
                setId(id:string):void;
                setItemCategorySet(itemCategorySet:$.java.util.Set):void;
                setKeys(keys:$.java.util.List):void;
                setLines(lines:string[]):void;
                setLocaleCodes(localeCodes:$.java.util.Map):void;
                setName(name:string):void;
                setOriginalCode(originalCode:string):void;
                setOriginalKeys(originalKeys:$.java.util.List):void;
                setOriginalLines(originalLines:string[]):void;
                setOriginalNodes(originalNodes:$.java.util.List):void;
                setProrateItemFormula(isProrateItemFormula:boolean):void;
                setResultItem(resultItem:kd.hr.hbp.business.service.formula.entity.item.ResultItem):void;
                setResultItemMap(resultItemMap:$.java.util.Map):void;
                setResultItemPropertyName(resultItemPropertyName:string):void;
                setTempVariableMap(tempVariableMap:$.java.util.Map):void;
                setUniqueKeyCode(uniqueKeyCode:string):void;
            }
            type FormulaInfo_T = $.java.io.Serializable & FormulaInfo_S & FormulaInfo$;
            interface FormulaInfo extends FormulaInfo_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.entity.expression{
            interface Expression_S {
            }
            type Expression_ST = $.java.io.Serializable & Expression_S;
            interface Expression_C extends Expression_ST {
                new():Expression;
            }
            interface Expression$ {
                getNode():kd.hr.hbp.business.service.formula.entity.node.OriginalNode;
                getType():kd.hr.hbp.business.service.formula.enums.ExpressionNodeTypeEnum;
                setNode(node:kd.hr.hbp.business.service.formula.entity.node.OriginalNode):void;
                setType(type_arg:kd.hr.hbp.business.service.formula.enums.ExpressionNodeTypeEnum):void;
            }
            type Expression_T = $.java.io.Serializable & Expression_S & Expression$;
            interface Expression extends Expression_T {
            }
            interface ConditionExpression_S {
            }
            type ConditionExpression_ST = Expression_S & ConditionExpression_S;
            interface ConditionExpression_C extends ConditionExpression_ST {
                new(condition:kd.hr.hbp.business.service.formula.entity.node.OriginalNode):ConditionExpression;
            }
            interface ConditionExpression$ {
                addExpression(expression:kd.hr.hbp.business.service.formula.entity.node.OriginalNode):void;
                getChildConditionExpressions():$.java.util.List;
                getConditionEnum():kd.hr.hbp.business.service.formula.enums.ConditionEnum;
                getExpressions():$.java.util.List;
                getIsResult():boolean;
                setChildConditionExpressions(childConditionExpressions:$.java.util.List):void;
                setConditionEnum(conditionEnum:kd.hr.hbp.business.service.formula.enums.ConditionEnum):void;
                setExpressionNodes(expressions:$.java.util.List):void;
                setIsResult(isResult:boolean):void;
            }
            type ConditionExpression_T = Expression & ConditionExpression_S & ConditionExpression$;
            interface ConditionExpression extends ConditionExpression_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.entity.item{
            interface Item_S {
            }
            type Item_ST = $.java.io.Serializable & Item_S;
            interface Item_C extends Item_ST {
                new():Item;
                /**
                 * @param itemCategory: itemCategory
                 * @param id:           id
                 * @param name:         名称
                 * @param uniqueCode:   uniqueCode
                 */
                new(itemCategory:string,id:string,name:string,uniqueCode:string):Item;
            }
            interface Item$ {
                getId():string;
                getItemCategory():string;
                getName():string;
                getUniqueCode():string;
                isCheckUniqueCode():boolean;
                setCheckUniqueCode(checkUniqueCode:boolean):void;
                setId(id:string):void;
                setItemCategory(itemCategory:string):void;
                setName(name:string):void;
                setUniqueCode(uniqueCode:string):void;
            }
            type Item_T = $.java.io.Serializable & Item_S & Item$;
            interface Item extends Item_T {
            }
            interface TreeNodeItem_S {
            }
            type TreeNodeItem_ST = Item_S & TreeNodeItem_S;
            interface TreeNodeItem_C extends TreeNodeItem_ST {
                new():TreeNodeItem;
                /**
                 * @param itemCategory: itemCategory
                 * @param id:           id
                 * @param parentId:     父id
                 * @param name:         名称
                 */
                new(itemCategory:string,id:string,parentId:string,name:string):TreeNodeItem;
                /**
                 * @param itemCategory: itemCategory
                 * @param id:           id
                 * @param parentId:     父id
                 * @param name:         名称
                 * @param hasChild:     是否有子节点
                 */
                new(itemCategory:string,id:string,parentId:string,name:string,hasChild:boolean):TreeNodeItem;
                /**
                 * @param itemCategory: itemCategory
                 * @param id:           id
                 * @param parentId:     父id
                 * @param name:         名称
                 * @param uniqueCode:   uniqueCode
                 */
                new(itemCategory:string,id:string,parentId:string,name:string,uniqueCode:string):TreeNodeItem;
            }
            interface TreeNodeItem$ {
                getParentId():string;
                getParentName():string;
                getTreeNodeShowName():string;
                isExpand():boolean;
                isHasChild():boolean;
                isShow():boolean;
                setExpand(expand:boolean):void;
                setHasChild(hasChild:boolean):void;
                setParentId(parentId:string):void;
                setParentName(parentName:string):void;
                setShow(show:boolean):void;
                setTreeNodeShowName(treeNodeShowName:string):void;
            }
            type TreeNodeItem_T = Item & TreeNodeItem_S & TreeNodeItem$;
            interface TreeNodeItem extends TreeNodeItem_T {
            }
            interface ResultItem_S {
                /**
                 * 判断结果item部分属性是否为空
                 *
                 * @param resultItem: 结果item
                 * @return void
                 */
                checkValueIsNull(resultItem:ResultItem,resultItemPropertyName:string):void;
                /**
                 * 将结果item转换为动态对象
                 *
                 * @param resultItem: 结果item
                 * @param type:       动态对象类型
                 * @return kd.bos.dataentity.entity.DynamicObject
                 */
                getDyByResultItem(resultItem:ResultItem,type_arg:$.kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType):$.kd.bos.dataentity.entity.DynamicObject;
            }
            type ResultItem_ST = CalItem_S & ResultItem_S;
            interface ResultItem_C extends ResultItem_ST {
                new():ResultItem;
            }
            interface ResultItem$ {
                getDataLength():number;
                getScale():number;
                isCalProportionItem():boolean;
                setCalProportionItem(calProportionItem:boolean):void;
                setDataLength(dataLength:number):void;
                setScale(scale:number):void;
            }
            type ResultItem_T = CalItem & ResultItem_S & ResultItem$;
            interface ResultItem extends ResultItem_T {
            }
            interface CalItem_S {
            }
            type CalItem_ST = TreeNodeItem_S & CalItem_S;
            interface CalItem_C extends CalItem_ST {
                new():CalItem;
                /**
                 * @param itemCategory: itemCategory
                 * @param id:           id
                 * @param parentId:     父id
                 * @param name:         名称
                 * @param uniqueCode:   uniqueCode
                 * @param dataType:     数据类型枚举
                 */
                new(itemCategory:string,id:string,parentId:string,name:string,uniqueCode:string,dataType:kd.hr.hbp.business.service.formula.enums.DataTypeEnum):CalItem;
                /**
                 * @param itemCategory: itemCategory
                 * @param id:           id
                 * @param parentId:     父id
                 * @param name:         名称
                 * @param uniqueCode:   uniqueCode
                 * @param dataType:     数据类型枚举
                 * @param isCustomItem: 是否自定义计算项目
                 */
                new(itemCategory:string,id:string,parentId:string,name:string,uniqueCode:string,dataType:kd.hr.hbp.business.service.formula.enums.DataTypeEnum,isCustomItem:boolean):CalItem;
                /**
                 * @param itemCategory:   itemCategory
                 * @param id:             id
                 * @param parentId:       父id
                 * @param name:           名称
                 * @param uniqueCode:     uniqueCode
                 * @param isCustomItem:   是否自定义计算项目
                 * @param isGlobalEffect: 如果是自定义计算项目,该项目是否全局生效
                 * @param dataType:       数据类型枚举
                 */
                new(itemCategory:string,id:string,parentId:string,name:string,uniqueCode:string,isCustomItem:boolean,isGlobalEffect:boolean,dataType:kd.hr.hbp.business.service.formula.enums.DataTypeEnum):CalItem;
                /**
                 * @param itemCategory:   itemCategory
                 * @param id:             id
                 * @param parentId:       父id
                 * @param name:           名称
                 * @param uniqueCode:     uniqueCode
                 * @param dataType:       数据类型枚举
                 * @param isCustomItem:   是否自定义计算项目
                 * @param isGlobalEffect: 如果是自定义计算项目,该项目是否全局生效
                 */
                new(itemCategory:string,id:string,parentId:string,name:string,uniqueCode:string,dataType:kd.hr.hbp.business.service.formula.enums.DataTypeEnum,isCustomItem:boolean,isGlobalEffect:boolean):CalItem;
            }
            interface CalItem$ {
                getDataType():kd.hr.hbp.business.service.formula.enums.DataTypeEnum;
                getEntityNumber():string;
                getItemType():kd.hr.hbp.business.service.formula.enums.CalItemTypeEnum;
                getOrders():string;
                getPropertyField():string;
                getSerializeQFilters():$.java.util.List;
                getqFilters():$.kd.bos.orm.query.QFilter[];
                isCanAssignment():boolean;
                isCheckHourMinSec():boolean;
                isCustomItem():boolean;
                isGlobalEffect():boolean;
                setCanAssignment(canAssignment:boolean):void;
                setCheckHourMinSec(checkHourMinSec:boolean):void;
                setCustomItem(customItem:boolean):void;
                setDataType(dataType:kd.hr.hbp.business.service.formula.enums.DataTypeEnum):void;
                setEntityNumber(entityNumber:string):void;
                setGlobalEffect(globalEffect:boolean):void;
                setItemType(itemType:kd.hr.hbp.business.service.formula.enums.CalItemTypeEnum):void;
                setOrders(orders:string):void;
                setPropertyField(propertyField:string):void;
                setSerializeQFilters(serializeQFilters:$.java.util.List):void;
                setqFilters(qFilters:$.kd.bos.orm.query.QFilter[]):void;
            }
            type CalItem_T = TreeNodeItem & CalItem_S & CalItem$;
            interface CalItem extends CalItem_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.entity.node{
            interface OriginalNode_S {
            }
            type OriginalNode_ST = $.java.lang.Comparable & OriginalNode_S;
            interface OriginalNode_C extends OriginalNode_ST {
                new():OriginalNode;
            }
            interface OriginalNode$ {
                compareTo(o:OriginalNode):number;
                getDataType():kd.hr.hbp.business.service.formula.enums.DataTypeEnum;
                getEndColumnIndex():number;
                getKeyType():kd.hr.hbp.business.service.formula.enums.ExpressionNodeTypeEnum;
                getLineIndex():number;
                getNodeText():string;
                getStartColumnIndex():number;
                getUniqueKey():string;
                isAnnotation():boolean;
                setAnnotation(annotation:boolean):void;
                setDataType(dataType:kd.hr.hbp.business.service.formula.enums.DataTypeEnum):void;
                setEndColumnIndex(endColumnIndex:number):void;
                setKeyType(keyType:kd.hr.hbp.business.service.formula.enums.ExpressionNodeTypeEnum):void;
                setLineIndex(lineIndex:number):void;
                setNodeText(nodeText:string):void;
                setStartColumnIndex(startColumnIndex:number):void;
                setUniqueKey(uniqueKey:string):void;
            }
            type OriginalNode_T = $.java.lang.Comparable & OriginalNode_S & OriginalNode$;
            interface OriginalNode extends OriginalNode_T {
            }
        }
        namespace kd.hr.hbp.business.service.formula.enums{
            enum DataTypeEnum {
                OBJECT,
                NUM,
                TEXT,
                BOOLEAN,
                INT,
                DATE,
                MONEY,
                ARRAY_NUM,
                ARRAY_STRING,
                ARRAY_BOOLEAN,
                ARRAY_INT,
                ARRAY_DATE,
                ARRAY_OBJECT,
                BASE,
                NULL,
                DATETIME
            }
            enum ExpressionNodeTypeEnum {
                CONDITION,
                FUN,
                STR,
                NUM,
                INT,
                ITEM,
                OPERATOR,
                CAL,
                ANNO,
                RESULT,
                BOOLEAN,
                ASS,
                ARRAY_INDEX,
                INVOKE_METHOD,
                ARRAY_INT,
                ARRAY_NUM,
                DATE,
                DATETIME,
                ARRAY_DATE,
                DATA_GRADE,
                DATA_GRADE_RESULT,
                SELECT_ITEM,
                NULL,
                EXIT,
                EXPORT
            }
            enum CalItemTypeEnum {
                BASIC,
                BASE_DATA,
                ENUM
            }
            enum ConditionEnum {
                IF,
                WHILE,
                THEN,
                ELSEIF,
                ELSE,
                ENDIF,
                END_WHILE
            }
        }
        namespace kd.hr.hbp.business.service.message{
            interface IHRMsgTplService_S {
            }
            interface IHRMsgTplService$ {
                /**
                 * 消费者保存消费信息的api接口
                 *
                 * @param tplDy: 默认是hbp模板hbp_msgcenterinputtpl的动态对象
                 */
                consumerSaveMsg(tplDy:$.kd.bos.dataentity.entity.DynamicObject):kd.hr.hbp.common.mservice.HRMServiceResult;
            }
            type IHRMsgTplService_T = IHRMsgTplService_S & IHRMsgTplService$;
            interface IHRMsgTplService extends IHRMsgTplService_T {
            }
        }
        namespace kd.hr.hbp.business.service.perm.dyna.condhandler{
            interface IDynaCondParser_S {
            }
            interface IDynaCondParser$ {
                parseDynaCond(propType:string,userId:long,customParam:$.java.util.Map):$.java.util.List;
            }
            type IDynaCondParser_T = IDynaCondParser_S & IDynaCondParser$;
            interface IDynaCondParser extends IDynaCondParser_T {
            }
        }
        namespace kd.hr.hbp.business.service.query.ksql{
            interface QueryField_S {
            }
            interface QueryField_C extends QueryField_S {
                new(alias:string,originField:string,convertField:string,dbField:string):QueryField;
            }
            interface QueryField$ {
                getAlias():string;
                getConvertField():string;
                getDbField():string;
                getFieldEntityAlias():string;
                getOriginField():string;
                getPkDbField():string;
                getTable():string;
                isEntryField():boolean;
                /**
                 * 判断当前字段是否为分录字段，（不含分录多语言，分录拆分表）
                 *
                 * @return
                 */
                isEntrySelfField():boolean;
                isMultiLanguage():boolean;
                isSplitField():boolean;
                setAlias(alias:string):void;
                setConvertField(convertField:string):void;
                setDbField(dbField:string):void;
                setEntryField(entryField:boolean):void;
                setFieldEntityAlias(fieldEntityAlias:string):void;
                setMultiLanguage(multiLanguage:boolean):void;
                setOriginField(originField:string):void;
                setPkDbField(pkDbField:string):void;
                setSplitField(splitField:boolean):void;
                setTable(table:string):void;
            }
            type QueryField_T = QueryField_S & QueryField$;
            interface QueryField extends QueryField_T {
            }
            interface KsqlListDataProvider_S {
                readonly FULL_SQL:string;
                readonly PKSQL:string;
            }
            type KsqlListDataProvider_ST = $.kd.bos.mvc.list.ListDataProvider & KsqlListDataProvider_S;
            interface KsqlListDataProvider_C extends KsqlListDataProvider_ST {
                new(formView:$.kd.bos.form.IFormView,ksqlConfig:IKsqlConfig):KsqlListDataProvider;
                new(ksqlConfig:KsqlConfig,appId:string,cacheKey:string,queryType:string,isUnionSQL:boolean):KsqlListDataProvider;
                new(formView:$.kd.bos.form.IFormView,ksqlConfig:IKsqlConfig,queryType:string,isUnionSQL:boolean,isFullUnion:boolean):KsqlListDataProvider;
            }
            interface KsqlListDataProvider$ {
                /**
                 * 生成IDQuery查询SQL（SQL中包含多语言替换符）
                 *
                 * @param queryEntityType
                 * @param qFilters
                 * @param orderBys
                 * @param start
                 * @param limit
                 * @param relationMap
                 * @return
                 * @throws SqlTranslateException
                 */
                genQueryAllPkSql(queryEntityType:$.kd.bos.entity.QueryEntityType,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,start:number,limit:number,relationMap:$.java.util.Map):string;
                /**
                 * 多实体导出临时优化方案
                 */
                queryAllPk(queryEntityType:$.kd.bos.entity.QueryEntityType,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,start:number,limit:number,relationMap:$.java.util.Map):$.java.util.List;
                queryDynamicObjectCollection(queryEntityType:$.kd.bos.entity.QueryEntityType,returnEntityType:$.kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType,queryFields:string,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,isLimitCount:boolean,start:number,limit:number):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * 动态对象数据查询接口
                 *
                 * @param queryEntityType  查询实体模型
                 * @param returnEntityType 返回数据模型
                 * @param queryFields      查询字段，多个之间使用英文逗号分隔
                 * @param qFilters         过滤条件
                 * @param orderBys         排序字段
                 * @param isLimitCount     是否限制查询结果返回数据的条数，兼容接口中查所有数据情况
                 * @param start            开始下标
                 * @param limit            每页查询条数
                 * @param relationMap      时间切片，支持在join on 上加过滤条件<key:从实体别名，value:关联条件集合>
                 * @return 根据 returnEntityType 生成 DynamicObjectCollection 返回 queryFields 中的所有字段数据
                 */
                queryDynamicObjectCollection(queryEntityType:$.kd.bos.entity.QueryEntityType,returnEntityType:$.kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType,queryFields:string,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,isLimitCount:boolean,start:number,limit:number,relationMap:$.java.util.Map):$.kd.bos.dataentity.entity.DynamicObjectCollection;
            }
            type KsqlListDataProvider_T = $.kd.bos.mvc.list.ListDataProvider & KsqlListDataProvider_S & KsqlListDataProvider$;
            interface KsqlListDataProvider extends KsqlListDataProvider_T {
            }
            interface EntitySelectField_S {
            }
            interface EntitySelectField_C extends EntitySelectField_S {
                new():EntitySelectField;
            }
            interface EntitySelectField$ {
                addQueryField(queryField:QueryField):void;
                getEntityAlias():string;
                getEntityNum():string;
                getQueryFields():$.java.util.List;
                getTable():string;
                getTableAlias():string;
                setEntityAlias(entityAlias:string):void;
                setEntityNum(entityNum:string):void;
                setQueryFields(queryFields:$.java.util.List):void;
                setTable(table:string):void;
                setTableAlias(tableAlias:string):void;
            }
            type EntitySelectField_T = EntitySelectField_S & EntitySelectField$;
            interface EntitySelectField extends EntitySelectField_T {
            }
            interface KsqlConfig_S {
            }
            type KsqlConfig_ST = IKsqlConfig_S & KsqlConfig_S;
            interface KsqlConfig_C extends KsqlConfig_ST {
                new():KsqlConfig;
            }
            interface KsqlConfig$ {
                getEntityTableAliasMap():$.java.util.Map;
                getQueryEntityInfo():QueryEntityInfo;
                setCustomSelectedFields(customSelectedFields:string):void;
                setEntityTableAliasMap(entityTableAliasMap:$.java.util.Map):void;
                setJoinOnRelationMap(joinOnRelationMap:$.java.util.Map):void;
                setQueryEntityInfo(queryEntityInfo:QueryEntityInfo):void;
            }
            type KsqlConfig_T = IKsqlConfig & KsqlConfig_S & KsqlConfig$;
            interface KsqlConfig extends KsqlConfig_T {
            }
            interface IKsqlConfig_S {
            }
            interface IKsqlConfig$ {
                /**
                 * 增加不可优化的表
                 *
                 * @param tableName 在查询优化时不可被优化的数据表
                 */
                addUnIgnoreTable(tableName:string):void;
                /**
                 * 清空解析参数
                 */
                clearJoinConfig():void;
                /**
                 * 查询列表多实体查询需要支持业务额外增加列表上不展示的字段，用于业务取到id后，按时间对历史数据切片
                 * @return
                 */
                getCustomSelectedFields?():string;
                /**
                 * 获取数据库路由
                 *
                 * @param entityName 查询实体编码
                 * @return
                 */
                getDBRoute(entityName:string):$.kd.bos.db.DBRoute;
                /**
                 * 查询列表多实体查询需要支持on条件暴露的设置方法，用于多实体查询支持on条件设置
                 * @return
                 */
                getJoinOnRelationMap?():$.java.util.Map;
                /**
                 * 只查询主键
                 *
                 * @param entityName
                 * @return
                 */
                getOnlyMainPKSqlStr(entityName:string):string;
                /**
                 * 只查询主键
                 *
                 * @param limit
                 * @param start
                 * @param entityName
                 * @return
                 */
                getOnlyMainPKSqlStr(entityName:string,limit:number,start:number,orderBy:string):string;
                /**
                 * 查询实体主键及别名
                 *
                 * @param entityName 查询实体编码
                 * @return
                 */
                getPKPropMap(entityName:string):$.java.util.Map;
                /**
                 * 根据PK查询
                 *
                 * @param entityName 查询实体名称
                 * @return KSQL
                 */
                getPKSqlStr(entityName:string):string;
                getPKSqlStr(limit:number,start:number,entityName:string):string;
                /**
                 * 查询配置属性
                 *
                 * @param entityName 查询实体编码
                 * @return
                 */
                getPropMap(entityName:string):$.java.util.Map;
                /**
                 * 获取查询实体KSQL语句生成基类
                 *
                 * @param entityName 查询实体编码
                 * @return
                 */
                getQueryEntityInfo(entityName:string):QueryEntityInfo;
                /**
                 * 查询总数KSQL
                 *
                 * @param entityName 查询实体名称
                 * @return 查询实体统计KSQL
                 */
                getSqlCount(entityName:string):string;
                /**
                 * 根据查询实体配置生成数据查询KSQL
                 *
                 * @return KSQL
                 */
                getSqlStr():string;
                /**
                 * 根据查询实体配置生成数据查询KSQL
                 *
                 * @param entityName 查询实体名称
                 * @return KSQL
                 */
                getSqlStr(entityName:string):string;
                /**
                 * 获取select内容体
                 *
                 * @param limit 查询条数
                 * @param start 开始下标
                 * @return KSQL
                 */
                getSqlStr(limit:number,start:number):string;
                /**
                 * 获取select内容体
                 *
                 * @param limit      查询条数
                 * @param start      开始下标
                 * @param entityName 查询实体名称
                 * @return KSQL
                 */
                getSqlStr(limit:number,start:number,entityName:string):string;
                /**
                 * 查询配置实体别名
                 *
                 * @param entityName 查询实体名称
                 * @return 查询实体别名映射（实体别名->[数据表名->数据表别名]）
                 */
                getTableAliasMap(entityName:string):$.java.util.Map;
                /**
                 * 获取不可优化的表集合
                 * （实现类需要按需返回记录不可优化表的集合）
                 *
                 * @return 不可优化的表名集合
                 */
                getUnIgnoreTable?():$.java.util.Set;
                /**
                 * 白名单sql 过滤信息
                 *
                 * @param entityName entityName
                 * @return
                 */
                getWhiteSQLFilter(entityName:string):$.java.util.Map;
            }
            type IKsqlConfig_T = IKsqlConfig_S & IKsqlConfig$;
            interface IKsqlConfig extends IKsqlConfig_T {
            }
            interface QueryEntityInfo_S {
            }
            interface QueryEntityInfo_C extends QueryEntityInfo_S {
                /**
                 * 构造器
                 *
                 * @param queryEntityNum 查询实体编码
                 */
                new(queryEntityNum:string):QueryEntityInfo;
            }
            interface QueryEntityInfo$ {
                getAllEntityNames():$.java.util.Set;
                getEditEntityNum():string;
                getEditEntitySelectField():EntitySelectField;
                getEditEntityTable():string;
                getEditEntityType():$.kd.bos.entity.MainEntityType;
                getJoinConditionMap(entityAlias:string):$.java.util.Set;
                getJoinEntitySelectField():$.java.util.List;
                getJoinEntitys():$.java.util.List;
                getJoinRelations():$.java.util.List;
                getQueryEntityNum():string;
                getQueryEntityType():$.kd.bos.entity.QueryEntityType;
                getQueryJoinEntitys():$.java.util.List;
                getQueryJoinRelations():$.java.util.List;
                getQuerySelectFields():$.java.util.List;
                getSelectFields():$.java.util.List;
                setEditEntityNum(editEntityNum:string):void;
                setEditEntitySelectField(editEntitySelectField:EntitySelectField):void;
                setEditEntityTable(editEntityTable:string):void;
                setEditEntityType(editEntityType:$.kd.bos.entity.MainEntityType):void;
                setJoinEntitySelectField(joinEntitySelectField:$.java.util.List):void;
                setJoinEntitys(joinEntitys:$.java.util.List):void;
                setJoinRelations(joinRelations:$.java.util.List):void;
                setQueryEntityNum(queryEntityNum:string):void;
                setQueryEntityType(queryEntityType:$.kd.bos.entity.QueryEntityType):void;
                setSelectFields(selectFields:$.java.util.List):void;
            }
            type QueryEntityInfo_T = QueryEntityInfo_S & QueryEntityInfo$;
            interface QueryEntityInfo extends QueryEntityInfo_T {
            }
        }
        namespace kd.hr.hbp.business.service.smartsearch{
            interface LabelValCompletionService_S {
                /**
                 * 标签自动补全
                 *
                 * @param compParam 标签自动补全请求参数
                 * @return 标签自动补全数据包
                 */
                completion(compParam:kd.hr.hbp.common.model.smartsearch.search.LabelValCompParam):kd.hr.hbp.common.api.HrApiResponse;
            }
            interface LabelValCompletionService_C extends LabelValCompletionService_S {
                new():LabelValCompletionService;
            }
            interface LabelValCompletionService$ {
            }
            type LabelValCompletionService_T = LabelValCompletionService_S & LabelValCompletionService$;
            interface LabelValCompletionService extends LabelValCompletionService_T {
            }
            interface SearchLogQueryService_S {
                /**
                 * 按时间段查询某个场景下最高频10个关键词
                 *
                 * @param sceneId          搜索场景ID（必传）
                 * @param searchPageNumber 搜索页面编码（必传）
                 * @param startTime        开始时间（非必传）
                 * @param endTime          结束时间（非必传）
                 * @return 按顺序返回最高频的是个关键词
                 */
                queryTopKeywords(sceneId:long,searchPageNumber:string,startTime:Date,endTime:Date):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 查询某用户最近10次的搜索关键词
                 *
                 * @param sceneId          搜索场景ID（必传）
                 * @param searchPageNumber 搜索页面编码（必传）
                 * @param userId           用户ID（必传）
                 * @return 按顺序返回最近10次的搜索关键词
                 */
                queryUserTopKeywords(sceneId:long,searchPageNumber:string,userId:long):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 移除用户最近所有搜索关键词
                 *
                 * @param sceneId          搜索场景ID（必传）
                 * @param searchPageNumber 搜索页面编码（必传）
                 * @param userId           用户ID（必传）
                 */
                removeUserKeywords(sceneId:long,searchPageNumber:string,userId:long):void;
                /**
                 * 移除用户最近搜索关键词 keyword
                 *
                 * @param sceneId          搜索场景ID（必传）
                 * @param searchPageNumber 搜索页面编码（必传）
                 * @param userId           用户ID（必传）
                 * @param keyword          搜索关键词（必传）
                 */
                removeUserKeywords(sceneId:long,searchPageNumber:string,userId:long,keyword:string):void;
            }
            interface SearchLogQueryService_C extends SearchLogQueryService_S {
                new():SearchLogQueryService;
            }
            interface SearchLogQueryService$ {
            }
            type SearchLogQueryService_T = SearchLogQueryService_S & SearchLogQueryService$;
            interface SearchLogQueryService extends SearchLogQueryService_T {
            }
            interface HRSmartSearchService_S {
                /**
                 * 搜索数据（返回前10000条数据）
                 *
                 * @param searchParam 搜索请求参数
                 * @return 搜索结果
                 */
                search(searchParam:kd.hr.hbp.common.model.smartsearch.search.SearchParam):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 搜索数据（返回前10000条数据）
                 *
                 * @param searchParam 搜索请求参数
                 * @param searchField 搜索字段别名集合
                 * @param qFilters    精确过滤条件
                 * @return 搜索结果
                 */
                search(searchParam:kd.hr.hbp.common.model.smartsearch.search.SearchParam,searchField:$.java.util.List,qFilters:$.kd.bos.orm.query.QFilter[]):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 搜索数据（最多返回10000条数据）
                 *
                 * @param searchParam 搜索请求参数
                 * @param qFilters    精确过滤条件
                 * @param searchField 搜索字段别名集合
                 * @param start       开始查询下标
                 * @param limit       查询数据条数（最多返回10000条数据）
                 * @return 搜索结果
                 */
                search(searchParam:kd.hr.hbp.common.model.smartsearch.search.SearchParam,searchField:$.java.util.List,qFilters:$.kd.bos.orm.query.QFilter[],start:number,limit:number):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 搜索数据（最多返回10000条数据）
                 *
                 * @param searchParam      搜索请求参数
                 * @param qFilters         精确过滤条件
                 * @param searchField      搜索字段别名集合
                 * @param highLightPreTag  高亮开标签(示例："<p class='highLignt' style='color: var(--theme-color);display: inline'>")
                 * @param highLightPostTag 高亮闭标签（示例："</p>"）
                 * @param start            开始查询下标
                 * @param limit            查询数据条数（最多返回10000条数据）
                 * @return 搜索结果
                 */
                search(searchParam:kd.hr.hbp.common.model.smartsearch.search.SearchParam,searchField:$.java.util.List,qFilters:$.kd.bos.orm.query.QFilter[],highLightPreTag:string,highLightPostTag:string,start:number,limit:number):kd.hr.hbp.common.api.HrApiResponse;
            }
            interface HRSmartSearchService_C extends HRSmartSearchService_S {
                new():HRSmartSearchService;
            }
            interface HRSmartSearchService$ {
            }
            type HRSmartSearchService_T = HRSmartSearchService_S & HRSmartSearchService$;
            interface HRSmartSearchService extends HRSmartSearchService_T {
            }
            interface SearchSceneService_S {
                /**
                 * 根据搜索场景ID和字段别名获取控权QFilter
                 *
                 * @param sceneId            场景ID
                 * @param fieldAlias         字段别名
                 * @param searchEntityNumber 搜索页面编码（HR中台注册的搜索动态页面）
                 * @param appNumber          权限控制应用编码（为null时按searchEntityNumber所在应用控权）
                 * @return 控权QFilter
                 */
                getPermQFilters(sceneId:long,fieldAlias:string,searchEntityNumber:string,appNumber:string):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 根据搜索对象获取搜索对象上所有模型标签字段信息
                 *
                 * @param searchObjId 搜索对象ID
                 * @return 所有模型标签字段信息
                 */
                queryAllLabelFields(searchObjId:long):kd.hr.hbp.common.api.HrApiResponse;
                /**
                 * 根据注册搜索页面和发布应用查询场景信息
                 * 搜索场景信息包括搜素场景配置，精准搜索项目，二次过滤条件，搜索字段等
                 *
                 * @param searchEntityNumber 注册搜索页面编码（HR中台注册的搜索动态页面）
                 * @param appNumber          权限控制应用编码（传null时按注册搜索页面所在应用控权）
                 * @return 搜索场景
                 * @see kd.hr.hbp.common.model.smartsearch.scene.SearchSceneBo
                 */
                querySearchScene(searchEntityNumber:string,appNumber:string):kd.hr.hbp.common.api.HrApiResponse;
            }
            interface SearchSceneService_C extends SearchSceneService_S {
                new():SearchSceneService;
            }
            interface SearchSceneService$ {
            }
            type SearchSceneService_T = SearchSceneService_S & SearchSceneService$;
            interface SearchSceneService extends SearchSceneService_T {
            }
        }
        namespace kd.hr.hbp.business.service.timeline.dao{
            interface TimelineEntityConf_S {
            }
            type TimelineEntityConf_ST = $.java.io.Serializable & TimelineEntityConf_S;
            interface TimelineEntityConf_C extends TimelineEntityConf_ST {
                new(modelTypeEnum:kd.hr.hbp.common.constants.timeline.TimelineModelTypeEnum,logicKey:$.java.util.Set):TimelineEntityConf;
            }
            interface TimelineEntityConf$ {
                getCover():boolean;
                getLogicKey():$.java.util.Set;
                getModelTypeEnum():kd.hr.hbp.common.constants.timeline.TimelineModelTypeEnum;
                getNeedTimerDealCurrent():boolean;
                getStartDateLimit():boolean;
                setCover(cover:boolean):void;
                setLogicKey(logicKey:$.java.util.Set):void;
                setModelTypeEnum(modelTypeEnum:kd.hr.hbp.common.constants.timeline.TimelineModelTypeEnum):void;
                setNeedTimerDealCurrent(needTimerDealCurrent:boolean):void;
                setStartDateLimit(startDateLimit:boolean):void;
            }
            type TimelineEntityConf_T = $.java.io.Serializable & TimelineEntityConf_S & TimelineEntityConf$;
            interface TimelineEntityConf extends TimelineEntityConf_T {
            }
        }
        namespace kd.hr.hbp.business.servicehelper{
            interface HRQueryEntityHelper$QueryEntityParamInfo_S {
            }
            interface HRQueryEntityHelper$QueryEntityParamInfo_C extends HRQueryEntityHelper$QueryEntityParamInfo_S {
                new():HRQueryEntityHelper$QueryEntityParamInfo;
            }
            interface HRQueryEntityHelper$QueryEntityParamInfo$ {
                isMulBaseDataCollectionToString():boolean;
                setMulBaseDataCollectionToString(arg0:boolean):void;
            }
            type HRQueryEntityHelper$QueryEntityParamInfo_T = HRQueryEntityHelper$QueryEntityParamInfo_S & HRQueryEntityHelper$QueryEntityParamInfo$;
            interface HRQueryEntityHelper$QueryEntityParamInfo extends HRQueryEntityHelper$QueryEntityParamInfo_T {
            }
            interface HRMServiceHelper_S {
                /**
                 * 调用业务云、应用下的微服务，与平台DispatchServiceHelper.invokeBizService使用一致
                 *
                 * @param cloudId     云Id
                 * @param appId       应用Id
                 * @param serviceName 服务名
                 * @param methodName  方法名
                 * @param paras       方法参数
                 * @return 调用返回值
                 */
                invokeBizService(cloudId:string,appId:string,serviceName:string,methodName:string,...paras:any[]):any;
                /**
                 * 调用hrmp云下的微服务，指定调用微服务cloudId参数为 hrmp
                 *
                 * @param appId       应用Id
                 * @param serviceName 服务名
                 * @param methodName  方法名
                 * @param paras       方法参数
                 * @return T 调用返回值
                 */
                invokeHRMPService(appId:string,serviceName:string,methodName:string,...paras:any[]):any;
                /**
                 * 调用hr云下的微服务，指定调用微服务cloudId参数为 hr
                 *
                 * @param appId       应用Id
                 * @param serviceName 服务名
                 * @param methodName  方法名
                 * @param paras       方法参数
                 * @return 调用返回值
                 */
                invokeHRService(appId:string,serviceName:string,methodName:string,...paras:any[]):any;
                /**
                 * ISV微服务调用方法，取当前环境 开发商、云Id、应用Id 拼装调用微服务的factoryQualifiedPrefix，使用者需要评估是否适用，
                 *  如果不适用，则直接用平台的 DispatchServiceHelper.invokeService
                 *
                 * @param cloudId     云Id
                 * @param appId       应用Id
                 * @param serviceName 服务名
                 * @param methodName  方法名
                 * @param paras       方法参数
                 * @return 调用返回值
                 */
                invokeService(cloudId:string,appId:string,serviceName:string,methodName:string,...paras:any[]):any;
            }
            interface HRMServiceHelper_C extends HRMServiceHelper_S {
                new():HRMServiceHelper;
            }
            interface HRMServiceHelper$ {
            }
            type HRMServiceHelper_T = HRMServiceHelper_S & HRMServiceHelper$;
            interface HRMServiceHelper extends HRMServiceHelper_T {
            }
            interface HRExportHeadObject_S {
            }
            type HRExportHeadObject_ST = $.java.io.Serializable & HRExportHeadObject_S;
            interface HRExportHeadObject_C extends HRExportHeadObject_ST {
                /**
                 * 构造方法
                 */
                new():HRExportHeadObject;
                /**
                 * 构造方法
                 *
                 * @param columnKey   列key
                 * @param columnAlias 列别名
                 */
                new(columnKey:string,columnAlias:string):HRExportHeadObject;
            }
            interface HRExportHeadObject$ {
                /**
                 * 获取列别名
                 *
                 * @return 列别名
                 */
                getColumnAlias():string;
                /**
                 * 获取列key
                 *
                 * @return 列key
                 */
                getColumnId():string;
                /**
                 * 设置列别名
                 *
                 * @param 列别名
                 */
                setColumnAlias(columnAlias:string):void;
                /**
                 * 设置列key
                 *
                 * @param 列key
                 */
                setColumnId(columnId:string):void;
            }
            type HRExportHeadObject_T = $.java.io.Serializable & HRExportHeadObject_S & HRExportHeadObject$;
            interface HRExportHeadObject extends HRExportHeadObject_T {
            }
            interface HRExportDataHelper_S {
                /**
                 * 获取 Excel 生成后的 redis URL
                 *
                 * @param fileName       文件名
                 * @param exportDataList 导出数据list集合
                 * @param headDataList   excel表头list集合
                 * @return 导出excel的url
                 * @throws IOException the io exception
                 */
                getExportExcelUrl(fileName:string,exportDataList:$.java.util.List,headDataList:$.java.util.List):string;
            }
            interface HRExportDataHelper_C extends HRExportDataHelper_S {
                new():HRExportDataHelper;
            }
            interface HRExportDataHelper$ {
                /**
                 * 获取 Excel 生成后的 redis URL
                 *
                 * @param fileName       文件名
                 * @param exportDataList 导出数据list集合
                 * @param headDataList   excel表头list集合
                 * @return 导出excel的url
                 * @throws IOException the io exception
                 */
                getExcelDownLoadUrl(fileName:string,exportDataList:$.java.util.List,headDataList:$.java.util.List):string;
                /**
                 * 是否自定义列开关，true为自定义，默认为false，测试
                 *
                 * @return 开关状态
                 */
                isCustomColumn():boolean;
                /**
                 * 自定义设置sheet表头列宽
                 *
                 * @param sheet        sheet页
                 * @param headDataList 表头字段
                 */
                setSheetColumn(sheet:any,headDataList:$.java.util.List):void;
            }
            type HRExportDataHelper_T = HRExportDataHelper_S & HRExportDataHelper$;
            interface HRExportDataHelper extends HRExportDataHelper_T {
            }
            interface HRQueryEntityHelper_S {
                getCurrentRequestParam():HRQueryEntityHelper$QueryEntityParamInfo;
                /**
                 * 获取查询实体数据查询工具类实例对象
                 *
                 * @return 当前类实体对象
                 */
                getInstance():HRQueryEntityHelper;
                setCurrentRequestParam(queryEntityParamInfo:HRQueryEntityHelper$QueryEntityParamInfo):void;
            }
            interface HRQueryEntityHelper_C extends HRQueryEntityHelper_S {
                new():HRQueryEntityHelper;
            }
            interface HRQueryEntityHelper$ {
                /**
                 * 查询数据，返回DataSet（默认不分页）
                 *
                 * @param queryEntityType 查询实体模型
                 * @param queryFileds     查询字段，多个字段通过“,”分割
                 * @param qFilters        查询过滤条件
                 * @param orderBys        排序字段，多个字段之间用英文","分开，排序方式和排序字段之间用空格分割，例如："name desc,number"
                 * @return DataSet
                 */
                getQueryDataSet(queryEntityType:$.kd.bos.entity.QueryEntityType,queryFileds:string,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.algo.DataSet;
                /**
                 * 查询数据，返回DataSet（默认分页）
                 *
                 * @param queryEntityType 查询实体模型
                 * @param queryFileds     查询字段，多个字段通过“,”分割
                 * @param qFilters        查询过滤条件
                 * @param orderBys        排序字段，多个字段之间用英文","分开，排序方式和排序字段之间用空格分割，例如："name desc,number"
                 * @param start           分页开始下标
                 * @param limit           每页条数
                 * @return DataSet
                 */
                getQueryDataSet(queryEntityType:$.kd.bos.entity.QueryEntityType,queryFileds:string,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,start:number,limit:number):$.kd.bos.algo.DataSet;
                /**
                 * 查询数据，返回DynamicObjectCollection（默认不分页）
                 *
                 * @param queryEntityType 查询实体模型
                 * @param queryFileds     查询字段，多个字段通过“,”分割
                 * @param qFilters        查询过滤条件
                 * @param orderBys        排序字段，多个字段之间用英文","分开，排序方式和排序字段之间用空格分割，例如："name desc,number"
                 * @return DynamicObjectCollection
                 */
                getQueryDyoColl(queryEntityType:$.kd.bos.entity.QueryEntityType,queryFileds:string,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * 查询数据，返回DynamicObjectCollection（默认分页）
                 *
                 * @param queryEntityType 查询实体模型
                 * @param queryFileds     查询字段，多个字段通过“,”分割
                 * @param qFilters        查询过滤条件
                 * @param orderBys        排序字段，多个字段之间用英文","分开，排序方式和排序字段之间用空格分割，例如："name desc,number"
                 * @param start           分页开始下标
                 * @param limit           每页条数
                 * @return DynamicObjectCollection
                 */
                getQueryDyoColl(queryEntityType:$.kd.bos.entity.QueryEntityType,queryFileds:string,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,start:number,limit:number):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * 查询所有主实体主键
                 *
                 * @param queryEntityType 查询实体模型
                 * @param qFilters        查询过滤条件
                 * @param orderBys        排序字段，多个字段之间用英文","分开，排序方式和排序字段之间用空格分割，例如："name desc,number"
                 * @return 所有主实体主键集合
                 */
                queryAllPkByKSql(queryEntityType:$.kd.bos.entity.QueryEntityType,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.java.util.List;
                /**
                 * 分页查询主实体主键
                 *
                 * @param queryEntityType 查询实体模型
                 * @param qFilters        查询过滤条件
                 * @param orderBys        排序字段，多个字段之间用英文","分开，排序方式和排序字段之间用空格分割，例如："name desc,number"
                 * @param start           分页开始下标
                 * @param limit           每页条数
                 * @return 主实体主键集合
                 */
                queryAllPkByKSql(queryEntityType:$.kd.bos.entity.QueryEntityType,qFilters:$.kd.bos.orm.query.QFilter[],orderBys:string,start:number,limit:number):$.java.util.List;
            }
            type HRQueryEntityHelper_T = HRQueryEntityHelper_S & HRQueryEntityHelper$;
            interface HRQueryEntityHelper extends HRQueryEntityHelper_T {
            }
            interface AppIdServiceHelper_S {
                /**
                 * 获取权限需要的appId
                 *
                 * @param entryAppId   the entry app id
                 * @param entityNumber the entity number
                 * @return the perm app id
                 */
                getPermAppId(entryAppId:string,entityNumber:string):string;
            }
            interface AppIdServiceHelper_C extends AppIdServiceHelper_S {
                new():AppIdServiceHelper;
            }
            interface AppIdServiceHelper$ {
            }
            type AppIdServiceHelper_T = AppIdServiceHelper_S & AppIdServiceHelper$;
            interface AppIdServiceHelper extends AppIdServiceHelper_T {
            }
            interface HREntityHelper_S {
                /**
                 * 获取所有字段属性
                 *
                 * @param pageName 实体标识
                 * @return Map all fields
                 */
                getAllFields(pageName:string):$.java.util.Map;
                /**
                 * 获取字段属性
                 *
                 * @param pageName  实体标识
                 * @param fieldName 字段名
                 * @return DynamicProperty field property
                 */
                getFieldProperty(pageName:string,fieldName:string):$.kd.bos.dataentity.metadata.dynamicobject.DynamicProperty;
                /**
                 * 将表名转成对应的中文名
                 *
                 * @param pageName the page name
                 * @return String page chinese name
                 */
                getPageChineseName(pageName:string):string;
                /**
                 * 获取实体(单据or基础资料页面)的属性
                 *
                 * @param pageName 实体标识
                 * @return MainEntityType page entity type
                 */
                getPageEntityType(pageName:string):$.kd.bos.entity.MainEntityType;
                /**
                 * 获取基础资料或者列表的表名
                 *
                 * @param pageNumber 页面编码
                 * @return String table name
                 */
                getTableName(pageNumber:string):string;
            }
            interface HREntityHelper_C extends HREntityHelper_S {
                new():HREntityHelper;
            }
            interface HREntityHelper$ {
            }
            type HREntityHelper_T = HREntityHelper_S & HREntityHelper$;
            interface HREntityHelper extends HREntityHelper_T {
            }
            interface HRBaseServiceHelper_S {
                /**
                 * 生成访问数据的serviceHelper对象
                 * @param entityName 实体名称
                 * @return 操作数据库helper对象
                 */
                create(entityName:string):HRBaseServiceHelper;
            }
            interface HRBaseServiceHelper_C extends HRBaseServiceHelper_S {
                /**
                 * 初始化构造一个serviceHelper对象
                 *
                 * @param entityName 实体编码
                 */
                new(entityName:string):HRBaseServiceHelper;
            }
            interface HRBaseServiceHelper$ {
                /**
                 * 查询满足指定过滤条件的数据数量
                 *
                 * @param entityName 实体编码
                 * @param filters    过滤条件
                 * @return 数量
                 */
                count(entityName:string,filters:$.kd.bos.orm.query.QFilter[]):number;
                /**
                 * 按指定pk数组删除数据
                 *
                 * @param pks 指定pk数组
                 */
                delete(pks:any[]):void;
                /**
                 * 按指定过滤条件删除数据
                 *
                 * @param filters the filters
                 * @return 删除数量
                 */
                deleteByFilter(filters:$.kd.bos.orm.query.QFilter[]):number;
                /**
                 * 按指定pk删除数据
                 *
                 * @param pk 指定pk
                 */
                deleteOne(pk:any):void;
                /**
                 * 生成空的动态对象
                 *
                 * @return DynamicObject dynamic object
                 */
                generateEmptyDynamicObject():$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 生成空的动态对象
                 *
                 * @param entityName 实体编码
                 * @return DynamicObject dynamic object
                 */
                generateEmptyDynamicObject(entityName:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 生成空的分录
                 *
                 * @param dy          the dy
                 * @param entryEntity the entry entity
                 * @return DynamicObjectCollection dynamic object collection
                 */
                generateEmptyEntryCollection(dy:$.kd.bos.dataentity.entity.DynamicObject,entryEntity:string):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * 生成空的分录动态对象
                 *
                 * @param entryEntity the entry entity
                 * @return DynamicObject dynamic object
                 */
                generateEmptyEntryDynamicObject(entryEntity:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * 生成空的分录动态对象
                 *
                 * @param entityName  the entity name
                 * @param entryEntity the entry entity
                 * @return DynamicObject dynamic object
                 */
                generateEmptyEntryDynamicObject(entityName:string,entryEntity:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * get实体编码
                 *
                 * @return 实体编码
                 */
                getEntityName():string;
                /**
                 * 指定过滤条件的数据是否存在
                 *
                 * @param filter the filter
                 * @return 查询结果
                 */
                isExists(filter:$.kd.bos.orm.query.QFilter):boolean;
                /**
                 * 指定过滤条件的数据是否存在
                 *
                 * @param filters the filters
                 * @return 查询结果
                 */
                isExists(filters:$.kd.bos.orm.query.QFilter[]):boolean;
                /**
                 * 指定pk的数据是否存在
                 *
                 * @param pk the pk
                 * @return 查询结果
                 */
                isExists(pk:any):boolean;
                /**
                 * load指定过滤条件的动态对象
                 *
                 * @param filter the filter
                 * @return DynamicObject dynamic object
                 */
                loadDynamicObject(filter:$.kd.bos.orm.query.QFilter):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load指定过滤条件的动态对象，说明： 如果匹配到多条，将取第一条
                 * @param filters the filters
                 * @return DynamicObject dynamic object
                 */
                loadDynamicObject(filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load指定过滤条件的动态对象数组
                 *
                 * @param filters the filters
                 * @return DynamicObject dynamic object [ ]
                 */
                loadDynamicObjectArray(filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load指定pk的动态对象数组
                 *
                 * @param pkArray the pk array
                 * @return dynamic object [ ]
                 */
                loadDynamicObjectArray(pkArray:any[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load指定过滤条件的动态对象数组
                 *
                 * @param entityName the entity name
                 * @param filters    the filters
                 * @return DynamicObject[] dynamic object [ ]
                 */
                loadDynamicObjectArray(entityName:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load指定pk的动态对象数组
                 *
                 * @param entityName 实体编码
                 * @param pkArray    pk array
                 * @return dynamic object [ ]
                 */
                loadDynamicObjectArray(entityName:string,pkArray:any[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load指定pk的动态对象
                 *
                 * @param pk pk
                 * @return DynamicObject dynamic object
                 */
                loadSingle(pk:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load指定pk的动态对象
                 *
                 * @param entityName 实体编码
                 * @param pk         pk
                 * @return 动态对象
                 */
                loadSingle(entityName:string,pk:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load带实体标识的DynamicObject[]，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用{@link HRBaseServiceHelper#queryOriginalArray(String, QFilter[])}，只访问一次数据库
                 *
                 * @param filters the filters
                 * @return DynamicObject dynamic object [ ]
                 */
                query(filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load带实体标识的DynamicObject[]，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param filters  the filters
                 * @param orderBys the order bys
                 * @return DynamicObject dynamic object [ ]
                 */
                query(filters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load带实体标识的DynamicObject[]，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param filters          the filters
                 * @return DynamicObject dynamic object [ ]
                 */
                query(selectProperties:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load带实体标识的DynamicObject[]，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param filters          the filters
                 * @param orderBys         the order bys
                 * @return DynamicObject dynamic object [ ]
                 */
                query(selectProperties:string,filters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * load按查询字段、过滤条件并按指定字段排序，取top
                 *
                 * @param selectProperties the select properties
                 * @param filters          the filters
                 * @param orderby          the orderby
                 * @param top              the top
                 * @return DynamicObject dynamic object [ ]
                 */
                query(selectProperties:string,filters:$.kd.bos.orm.query.QFilter[],orderby:string,top:number):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * queryDataSet 按查询字段和过滤条
                 *
                 * @param algoKey      the algo key
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @return DataSet 结果集
                 */
                queryDataSet(algoKey:string,selectFields:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.algo.DataSet;
                /**
                 * queryDataSet 按查询字段、过滤条件并按指定字段排序
                 *
                 * @param algoKey      the algo key
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @param orderBys     the order bys
                 * @return DataSet 结果集
                 */
                queryDataSet(algoKey:string,selectFields:string,filters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.algo.DataSet;
                /**
                 * queryDataSet 按查询字段、过滤条件并按指定字段排序，取top
                 *
                 * @param algoKey      the algo key
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @param orderBys     the order bys
                 * @param top top number
                 * @return DataSet 结果集
                 */
                queryDataSet(algoKey:string,selectFields:string,filters:$.kd.bos.orm.query.QFilter[],orderBys:string,top:number):$.kd.bos.algo.DataSet;
                /**
                 * load带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param filters the filters
                 * @return DynamicObject dynamic object
                 */
                queryOne(filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param pk the pk
                 * @return DynamicObject dynamic object
                 */
                queryOne(pk:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param filter           the filter
                 * @return DynamicObject dynamic object
                 */
                queryOne(selectProperties:string,filter:$.kd.bos.orm.query.QFilter):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param filters          the filters
                 * @return DynamicObject dynamic object
                 */
                queryOne(selectProperties:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param pk               the pk
                 * @return DynamicObject dynamic object
                 */
                queryOne(selectProperties:string,pk:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * load带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param filters          the filters
                 * @param order            the order
                 * @return DynamicObject dynamic object
                 */
                queryOne(selectProperties:string,filters:$.kd.bos.orm.query.QFilter[],order:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * query原生的不带实体标识及属性的queryOriginalArray，单纯用作查询 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @return DynamicObject dynamic object [ ]
                 */
                queryOriginalArray(selectFields:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * query原生的不带实体标识及属性的queryOriginalArray，单纯用作查询 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @param orderBys     the order bys
                 * @return DynamicObject dynamic object [ ]
                 */
                queryOriginalArray(selectFields:string,filters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.dataentity.entity.DynamicObject[];
                /**
                 * query原生的不带实体标识及属性的queryOriginalCollection，单纯用作查询 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @return DynamicObjectCollection dynamic object collection
                 */
                queryOriginalCollection(selectFields:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * query原生的不带实体标识及属性的queryOriginalArray，单纯用作查询 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @param orderBys     the order bys
                 * @return DynamicObjectCollection dynamic object collection
                 */
                queryOriginalCollection(selectFields:string,filters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.dataentity.entity.DynamicObjectCollection;
                /**
                 * query带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库</br>
                 * <font color=red>说明：会查询所有字段，有大字段的慎用</font>
                 * @param filter           the filter
                 * @return DynamicObject dynamic object
                 */
                queryOriginalOne(filter:$.kd.bos.orm.query.QFilter):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * query带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库</br>
                 * <font color=red>说明：会查询所有字段，有大字段的慎用</font>
                 * @param filters           the filters
                 * @return DynamicObject dynamic object
                 */
                queryOriginalOne(filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * queryOne 使用BusinessDataServiceHelper方法，获得带实体标识的DynamicObject,访问两次数据库 queryOriginalOne
                 * 使用QueryServiceHelper方法，获得原生的DynamicObject，selectFields可以使用别名，访问一次数据库。
                 *
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @return DynamicObject dynamic object
                 */
                queryOriginalOne(selectFields:string,filters:$.kd.bos.orm.query.QFilter[]):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * query带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param filter           the filter
                 * @return DynamicObject dynamic object
                 */
                queryOriginalOne(selectProperties:string,filter:$.kd.bos.orm.query.QFilter):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * query带实体标识的DynamicObject，更新前使用，使用该方法会访问两次数据库 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectProperties the select properties
                 * @param pk               the pk
                 * @return DynamicObject dynamic object
                 */
                queryOriginalOne(selectProperties:string,pk:any):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * query原生的不带实体标识及属性的queryOriginalArray，单纯用作查询 单纯查询推荐使用queryOriginal方法，只访问一次数据库
                 *
                 * @param selectFields the select fields
                 * @param filters      the filters
                 * @param orderBys     the order bys
                 * @return DynamicObject dynamic object
                 */
                queryOriginalOne(selectFields:string,filters:$.kd.bos.orm.query.QFilter[],orderBys:string):$.kd.bos.dataentity.entity.DynamicObject;
                /**
                 * save指定动态对象集合
                 *
                 * @param dobjColl the dobj coll
                 * @return DynamicObject object collectiion
                 */
                save(dobjColl:$.kd.bos.dataentity.entity.DynamicObjectCollection):any[];
                /**
                 * save指定动态对象数组
                 *
                 * @param dobjs 指定的动态对象数组
                 * @return DynamicObject object [ ]
                 */
                save(dobjs:$.kd.bos.dataentity.entity.DynamicObject[]):any[];
                /**
                 * save指定动态对象
                 *
                 * @param dobj 指定动态对象
                 * @return 动态对象pk
                 */
                saveOne(dobj:$.kd.bos.dataentity.entity.DynamicObject):any;
                /**
                 * set实体编码
                 *
                 * @param entityName 实体编码
                 */
                setEntityName(entityName:string):void;
                /**
                 * save指定动态对象数组
                 *
                 * @param dobjs the DynamicObject[] objects
                 * @return Object[] object [ ]
                 */
                update(dobjs:$.kd.bos.dataentity.entity.DynamicObject[]):any[];
                /**
                 * save指定动态对象
                 *
                 * @param dobj the DynamicObject object
                 */
                updateDataOne(dobj:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * save指定动态对象数组
                 *
                 * @param dobjs the DynamicObject[]
                 */
                updateDatas(dobjs:$.kd.bos.dataentity.entity.DynamicObject[]):void;
                /**
                 * save指定动态对象
                 *
                 * @param dobj 指定动态对象
                 * @return DynamicObject object pks
                 */
                updateOne(dobj:$.kd.bos.dataentity.entity.DynamicObject):any;
            }
            type HRBaseServiceHelper_T = HRBaseServiceHelper_S & HRBaseServiceHelper$;
            interface HRBaseServiceHelper extends HRBaseServiceHelper_T {
            }
        }
        namespace kd.hr.hbp.business.util{
            interface ExcludeFromJacocoGeneratedReport_S {
            }
            interface ExcludeFromJacocoGeneratedReport$ {
            }
            type ExcludeFromJacocoGeneratedReport_T = $.java.lang.annotation.Annotation & ExcludeFromJacocoGeneratedReport_S & ExcludeFromJacocoGeneratedReport$;
            interface ExcludeFromJacocoGeneratedReport extends ExcludeFromJacocoGeneratedReport_T {
            }
        }
        namespace kd.hr.hbp.common.api{
            interface HrApiResponse_S {
                fail(arg0:any):HrApiResponse;
                fail(arg0:string):HrApiResponse;
                fail(arg0:string,arg1:string):HrApiResponse;
                success():HrApiResponse;
                success(arg0:any):HrApiResponse;
            }
            type HrApiResponse_ST = $.java.io.Serializable & HrApiResponse_S;
            interface HrApiResponse_C extends HrApiResponse_ST {
                new():HrApiResponse;
                new(arg0:boolean,arg1:string,arg2:string,arg3:any):HrApiResponse;
            }
            interface HrApiResponse$ {
                getCode():string;
                getData():any;
                getErrorMessage():string;
                isSuccess():boolean;
                setCode(arg0:string):void;
                setData(arg0:any):void;
                setErrorMessage(arg0:string):void;
                setSuccess(arg0:boolean):void;
            }
            type HrApiResponse_T = $.java.io.Serializable & HrApiResponse_S & HrApiResponse$;
            interface HrApiResponse extends HrApiResponse_T {
            }
        }
        namespace kd.hr.hbp.common.constants.timeline{
            enum TimelineModelTypeEnum {
                INTERRUPTION_OVERLAP,
                INTERRUPTION_NOOVERLAP,
                NOINTERRUPTION_NOOVERLAP
            }
        }
        namespace kd.hr.hbp.common.enums.smartsearch{
            enum SearchCategoryEnum {
                WORD_SEG_SEARCH,
                PHRASE_SEARCH
            }
            enum SearchKeyLogicEnum {
                AND,
                OR
            }
            enum SearchTargetTypeEnum {
                FIELDS,
                ENTITY
            }
        }
        namespace kd.hr.hbp.common.init{
            interface InitInParam_S {
            }
            interface InitInParam_C extends InitInParam_S {
                new():InitInParam;
            }
            interface InitInParam$ {
                getAcker():$.kd.bos.mq.MessageAcker;
                getBatchNumber():long;
                getEntityNumber():string;
                getExecTaskId():long;
                getHandleClassName():string;
                getHandleWay():string;
                getMessageId():string;
                getMethod():string;
                getOperateType():string;
                getOther():$.java.util.Map;
                getScene():InitSceneEnum;
                isResend():boolean;
                setAcker(arg0:$.kd.bos.mq.MessageAcker):void;
                setBatchNumber(arg0:long):void;
                setEntityNumber(arg0:string):void;
                setExecTaskId(arg0:long):void;
                setHandleClassName(arg0:string):void;
                setHandleWay(arg0:string):void;
                setMessageId(arg0:string):void;
                setMethod(arg0:string):void;
                setOperateType(arg0:string):void;
                setOther(arg0:$.java.util.Map):void;
                setResend(arg0:boolean):void;
                setScene(arg0:InitSceneEnum):void;
            }
            type InitInParam_T = InitInParam_S & InitInParam$;
            interface InitInParam extends InitInParam_T {
            }
            enum InitSceneEnum {
                COMMON,
                NONLINETIMESEQ,
                LINETIEMSEQ,
                LINETIMESEQ_VERSION
            }
        }
        namespace kd.hr.hbp.common.model{
            interface AuthorizedOrgTeamResult_S {
                allOrg():AuthorizedOrgTeamResult;
            }
            type AuthorizedOrgTeamResult_ST = $.java.io.Serializable & AuthorizedOrgTeamResult_S;
            interface AuthorizedOrgTeamResult_C extends AuthorizedOrgTeamResult_ST {
                new():AuthorizedOrgTeamResult;
                new(arg0:boolean):AuthorizedOrgTeamResult;
                new(arg0:boolean,arg1:$.java.util.Map):AuthorizedOrgTeamResult;
            }
            interface AuthorizedOrgTeamResult$ {
                getHasPermOrgTeamMap():$.java.util.Map;
                isHasAllOrgPerm():boolean;
                setHasAllOrgPerm(arg0:boolean):void;
                setHasPermOrgTeamMap(arg0:$.java.util.Map):void;
            }
            type AuthorizedOrgTeamResult_T = $.java.io.Serializable & AuthorizedOrgTeamResult_S & AuthorizedOrgTeamResult$;
            interface AuthorizedOrgTeamResult extends AuthorizedOrgTeamResult_T {
            }
            interface AuthorizedOrgResultWithSub_S {
                allOrg():AuthorizedOrgResultWithSub;
            }
            type AuthorizedOrgResultWithSub_ST = $.java.io.Serializable & AuthorizedOrgResultWithSub_S;
            interface AuthorizedOrgResultWithSub_C extends AuthorizedOrgResultWithSub_ST {
                new():AuthorizedOrgResultWithSub;
                new(arg0:boolean):AuthorizedOrgResultWithSub;
                new(arg0:boolean,arg1:$.java.util.List):AuthorizedOrgResultWithSub;
            }
            interface AuthorizedOrgResultWithSub$ {
                getHasPermOrgsWithSub():$.java.util.List;
                isHasAllOrgPerm():boolean;
                setHasAllOrgPerm(arg0:boolean):void;
                setHasPermOrgsWithSub(arg0:$.java.util.List):void;
            }
            type AuthorizedOrgResultWithSub_T = $.java.io.Serializable & AuthorizedOrgResultWithSub_S & AuthorizedOrgResultWithSub$;
            interface AuthorizedOrgResultWithSub extends AuthorizedOrgResultWithSub_T {
            }
            interface AuthorizedOrgResult_S {
                allOrg():AuthorizedOrgResult;
            }
            type AuthorizedOrgResult_ST = $.java.io.Serializable & AuthorizedOrgResult_S;
            interface AuthorizedOrgResult_C extends AuthorizedOrgResult_ST {
                new():AuthorizedOrgResult;
                new(arg0:boolean):AuthorizedOrgResult;
                new(arg0:boolean,arg1:$.java.util.List):AuthorizedOrgResult;
            }
            interface AuthorizedOrgResult$ {
                getHasPermOrgs():$.java.util.List;
                isHasAllOrgPerm():boolean;
                setHasAllOrgPerm(arg0:boolean):void;
                setHasPermOrgs(arg0:$.java.util.List):void;
            }
            type AuthorizedOrgResult_T = $.java.io.Serializable & AuthorizedOrgResult_S & AuthorizedOrgResult$;
            interface AuthorizedOrgResult extends AuthorizedOrgResult_T {
            }
        }
        namespace kd.hr.hbp.common.model.smartsearch.search{
            interface LabelValCompParam_S {
            }
            type LabelValCompParam_ST = $.java.io.Serializable & LabelValCompParam_S;
            interface LabelValCompParam_C extends LabelValCompParam_ST {
                new():LabelValCompParam;
            }
            interface LabelValCompParam$ {
                getInputText():string;
                getSearchObjId():long;
                getSearchRangFieldList():$.java.util.List;
                getSearchTargetType():kd.hr.hbp.common.enums.smartsearch.SearchTargetTypeEnum;
                getSize():number;
                setInputText(arg0:string):void;
                setSearchObjId(arg0:long):void;
                setSearchRangFieldList(arg0:$.java.util.List):void;
                setSearchTargetType(arg0:kd.hr.hbp.common.enums.smartsearch.SearchTargetTypeEnum):void;
                setSize(arg0:number):void;
            }
            type LabelValCompParam_T = $.java.io.Serializable & LabelValCompParam_S & LabelValCompParam$;
            interface LabelValCompParam extends LabelValCompParam_T {
            }
            interface SearchParam_S {
            }
            type SearchParam_ST = $.java.io.Serializable & SearchParam_S;
            interface SearchParam_C extends SearchParam_ST {
                new():SearchParam;
                new(arg0:long,arg1:long,arg2:kd.hr.hbp.common.enums.smartsearch.SearchCategoryEnum,arg3:kd.hr.hbp.common.enums.smartsearch.SearchKeyLogicEnum):SearchParam;
                new(arg0:long,arg1:long,arg2:kd.hr.hbp.common.enums.smartsearch.SearchCategoryEnum,arg3:kd.hr.hbp.common.enums.smartsearch.SearchKeyLogicEnum,arg4:string):SearchParam;
            }
            interface SearchParam$ {
                getCategory():kd.hr.hbp.common.enums.smartsearch.SearchCategoryEnum;
                getLabelValCompSelList():$.java.util.List;
                getPageId():string;
                getPermCtlAppNum():string;
                getPermCtlDymNum():string;
                getSceneId():long;
                getSceneVersion():long;
                getSearchContent():string;
                getSearchKeyLogic():kd.hr.hbp.common.enums.smartsearch.SearchKeyLogicEnum;
                getSearchObjId():long;
                getSearchRangFieldList():$.java.util.List;
                getSearchTargetType():kd.hr.hbp.common.enums.smartsearch.SearchTargetTypeEnum;
                isRecordSearchLog():boolean;
                setCategory(arg0:kd.hr.hbp.common.enums.smartsearch.SearchCategoryEnum):void;
                setLabelValCompSelList(arg0:$.java.util.List):void;
                setPageId(arg0:string):void;
                setPermCtlAppNum(arg0:string):void;
                setPermCtlDymNum(arg0:string):void;
                setRecordSearchLog(arg0:boolean):void;
                setSceneId(arg0:long):void;
                setSceneVersion(arg0:long):void;
                setSearchContent(arg0:string):void;
                setSearchKeyLogic(arg0:kd.hr.hbp.common.enums.smartsearch.SearchKeyLogicEnum):void;
                setSearchObjId(arg0:long):void;
                setSearchRangFieldList(arg0:$.java.util.List):void;
                setSearchTargetType(arg0:kd.hr.hbp.common.enums.smartsearch.SearchTargetTypeEnum):void;
            }
            type SearchParam_T = $.java.io.Serializable & SearchParam_S & SearchParam$;
            interface SearchParam extends SearchParam_T {
            }
        }
        namespace kd.hr.hbp.common.mservice{
            interface HRMSendMsgResult_S {
                readonly CODE_ALL_FAILED:string;
                readonly CODE_ALL_SUCCESSED:string;
                readonly CODE_SOME_SUCCESSED:string;
                readonly IS_SUCCESS_FALSE:number;
                readonly IS_SUCCESS_TRUE:number;
            }
            type HRMSendMsgResult_ST = HRMServiceResult_S & HRMSendMsgResult_S;
            interface HRMSendMsgResult_C extends HRMSendMsgResult_ST {
                new():HRMSendMsgResult;
            }
            interface HRMSendMsgResult$ {
                getFailedCnt():number;
                getSuccessedCnt():number;
                getTotalCnt():number;
                setErrorResult(arg0:boolean,arg1:string,arg2:string):void;
                setFailedCnt(arg0:number):void;
                setResult(arg0:boolean,arg1:string,arg2:number,arg3:number,arg4:string):void;
                setSuccessedCnt(arg0:number):void;
                setTotalCnt(arg0:number):void;
            }
            type HRMSendMsgResult_T = HRMServiceResult & HRMSendMsgResult_S & HRMSendMsgResult$;
            interface HRMSendMsgResult extends HRMSendMsgResult_T {
            }
            interface HRMServiceResult_S {
                readonly DEFAULT_ERROR_CODE:string;
                readonly DEFAULT_SUCCESS_CODE:string;
                fail(arg0:string):HRMServiceResult;
                fail(arg0:string,arg1:string):HRMServiceResult;
                success():HRMServiceResult;
                success(arg0:any):HRMServiceResult;
                success(arg0:any,arg1:string):HRMServiceResult;
            }
            type HRMServiceResult_ST = $.java.io.Serializable & HRMServiceResult_S;
            interface HRMServiceResult_C extends HRMServiceResult_ST {
                new():HRMServiceResult;
            }
            interface HRMServiceResult$ {
                getMessage():string;
                getReturnCode():string;
                getReturnData():any;
                isSuccess():boolean;
                setMessage(arg0:string):void;
                setReturnCode(arg0:string):void;
                setReturnData(arg0:any):void;
                setSuccess(arg0:boolean):void;
            }
            type HRMServiceResult_T = $.java.io.Serializable & HRMServiceResult_S & HRMServiceResult$;
            interface HRMServiceResult extends HRMServiceResult_T {
            }
        }
        namespace kd.sdk.hr.hrmp.haos.extpoint{
            interface IStaffExtDimFilterExtend_S {
            }
            interface IStaffExtDimFilterExtend$ {
                /**
                 * 获取扩展维度的自定义的过滤条件，用于打开F7以及导入数据时
                 * 接口入参为 扩展维度的基础资料编码
                 * @return 自定义过滤条件
                 */
                getCustomExtDimQfilter(extDimBaseDataNumber:string,dataModel:$.kd.bos.entity.datamodel.IDataModel):$.kd.bos.orm.query.QFilter;
            }
            type IStaffExtDimFilterExtend_T = IStaffExtDimFilterExtend_S & IStaffExtDimFilterExtend$;
            interface IStaffExtDimFilterExtend extends IStaffExtDimFilterExtend_T {
            }
            interface HROdcModule_S {
            }
            type HROdcModule_ST = $.kd.sdk.module.Module & HROdcModule_S;
            interface HROdcModule_C extends HROdcModule_ST {
                new():HROdcModule;
            }
            interface HROdcModule$ {
            }
            type HROdcModule_T = $.kd.sdk.module.Module & HROdcModule_S & HROdcModule$;
            interface HROdcModule extends HROdcModule_T {
            }
            interface IStaffRuleConfigExtend_S {
            }
            interface IStaffRuleConfigExtend$ {
                /**
                 * 是否可以跳过编制计划设置BU重复的校验
                 * @return
                 */
                skipBURepeatConfigValidator():boolean;
            }
            type IStaffRuleConfigExtend_T = IStaffRuleConfigExtend_S & IStaffRuleConfigExtend$;
            interface IStaffRuleConfigExtend extends IStaffRuleConfigExtend_T {
            }
        }
        namespace kd.sdk.hr.hrmp.hbjm.extpoint{
            interface HROdcModule_S {
            }
            type HROdcModule_ST = $.kd.sdk.module.Module & HROdcModule_S;
            interface HROdcModule_C extends HROdcModule_ST {
                new():HROdcModule;
            }
            interface HROdcModule$ {
            }
            type HROdcModule_T = $.kd.sdk.module.Module & HROdcModule_S & HROdcModule$;
            interface HROdcModule extends HROdcModule_T {
            }
            interface IJobTreeSortConditionExtend_S {
            }
            interface IJobTreeSortConditionExtend$ {
                /**
                 * 获取左树排序的规则
                 * @return 排序规则
                 */
                getJobTreeAndJobClassTreeSortCondition():string;
            }
            type IJobTreeSortConditionExtend_T = IJobTreeSortConditionExtend_S & IJobTreeSortConditionExtend$;
            interface IJobTreeSortConditionExtend extends IJobTreeSortConditionExtend_T {
            }
        }
        namespace kd.sdk.hr.hrmp.hbpm.extpoint{
            interface IPositionCompareEntryServiceExtend_S {
            }
            interface IPositionCompareEntryServiceExtend$ {
                /**
                 * 岗位分录对比
                 * @param before 变动前的版本
                 * @param after  变动后的版本
                 * @param entryKey 分录标识
                 * @return 对比结果
                 */
                getEntryComparentResult(before:$.kd.bos.dataentity.entity.DynamicObject,after:$.kd.bos.dataentity.entity.DynamicObject,entryKey:string):PositionCompareEntryResult;
            }
            type IPositionCompareEntryServiceExtend_T = IPositionCompareEntryServiceExtend_S & IPositionCompareEntryServiceExtend$;
            interface IPositionCompareEntryServiceExtend extends IPositionCompareEntryServiceExtend_T {
            }
            interface IPositionF7OrgTreeOrgIdsServiceExtend_S {
            }
            interface IPositionF7OrgTreeOrgIdsServiceExtend$ {
                /**
                 * F7左树的需要展示的组织数据的boid
                 * @return
                 */
                getPositionF7TreeOrgIds():$.java.util.List;
            }
            type IPositionF7OrgTreeOrgIdsServiceExtend_T = IPositionF7OrgTreeOrgIdsServiceExtend_S & IPositionF7OrgTreeOrgIdsServiceExtend$;
            interface IPositionF7OrgTreeOrgIdsServiceExtend extends IPositionF7OrgTreeOrgIdsServiceExtend_T {
            }
            interface IBosPositionValidateServiceExt_S {
            }
            interface IBosPositionValidateServiceExt$ {
                /**
                 * 平台岗位校验
                 *
                 * @param reqs HR岗位相关字段入参
                 * @return 校验结果集合（与入参顺序保持一致）
                 */
                bosPositionValidate(reqs:$.java.util.List):$.java.util.List;
            }
            type IBosPositionValidateServiceExt_T = IBosPositionValidateServiceExt_S & IBosPositionValidateServiceExt$;
            interface IBosPositionValidateServiceExt extends IBosPositionValidateServiceExt_T {
            }
            interface HROdcModule_S {
            }
            type HROdcModule_ST = $.kd.sdk.module.Module & HROdcModule_S;
            interface HROdcModule_C extends HROdcModule_ST {
                new():HROdcModule;
            }
            interface HROdcModule$ {
            }
            type HROdcModule_T = $.kd.sdk.module.Module & HROdcModule_S & HROdcModule$;
            interface HROdcModule extends HROdcModule_T {
            }
            interface PositionCompareEntryResult_S {
            }
            interface PositionCompareEntryResult_C extends PositionCompareEntryResult_S {
                new():PositionCompareEntryResult;
            }
            interface PositionCompareEntryResult$ {
                getAfterValue():string;
                getBeforeValue():string;
                isSame():boolean;
                setAfterValue(afterValue:string):void;
                setBeforeValue(beforeValue:string):void;
                setSame(same:boolean):void;
            }
            type PositionCompareEntryResult_T = PositionCompareEntryResult_S & PositionCompareEntryResult$;
            interface PositionCompareEntryResult extends PositionCompareEntryResult_T {
            }
            interface IPositionSkipValidateServiceExtend_S {
            }
            interface IPositionSkipValidateServiceExtend$ {
                /**
                 * 获取需要跳过的校验的方法名称
                 * @return 需要跳过的校验的方法名称
                 */
                getSkipValidateMethods():$.java.util.List;
            }
            type IPositionSkipValidateServiceExtend_T = IPositionSkipValidateServiceExtend_S & IPositionSkipValidateServiceExtend$;
            interface IPositionSkipValidateServiceExtend extends IPositionSkipValidateServiceExtend_T {
            }
            interface IValidatorExtend_S {
            }
            interface IValidatorExtend$ {
                getExtendValidator():$.java.util.List;
            }
            type IValidatorExtend_T = IValidatorExtend_S & IValidatorExtend$;
            interface IValidatorExtend extends IValidatorExtend_T {
            }
        }
        namespace kd.sdk.hr.hrmp.hrdi{
            interface HRHdtcModule_S {
            }
            type HRHdtcModule_ST = $.kd.sdk.module.Module & HRHdtcModule_S;
            interface HRHdtcModule_C extends HRHdtcModule_ST {
                new():HRHdtcModule;
            }
            interface HRHdtcModule$ {
            }
            type HRHdtcModule_T = $.kd.sdk.module.Module & HRHdtcModule_S & HRHdtcModule$;
            interface HRHdtcModule extends HRHdtcModule_T {
            }
            interface IHRCommonIntegrationService_S {
            }
            interface IHRCommonIntegrationService$ {
                /**
                 * 业务数据集成方法
                 *
                 * @param dataList 业务动态对象数据
                 * @param bizScene 业务场景：新增 1，启用 2， 禁用 3， 变更 4， 删除 5
                 * @param extParamMap 预留扩展入参
                 * @return 数据同步结果
                 * 返回结果说明：
                 * HRMServiceResult.success : 是否成功标识
                 * HRMServiceResult.message : 异常场景，则为异常信息，非异常场景，则为空
                 * HRMServiceResult.returnCode : 同步数据全部成功，则为success，如果有同步失败数据，则为fail
                 * HRMServiceResult.returnData : 如果returnCode为success，则为空，如果returnCode为fail，
                 *                             则为失败数据ID和失败信息的Map<Long,String>，格式为<ID,失败信息>
                 */
                sync(dataList:$.java.util.List,bizScene:string,extParamMap:$.java.util.Map):kd.hr.hbp.common.mservice.HRMServiceResult;
            }
            type IHRCommonIntegrationService_T = IHRCommonIntegrationService_S & IHRCommonIntegrationService$;
            interface IHRCommonIntegrationService extends IHRCommonIntegrationService_T {
            }
        }
        namespace kd.sdk.hr.hrmp.hrpi.extpoint{
            interface ErmanfileDataMapBeforeDelUtil_S {
                /**
                 * 获取删除的数据
                 *
                 * @param entityName 实体标识
                 * @param pkIdList   数据id
                 */
                getData(entityName:string,pkIdList:$.java.util.List):void;
            }
            interface ErmanfileDataMapBeforeDelUtil_C extends ErmanfileDataMapBeforeDelUtil_S {
                new():ErmanfileDataMapBeforeDelUtil;
            }
            interface ErmanfileDataMapBeforeDelUtil$ {
            }
            type ErmanfileDataMapBeforeDelUtil_T = ErmanfileDataMapBeforeDelUtil_S & ErmanfileDataMapBeforeDelUtil$;
            interface ErmanfileDataMapBeforeDelUtil extends ErmanfileDataMapBeforeDelUtil_T {
            }
            interface IErmanfileDataMapBeforeDelExtService_S {
            }
            interface IErmanfileDataMapBeforeDelExtService$ {
                /**
                 * 获取要删除的数据
                 *
                 * @param map key-实体标识;value-数据id
                 * @return 要删除的数据
                 */
                getDataMap?(map:$.java.util.Map):$.java.util.Map;
            }
            type IErmanfileDataMapBeforeDelExtService_T = IErmanfileDataMapBeforeDelExtService_S & IErmanfileDataMapBeforeDelExtService$;
            interface IErmanfileDataMapBeforeDelExtService extends IErmanfileDataMapBeforeDelExtService_T {
            }
        }
    }
}
export {};