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

/// <reference types="../../@cosmic/bos-script" />
/// <reference types="../../@cosmic/bos-core" />
declare global {
    namespace $ {
        namespace kd.fi.pa.algox{
            interface PARowMetaBuilder_S {
            }
            type PARowMetaBuilder_ST = $.java.io.Serializable & PARowMetaBuilder_S;
            interface PARowMetaBuilder_C extends PARowMetaBuilder_ST {
                new(rowMeta:$.kd.bos.algo.RowMeta):PARowMetaBuilder;
            }
            interface PARowMetaBuilder$ {
                /**
                 * 添加fields,返回新的rowMeta构建器
                 */
                addFields(...addFields:$.kd.bos.algo.Field[]):this;
                /**
                 * 创建RowX处理器
                 */
                create(rowX:$.kd.bos.algox.RowX):PARowXProcessor;
                /**
                 * 创建RowX处理器，数据转化
                 */
                createConversion(sourcePARowXProcessor:PARowXProcessor):PARowXProcessor;
                /**
                 * 创建RowX处理器，数据copy
                 */
                createCopy(rowX:$.kd.bos.algox.RowX):PARowXProcessor;
                /**
                 * 创建RowX处理器，数据new
                 */
                createNew():PARowXProcessor;
                /**
                 * 删除fields,返回新的rowMeta构建器
                 */
                delFields(...delFields:$.kd.bos.algo.Field[]):this;
                getRowMeta():$.kd.bos.algo.RowMeta;
            }
            type PARowMetaBuilder_T = $.java.io.Serializable & PARowMetaBuilder_S & PARowMetaBuilder$;
            interface PARowMetaBuilder extends PARowMetaBuilder_T {
            }
            interface PARowXProcessor_S {
            }
            type PARowXProcessor_ST = $.java.io.Serializable & PARowXProcessor_S;
            interface PARowXProcessor_C extends PARowXProcessor_ST {
                new(rowMeta:$.kd.bos.algo.RowMeta,rowX:$.kd.bos.algox.RowX):PARowXProcessor;
            }
            interface PARowXProcessor$ {
                getRowMeta():$.kd.bos.algo.RowMeta;
                getRowX():$.kd.bos.algox.RowX;
                /**
                 * 获取RowX属性值
                 */
                getValue(fieldName:string):any;
                /**
                 * 获取RowX属性值(批量)
                 */
                getValue(fieldNameList:$.java.util.List):$.java.util.Map;
                /**
                 * 获取RowX属性值(特殊处理)
                 */
                getValueSpecial(fieldName:string):any;
                /**
                 * 获取RowX属性的数据类型
                 */
                getValueType(fieldName:string):$.kd.bos.algo.DataType;
                /**
                 * 获取RowX属性值(批量)
                 */
                getValues(fieldNameList:$.java.util.List):any[];
                /**
                 * 修改RowX属性值(批量)
                 */
                updateValue(fieldValueMap:$.java.util.Map):this;
                /**
                 * 修改RowX属性值
                 */
                updateValue(field:string,value:any):this;
                /**
                 * 修改RowX属性值通过DataType(特殊处理)
                 */
                updateValueSpecial(field:string,value:any):this;
            }
            type PARowXProcessor_T = $.java.io.Serializable & PARowXProcessor_S & PARowXProcessor$;
            interface PARowXProcessor extends PARowXProcessor_T {
            }
            interface PAIdCreator_S {
            }
            type PAIdCreator_ST = $.java.io.Serializable & PAIdCreator_S;
            interface PAIdCreator_C extends PAIdCreator_ST {
                new():PAIdCreator;
                /**
                 * 自定义
                 */
                new(count:number):PAIdCreator;
            }
            interface PAIdCreator$ {
                /**
                 * 生成id
                 */
                getId():long;
                /**
                 * 重置count
                 */
                setCount(count:number):void;
            }
            type PAIdCreator_T = $.java.io.Serializable & PAIdCreator_S & PAIdCreator$;
            interface PAIdCreator extends PAIdCreator_T {
            }
        }
        namespace kd.fi.pa.algox.script{
            interface ScriptGroupReduceFunction_S {
            }
            interface ScriptGroupReduceFunction_C extends ScriptGroupReduceFunction_S {
                new():ScriptGroupReduceFunction;
            }
            interface ScriptGroupReduceFunction$ {
                /**
                 * reduce
                 *
                 * @param iter      分组后的数据集
                 * @param collector collector
                 */
                reduce(iter:$.java.lang.Iterable,collector:$.kd.bos.algox.Collector,context:ScriptFunctionContext):void;
            }
            type ScriptGroupReduceFunction_T = ScriptGroupReduceFunction_S & ScriptGroupReduceFunction$;
            interface ScriptGroupReduceFunction extends ScriptGroupReduceFunction_T {
            }
            interface GenerateRuleBaseScript_S {
            }
            interface GenerateRuleBaseScript_C extends GenerateRuleBaseScript_S {
                new():GenerateRuleBaseScript;
            }
            interface GenerateRuleBaseScript$ {
                /**
                 * 执行派生脚本生成派生数据集
                 * @return 派生数据集
                 */
                generate():$.kd.bos.algox.DataSetX;
                /**
                 * 返回数据源表dataSet，提供给脚本调用
                 * @param tableName 数据源表数据集
                 * @return
                 */
                getDataSourceDataSet(tableName:string):$.kd.bos.algo.DataSet;
                /**
                 * 返回数据源表数据集，提供给脚本调用
                 * @param tableName 数据源表数据集
                 * @return 数据集
                 */
                getDataSourceDataX(tableName:string):$.kd.bos.algox.DataSetX;
                getEndDate():Date;
                /**
                 * 获取FlatMap代理函数
                 * @return FlatMap代理函数
                 */
                getFlatMapFunctionProxy():FlatMapFunctionProxy;
                /**
                 * 获取GroupReduce代理函数
                 * @return 代理函数
                 */
                getGroupReduceFunctionProxy():GroupReduceFunctionProxy;
                getJobSession():$.kd.bos.algox.JobSession;
                getLimitNum():number;
                /**
                 * 获取Map代理函数
                 * @return 代理函数
                 */
                getMapFunctionProxy():MapFunctionProxy;
                /**
                 * 返回分析模型数据集，提供给脚本调用
                 * @return 分析模型数据集
                 */
                getModelDataSetX():$.kd.bos.algox.DataSetX;
                getOrgIds():long[];
                /**
                 * 返回派生RowMeta构建器
                 * @return RowMeta构建器
                 */
                getResultRowMetaBuilder():PARowMetaBuilder;
                getScript():string;
                getStartDate():Date;
                getStartPeriod():long;
                setDataSourceInputMap(dataSourceInputMap:$.java.util.Map):void;
                setEndDate(endDate:Date):void;
                setJobSession(jobSession:$.kd.bos.algox.JobSession):void;
                setLimitNum(limitNum:number):void;
                setOrgIds(orgIds:long[]):void;
                setScript(script:string):void;
                setSenderInput(senderInput:$.kd.bos.algo.Input[]):void;
                setStartDate(startDate:Date):void;
                setStartPeriod(startPeriod:long):void;
            }
            type GenerateRuleBaseScript_T = GenerateRuleBaseScript_S & GenerateRuleBaseScript$;
            interface GenerateRuleBaseScript extends GenerateRuleBaseScript_T {
            }
            interface MapFunctionProxy_S {
            }
            type MapFunctionProxy_ST = $.kd.bos.algox.MapFunction & MapFunctionProxy_S;
            interface MapFunctionProxy_C extends MapFunctionProxy_ST {
                new(script:string):MapFunctionProxy;
            }
            interface MapFunctionProxy$ {
                getContext():ScriptFunctionContext;
                getFunctionName():string;
                getScript():string;
                setFunctionName(functionName:string):void;
            }
            type MapFunctionProxy_T = $.kd.bos.algox.MapFunction & MapFunctionProxy_S & MapFunctionProxy$;
            interface MapFunctionProxy extends MapFunctionProxy_T {
            }
            interface ScriptFlatMapFunction_S {
            }
            interface ScriptFlatMapFunction_C extends ScriptFlatMapFunction_S {
                new():ScriptFlatMapFunction;
            }
            interface ScriptFlatMapFunction$ {
                /**
                 * @param rowX 处理数据行
                 * @param collector 收集器
                 * @param context 函数上下文
                 */
                flatMap(rowX:$.kd.bos.algox.RowX,collector:$.kd.bos.algox.Collector,context:ScriptFunctionContext):void;
            }
            type ScriptFlatMapFunction_T = ScriptFlatMapFunction_S & ScriptFlatMapFunction$;
            interface ScriptFlatMapFunction extends ScriptFlatMapFunction_T {
            }
            interface ScriptFunctionContext_S {
            }
            type ScriptFunctionContext_ST = $.java.io.Serializable & ScriptFunctionContext_S;
            interface ScriptFunctionContext_C extends ScriptFunctionContext_ST {
                new():ScriptFunctionContext;
            }
            interface ScriptFunctionContext$ {
                getCustomParam(name:string):any;
                getCustomParams():$.java.util.Map;
                getIdCreator():PAIdCreator;
                getResultRowMetaBuilder():PARowMetaBuilder;
                getSourceRowMetaBuilder():PARowMetaBuilder;
                putCustomParam(name:string,value:any):void;
                setIdCreator(idCreator:PAIdCreator):void;
                setResultRowMetaBuilder(resultRowMetaBuilder:PARowMetaBuilder):void;
                setSourceRowMetaBuilder(sourceRowMetaBuilder:PARowMetaBuilder):void;
            }
            type ScriptFunctionContext_T = $.java.io.Serializable & ScriptFunctionContext_S & ScriptFunctionContext$;
            interface ScriptFunctionContext extends ScriptFunctionContext_T {
            }
            interface GroupReduceFunctionProxy_S {
            }
            type GroupReduceFunctionProxy_ST = $.kd.bos.algox.GroupReduceFunction & GroupReduceFunctionProxy_S;
            interface GroupReduceFunctionProxy_C extends GroupReduceFunctionProxy_ST {
                new(script:string):GroupReduceFunctionProxy;
            }
            interface GroupReduceFunctionProxy$ {
                getContext():ScriptFunctionContext;
                getFunctionName():string;
                getScript():string;
                setFunctionName(functionName:string):void;
            }
            type GroupReduceFunctionProxy_T = $.kd.bos.algox.GroupReduceFunction & GroupReduceFunctionProxy_S & GroupReduceFunctionProxy$;
            interface GroupReduceFunctionProxy extends GroupReduceFunctionProxy_T {
            }
            interface ScriptMapFunction_S {
            }
            interface ScriptMapFunction_C extends ScriptMapFunction_S {
                new():ScriptMapFunction;
            }
            interface ScriptMapFunction$ {
                /**
                 * 映射函数
                 *
                 * @param row RowX
                 * @return 新RowX
                 */
                map(row:$.kd.bos.algox.RowX,context:ScriptFunctionContext):$.kd.bos.algox.RowX;
            }
            type ScriptMapFunction_T = ScriptMapFunction_S & ScriptMapFunction$;
            interface ScriptMapFunction extends ScriptMapFunction_T {
            }
            interface FlatMapFunctionProxy_S {
            }
            type FlatMapFunctionProxy_ST = $.kd.bos.algox.FlatMapFunction & FlatMapFunctionProxy_S;
            interface FlatMapFunctionProxy_C extends FlatMapFunctionProxy_ST {
                new(script:string):FlatMapFunctionProxy;
            }
            interface FlatMapFunctionProxy$ {
                getContext():ScriptFunctionContext;
                getFunctionName():string;
                getScript():string;
                setFunctionName(functionName:string):void;
            }
            type FlatMapFunctionProxy_T = $.kd.bos.algox.FlatMapFunction & FlatMapFunctionProxy_S & FlatMapFunctionProxy$;
            interface FlatMapFunctionProxy extends FlatMapFunctionProxy_T {
            }
        }
        namespace kd.sdk.fi{
            interface SdkFiModule_S {
            }
            type SdkFiModule_ST = $.kd.sdk.module.Module & SdkFiModule_S;
            interface SdkFiModule_C extends SdkFiModule_ST {
                new():SdkFiModule;
            }
            interface SdkFiModule$ {
            }
            type SdkFiModule_T = $.kd.sdk.module.Module & SdkFiModule_S & SdkFiModule$;
            interface SdkFiModule extends SdkFiModule_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.adjustDiff{
            interface IFilterAdjustDiffBill_S {
            }
            interface IFilterAdjustDiffBill$ {
                /**
                 * @Param finApBills 本次提交的单据集合
                 * @Param canAdjustDiffBills 标准过滤后需要执行调差的单据集合
                 */
                filterAdjustDiffFinAp(finApBills:$.kd.bos.dataentity.entity.DynamicObject[],canAdjustDiffBills:$.java.util.List):void;
            }
            type IFilterAdjustDiffBill_T = IFilterAdjustDiffBill_S & IFilterAdjustDiffBill$;
            interface IFilterAdjustDiffBill extends IFilterAdjustDiffBill_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.dap{
            interface IAfterGenerateVoucherExt_S {
            }
            interface IAfterGenerateVoucherExt$ {
                afterGenerateVoucher(voucherOpValue:string,billEntityNumber:string,billPkMap:$.java.util.Map):void;
            }
            type IAfterGenerateVoucherExt_T = IAfterGenerateVoucherExt_S & IAfterGenerateVoucherExt$;
            interface IAfterGenerateVoucherExt extends IAfterGenerateVoucherExt_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.importext{
            interface IAfterImportDataExt_S {
            }
            interface IAfterImportDataExt$ {
                afterImportData(e:$.kd.bos.entity.datamodel.events.ImportDataEventArgs,model:$.kd.bos.entity.datamodel.IDataModel):void;
            }
            type IAfterImportDataExt_T = IAfterImportDataExt_S & IAfterImportDataExt$;
            interface IAfterImportDataExt extends IAfterImportDataExt_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.invoice{
            interface IInvoiceImport_S {
            }
            interface IInvoiceImport$ {
                /**
                 * 采集发票处理收票单
                 * @param invoiceVOsJson 发票回传的json报文
                 * @param downloadInvs 对应生成的收票单
                 * @return
                 * <p>扩展示例如下
                 * <pre><code>
                 *  @Override
                 * public void afterImportInvoice(String invoesJson, List<DynamicObject> list) {
                 * 	 List<JSONObject> jsonList = JSONObject.parseObject(invoesJson, List.class);
                 * 	 List<InvoiceVO> InvoiceList = new ArrayList<>();
                 * 	 for (JSONObject json : jsonList) {
                 * 	 InvoiceList.add(JSONObject.parseObject(json.toJSONString(), InvoiceVO.class));
                 *     }
                 *     }
                 * </code></pre>
                 */
                afterImportInvoice(invoiceVOsJson:string,downloadInvs:$.java.util.List):void;
            }
            type IInvoiceImport_T = IInvoiceImport_S & IInvoiceImport$;
            interface IInvoiceImport extends IInvoiceImport_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.invoicematch{
            interface IInvoiceMatchBase_S {
            }
            interface IInvoiceMatchBase$ {
                /**
                 * 获取展示的发票匹配页面标识，标准产品默认是发票匹配ap_invoicematch。二开可以继承发票匹配模板定制化发票匹配页面
                 * @return 发票匹配页面标识
                 */
                getShowInvoiceMatchKey():string;
                /**
                 * 获取展示的选择匹配单据页面标识，标准产品默认是发票匹配ap_invoicematch。二开可以继承选择发票匹配模板定制化匹配单据页面
                 * @return 选择匹配单据页面标识
                 */
                getShowSelectMatchBillKey():string;
            }
            type IInvoiceMatchBase_T = IInvoiceMatchBase_S & IInvoiceMatchBase$;
            interface IInvoiceMatchBase extends IInvoiceMatchBase_T {
            }
            interface IInvoiceMatchFormHandler_S {
            }
            interface IInvoiceMatchFormHandler$ {
                /**
                 * 增加二开单据选择匹配对象的处理器
                 */
                addSelectMatchBillHandlers():$.java.util.List;
                /**
                 * 填充完收票单分录后扩展接口
                 */
                afterFillInvoiceData(view:$.kd.bos.form.IFormView):void;
                /**
                 * 加载完收票单分录后扩展接口
                 */
                afterLoadInvoiceData(view:$.kd.bos.form.IFormView):void;
            }
            type IInvoiceMatchFormHandler_T = IInvoiceMatchFormHandler_S & IInvoiceMatchFormHandler$;
            interface IInvoiceMatchFormHandler extends IInvoiceMatchFormHandler_T {
            }
            interface IInvoiceMatchOpHandler_S {
            }
            interface IInvoiceMatchOpHandler$ {
                /**
                 * 确认应付后对应付单的后处理
                 * @param finApBillIds  应付单id集合
                 */
                afterConfirmFinAp(finApBillIds:$.java.util.List):void;
                /**
                 * 移除标准产品保存或者提交的校验
                 * @param parentValidator   主校验接类，继承平台抽象类的校验器，传入该参数是为了根据数据来决定是否移除，增加扩展性
                 * @param subValidators     业务自己的校验，可以移除
                 */
                removeValidator(parentValidator:$.kd.bos.entity.validate.AbstractValidator,subValidators:$.java.util.List):void;
            }
            type IInvoiceMatchOpHandler_T = IInvoiceMatchOpHandler_S & IInvoiceMatchOpHandler$;
            interface IInvoiceMatchOpHandler extends IInvoiceMatchOpHandler_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.invoicematch.service{
            interface ISelectMatchBillHandler_S {
            }
            interface ISelectMatchBillHandler$ {
                /**
                 * 字段处理：未匹配类字段的赋值
                 * @param inputDataSet   查询出来的匹配对象打平数据
                 */
                fieldHandle(inputDataSet:$.kd.bos.algo.DataSet):$.kd.bos.algo.DataSet;
                /**
                 * 是否触发执行filedHandle
                 */
                isFireHandle():boolean;
            }
            type ISelectMatchBillHandler_T = ISelectMatchBillHandler_S & ISelectMatchBillHandler$;
            interface ISelectMatchBillHandler extends ISelectMatchBillHandler_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.list{
            interface IAfterBizProcess_S {
            }
            interface IAfterBizProcess$ {
                /**
                 * @param view    列表或者表单view
                 * @param bizName 当前业务标识，用于判断走对应哪个sdk
                 *
                 * <p>扩展示例如下
                 * <pre><code>
                 * public void afterBizProcess(IFormView view, String bizName) {
                 * // 只处理应付有源采集场景
                 * if (!AfterBizExtendConst.FINAP_COLLECT_INVOICE.equals(bizName)) return;
                 * // Demo样例，把有源采集的票发票代码赋值给表头的备注字段
                 * IDataModel model = view.getModel();
                 * DynamicObjectCollection inventry = model.getEntryEntity("inventry");
                 * if (!inventry.isEmpty()){
                 * String invoiceCode = inventry.get(0).getString("i_invoicecode");
                 * model.setValue("remark",invoiceCode);
                 * }
                 * }
                 *    </code></pre>
                 */
                afterBizProcess(view:$.kd.bos.form.IFormView,bizName:string):void;
            }
            type IAfterBizProcess_T = IAfterBizProcess_S & IAfterBizProcess$;
            interface IAfterBizProcess extends IAfterBizProcess_T {
            }
            interface IApproverSetting_S {
            }
            interface IApproverSetting$ {
                /**
                 * 列表展示当前处理人自定义字段名称
                 *
                 * @return String: 自定义的列表字段名
                 * <p>扩展示例如下
                 * <pre><code>
                 * public String showApproverCaptionExt() {
                 * return "当前审核人";
                 * }
                 * </code></pre>
                 */
                showApproverCaptionExt():string;
                /**
                 * 列表展示当前处理人自定义显示内容
                 *
                 * @return 自定义的显示内容 Map<String, String> key: 单据id(转成String类型) value: 这张单据列表上字段显示的值
                 * <p>扩展示例如下
                 * <pre><code>
                 * public Map<String, String> showApproverExt() {
                 * // key: 单据id(转成String类型) value: 这张单据列表上字段显示的值
                 * Map<String, String> nodeMap = new HashMap<>(8);
                 * // 若需要查询 请在这里批量查询
                 * for (String billId : billIds) {
                 * // 请在这里构造nodeMap 自定义每一张单据当前处理人的值
                 * if ("1782516835053234176".equals(billId)) {
                 * nodeMap.put(billId, "测试人");
                 * }
                 * }
                 * }
                 * </code></pre>
                 */
                showApproverExt?(billIds:$.java.util.List):$.java.util.Map;
            }
            type IApproverSetting_T = IApproverSetting_S & IApproverSetting$;
            interface IApproverSetting extends IApproverSetting_T {
            }
            interface IPayeeBankInfoFilter_S {
            }
            interface IPayeeBankInfoFilter$ {
                /**
                 * 供应商收款账号过滤条件扩展插件
                 * @param view 单据页面view对象
                 * @return
                 * <p>扩展示例如下
                 * <pre><code>
                 *  @Override
                 * default void setIFilters(ListFilterParameter lfp, IFormView view ) {
                 *         //ListFilterParameter lfp 打开列表界面的过来参数
                 *         //view 编辑界面的view对象
                 *         DynamicObject bill=view.getModel().getDataEntity();
                 *         bill.getLong("id");
                 *         QFilter filter=new QFilter("id", QCP.in,100000L);
                 *         return filter;
                 *
                 *     }
                 * </code></pre>
                 */
                setIFilters?(lfp:$.kd.bos.list.ListFilterParameter,view:$.kd.bos.form.IFormView):void;
            }
            type IPayeeBankInfoFilter_T = IPayeeBankInfoFilter_S & IPayeeBankInfoFilter$;
            interface IPayeeBankInfoFilter extends IPayeeBankInfoFilter_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.payapply{
            interface ICasPayBillPayCallback_S {
            }
            interface ICasPayBillPayCallback$ {
                /**
                 * 开票回调后处理
                 * @param params 付款单付款之后调用付款申请单反写接口json
                 * @return
                 *
                 * <p>扩展示例如下
                 *     <pre><code>
                 *    package kd.fi.arapcommon.customer;
                 *
                 *    import kd.bos.dataentity.entity.DynamicObject;
                 *    import kd.bos.db.tx.TX;
                 *    import kd.bos.db.tx.TXHandle;
                 *    import kd.bos.orm.query.QCP;
                 *    import kd.bos.orm.query.QFilter;
                 *    import kd.bos.servicehelper.BusinessDataServiceHelper;
                 *    import kd.fi.arapcommon.consts.EntityConst;
                 *    import kd.sdk.fi.ap.extpoint.payapply.ICasPayBillPayCallback;
                 *
                 *    import java.util.List;
                 *    import java.util.Map;
                 *    import java.util.Set;
                 *    import java.util.stream.Collectors;
                 *
                 *    public class CasPayBillPayCallbaclImpl_Demo implements ICasPayBillPayCallback {
                 *        @Override
                 *        public void afterProcess(Object params) {
                 *            List<Map<String, Object>> paramList = (List<Map<String, Object>>) params;
                 *            Set<Long> sourceIds = paramList.stream().map(param -> (Long) param.get("sourcepk")).collect(Collectors.toSet());//源单id集合
                 *            //可能跨库操作，开启新事务处理
                 *            try (TXHandle tx = TX.requiresNew("CasPayBillPayCallback.afterProcess")) {
                 *                try {
                 *                    //获取付款申请单
                 *                    DynamicObject[] payApplyBills = BusinessDataServiceHelper.load(EntityConst.AP_PAYAPPLY, "id", new QFilter[]{new QFilter("id", QCP.in, sourceIds)});
                 *                    for (DynamicObject payApplyBill : payApplyBills){
                 *                        //二开操作....
                 *                    }
                 *                } catch(Exception ex) {
                 *                    tx.markRollback();
                 *                    throw ex;
                 *                }
                 *            }
                 *        }
                 *    }
                 *    </code></pre>
                 */
                afterProcess(params:any):void;
            }
            type ICasPayBillPayCallback_T = ICasPayBillPayCallback_S & ICasPayBillPayCallback$;
            interface ICasPayBillPayCallback extends ICasPayBillPayCallback_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.push{
            interface IPushAssignField_S {
            }
            interface IPushAssignField$ {
                /**
                 * @return key:下推单据目标单业务标识，如ap_finapbill value:需要支持的扩展字段 [{pushfinap=[salesman, salesorg], pushfinar=[purchaser, purorg]}]
                 *
                 * 样例：
                 * <pre><code>
                 * public class PushAssignFieldDemo implements IPushAssignField {
                 *     public Map<String, List<String>> getAfterPushAssignField() {
                 *         Map<String, List<String>> assignMap = new HashMap<>(2);
                 *         // 调用应付转付的API接口
                 *         IPushBillService pushBillService = ArApServiceAPIFactory.getPushBillService(ServiceNameEnum.FINAPTRANSFER.getValue());
                 *         List<String> apExtendField = new ArrayList<>(2);
                 *         apExtendField.add("purchaser"); // 采购员
                 *         apExtendField.add("purorg"); // 采购组织
                 *         // key 就是对应实现的ServiceName标识
                 *         assignMap.put(pushBillService.getServiceName(), apExtendField);
                 *         return assignMap;
                 *     }
                 * }
                 * </code></pre>
                 */
                getAfterPushAssignField():$.java.util.Map;
            }
            type IPushAssignField_T = IPushAssignField_S & IPushAssignField$;
            interface IPushAssignField extends IPushAssignField_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.settle{
            interface IPreSettleFilter_S {
            }
            interface IPreSettleFilter$ {
                /**
                 * @return 扩展增加的期初预付单过滤条件
                 * <p>
                 * <pre><code>
                 * @Override
                 * public QFilter getPaidExtFilter(IFormView view) {
                 * QFilter filter = null;
                 * IDataModel model = view.getModel();
                 * DynamicObject department = (DynamicObject) model.getValue("department");
                 * if (!ObjectUtils.isEmpty(department)) {
                 * filter = new QFilter("department_ext", QCP.equals, department.getLong("id"));
                 * }
                 * return filter;
                 * }
                 * </code></pre>
                 * </p>
                 */
                getPaidExtFilter?(view:$.kd.bos.form.IFormView):$.kd.bos.orm.query.QFilter;
                /**
                 * @return 扩展增加的付款单过滤条件
                 * <p>
                 * <pre><code>
                 * @Override
                 * public QFilter getPayExtFilter(IFormView view) {
                 * QFilter filter = null;
                 * IDataModel model = view.getModel();
                 * DynamicObject department = (DynamicObject) model.getValue("department");
                 * if (!ObjectUtils.isEmpty(department)) {
                 * filter = new QFilter("department_ext", QCP.equals, department.getLong("id"));
                 * }
                 * return filter;
                 * }
                 * </code></pre>
                 * </p>
                 */
                getPayExtFilter?(view:$.kd.bos.form.IFormView):$.kd.bos.orm.query.QFilter;
                /**
                 * @return 扩展增加的收款单过滤条件
                 * <p>
                 * <pre><code>
                 * @Override
                 * public QFilter getRecExtFilter(IFormView view) {
                 * QFilter filter = null;
                 * IDataModel model = view.getModel();
                 * DynamicObject department = (DynamicObject) model.getValue("department");
                 * if (!ObjectUtils.isEmpty(department)) {
                 * filter = new QFilter("department_ext", QCP.equals, department.getLong("id"));
                 * }
                 * return filter;
                 * }
                 * </code></pre>
                 * </p>
                 */
                getRecExtFilter?(view:$.kd.bos.form.IFormView):$.kd.bos.orm.query.QFilter;
                /**
                 * @return 扩展增加的期初预收单过滤条件
                 * <p>
                 * <pre><code>
                 * @Override
                 * public QFilter getReceivedExtFilter(IFormView view) {
                 * QFilter filter = null;
                 * IDataModel model = view.getModel();
                 * DynamicObject department = (DynamicObject) model.getValue("department");
                 * if (!ObjectUtils.isEmpty(department)) {
                 * filter = new QFilter("department_ext", QCP.equals, department.getLong("id"));
                 * }
                 * return filter;
                 * }
                 * </code></pre>
                 * </p>
                 */
                getReceivedExtFilter?(view:$.kd.bos.form.IFormView):$.kd.bos.orm.query.QFilter;
            }
            type IPreSettleFilter_T = IPreSettleFilter_S & IPreSettleFilter$;
            interface IPreSettleFilter extends IPreSettleFilter_T {
            }
            interface IAfterSettleProcess_S {
            }
            interface IAfterSettleProcess$ {
                /**
                 * 类描述:应收应付结算后处理扩展
                 * @param recordJson  SettleRecordVO 对象kd.fi.arapcommon.vo.SettleRecordVO的json
                 * @param schemeJson  SettleSchemeVO 对象kd.fi.arapcommon.vo.SettleSchemeVO的json
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    import com.alibaba.fastjson.JSONObject;
                 *    import kd.bos.db.tx.TX;
                 *    import kd.bos.db.tx.TXHandle;
                 *    import kd.fi.arapcommon.vo.SettleRecordVO;
                 *    import kd.fi.arapcommon.vo.SettleSchemeVO;
                 *    import kd.sdk.fi.ap.extpoint.settle.ArApAfterSettleProcess;
                 *
                 *    import java.util.ArrayList;
                 *    import java.util.List;
                 *
                 *    // 类描述:应收应付结算后处理扩展
                 *    public class AfterSettleDemoDemo implements ArApAfterSettleProcess {
                 *        public void afterProcess(String schemeJson, String recordJson) {
                 *            // Json转换成 SettleRecordVO 对象，里面存储着结算记录所有信息
                 *            List<JSONObject> jsonList = JSONObject.parseObject(recordJson, List.class);
                 *            List<SettleRecordVO> recordList = new ArrayList<>();
                 *            for (JSONObject json : jsonList) {
                 *                recordList.add(JSONObject.parseObject(json.toJSONString(), SettleRecordVO.class));
                 *            }
                 *            // Json转换成 SettleSchemeVO ，里面存储了进行结算反结算需要的逻辑参数
                 *            SettleSchemeVO scheme = JSONObject.parseObject(schemeJson, SettleSchemeVO.class);
                 *            // 可能跨库操作，开启新事务处理
                 *            try (TXHandle tx = TX.requiresNew("invokeAfterSettleCallback.afterProcess")) {
                 *                try {
                 *                    // 处理结算后处理，现场根据场景进行个性化开发
                 *                } catch(Exception ex) {
                 *                    tx.markRollback();
                 *                    throw ex;
                 *                }
                 *            }
                 *        }
                 *    }
                 *    </code></pre>
                 */
                afterProcess(schemeJson:string,recordJson:string):void;
            }
            type IAfterSettleProcess_T = IAfterSettleProcess_S & IAfterSettleProcess$;
            interface IAfterSettleProcess extends IAfterSettleProcess_T {
            }
            interface ISettleMatchExt_S {
            }
            interface ISettleMatchExt$ {
                /**
                 * 结算前匹配条件扩展
                 * @param mainBillSettleVoJson 主方结算信息
                 * @param asstBillSettleVoJson 辅方结算信息
                 * @param schemeJson 结算相关参数信息
                 * @return 匹配通过还是失败
                 * <p>
                 * <pre><code>
                 * package kd.fi.arapcommon.writeback;
                 *
                 * import com.alibaba.fastjson.JSONObject;
                 * import kd.fi.arapcommon.vo.BillSettleVO;
                 * import kd.fi.arapcommon.vo.SettleSchemeVO;
                 * import kd.sdk.fi.ap.extpoint.settle.ISettleMatchExt;
                 *
                 * public class settleExtMatchService implements ISettleMatchExt {
                 * @Override
                 * public boolean match(String mainBillSettleVoJson, String asstBillSettleVoJson, String schemeJson) {
                 * // Json转换成 BillSettleVO 对象，里面存储着主方，辅方结算所需信息
                 * BillSettleVO mainBillSettleVo = SerializationUtils.fromJsonString(mainBillSettleVoJson, BillSettleVO.class);
                 * BillSettleVO asstBillSettleVo = SerializationUtils.fromJsonString(asstBillSettleVoJson, BillSettleVO.class);
                 * // Json转换成 SettleSchemeVO ，里面存储了进行结算反结算需要的逻辑参数
                 * SettleSchemeVO scheme = SerializationUtils.fromJsonString(schemeJson, SettleSchemeVO.class);
                 * // 结算前数据匹配，现场根据场景进行个性化开发
                 * boolean result = false;
                 * return result;
                 * }
                 * }
                 *
                 * </code></pre>
                 * </p>
                 */
                match(mainBillSettleVoJson:string,asstBillSettleVoJson:string,schemeJson:string):boolean;
            }
            type ISettleMatchExt_T = ISettleMatchExt_S & ISettleMatchExt$;
            interface ISettleMatchExt extends ISettleMatchExt_T {
            }
            interface IPaySettleWarnFilter_S {
            }
            interface IPaySettleWarnFilter$ {
                /**
                 *  描述：预付款结算提醒-付款单
                 *  "预付款结算提醒过滤条件扩展
                 *  @param model 页面模型对象
                 *  @return 扩展增加的付款单过滤条件
                 * <p>
                 *     <pre><code>
                 *      @Override
                 *      public QFilter addPaidFilter(IDataModel iDataModel) {
                 *         Object asstacttype = iDataModel.getValue("asstacttype");
                 *         return new QFilter("itempayeetype", QCP.not_equals,asstacttype);
                 *      }
                 *      </code></pre>
                 *      </p>
                 */
                addPaidFilter(model:$.kd.bos.entity.datamodel.IDataModel):$.kd.bos.orm.query.QFilter;
                /**
                 *  描述：预付款结算提醒-付款单
                 *  "预付款结算提醒过滤条件扩展
                 *  @param model 页面模型对象
                 *  @return 扩展增加的付款单过滤条件
                 * <p>
                 *     <pre><code>
                 *      @Override
                 *      public QFilter addPayFilter(IDataModel iDataModel) {
                 *         Object asstacttype = iDataModel.getValue("asstacttype");
                 *         return new QFilter("itempayeetype", QCP.not_equals,asstacttype);
                 *      }
                 *     </code></pre>
                 *     </p>
                 */
                addPayFilter(model:$.kd.bos.entity.datamodel.IDataModel):$.kd.bos.orm.query.QFilter;
            }
            type IPaySettleWarnFilter_T = IPaySettleWarnFilter_S & IPaySettleWarnFilter$;
            interface IPaySettleWarnFilter extends IPaySettleWarnFilter_T {
            }
            interface IManualSettleCheck_S {
            }
            interface IManualSettleCheck$ {
                /**
                 *  手工结算点击结算按钮前的校验扩展
                 *  @param view  页面模型对象
                 *  @return   校验通过还是失败
                 * <p>
                 *      <pre><code>
                 *     package kd.fi.arapcommon.customer.ext;
                 *
                 *     import kd.bos.dataentity.entity.DynamicObject;
                 *     import kd.bos.dataentity.resource.ResManager;
                 *     import kd.bos.form.IFormView;
                 *     import kd.bos.form.control.EntryGrid;
                 *     import kd.sdk.fi.ap.extpoint.settle.IManualSettleCheck;
                 *
                 *     import java.util.HashSet;
                 *     import java.util.Set;
                 *
                 *     public class ManualSettleCheck_Demo implements IManualSettleCheck {
                 *         public boolean check(IFormView view) {
                 *             EntryGrid mainGrid = view.getControl("mainbill");//主方表格
                 *             int[] mainSelectRows = mainGrid.getSelectRows();//主方选中行
                 *             EntryGrid asstGrid = view.getControl("asstbill");//辅方表格
                 *             int[] asstSelectRows = asstGrid.getSelectRows();//辅方选中行
                 *
                 *             Set<String> mainContactSet = new HashSet<>(1);
                 *             for (int mainSelectRow : mainSelectRows) {
                 *                 DynamicObject mainRow = view.getModel().getEntryRowEntity("mainbill", mainSelectRow);
                 *                 mainContactSet.add(mainRow.getString("maincontact"));
                 *             }
                 *             if (mainContactSet.size() > 1){
                 *                 //ResManager.loadKDString()多语言支持
                 *                 view.showTipNotification(ResManager.loadKDString("主方的合同号必须相同", "ManualSettleCheck_Demo_1", "fi-arapcommon"));
                 *                 return false;
                 *             }
                 *
                 *             Set<String> asstContactSet = new HashSet<>(1);
                 *             for (int asstSelectRow : asstSelectRows) {
                 *                 DynamicObject asstRow = view.getModel().getEntryRowEntity("asstbill", asstSelectRow);
                 *                 asstContactSet.add(asstRow.getString("asstcontact"));
                 *             }
                 *             if (asstContactSet.size() > 1){
                 *                 //ResManager.loadKDString()多语言支持
                 *                 view.showTipNotification(ResManager.loadKDString("辅方的合同号必须相同", "ManualSettleCheck_Demo_2", "fi-arapcommon"));
                 *                 return false;
                 *             }
                 *
                 *             if(mainContactSet.size() == 1 && asstContactSet.size() == 1 &&
                 *                     mainContactSet.iterator().next().equals(asstContactSet.iterator().next())){
                 *                 return true;
                 *             }else{
                 *                 //ResManager.loadKDString()多语言支持
                 *                 view.showTipNotification(ResManager.loadKDString("主方和辅方的合同号必须一致才能结算", "ManualSettleCheck_Demo_3", "fi-arapcommon"));
                 *                 return false;
                 *             }
                 *
                 *         }
                 *     }
                 *      </code></pre>
                 *      </p>
                 */
                check(view:$.kd.bos.form.IFormView):boolean;
            }
            type IManualSettleCheck_T = IManualSettleCheck_S & IManualSettleCheck$;
            interface IManualSettleCheck extends IManualSettleCheck_T {
            }
            interface IGetMaxBookDate_S {
            }
            interface IGetMaxBookDate$ {
                /**
                 * 类描述:获取应付结算记录主辅方最大记账日期扩展 <br/>
                 * 主要用于应付结算记录列表，修改结算日期时，校验结算日期是否晚于主辅方最大记账日期。 <br/>
                 * 若不需要此校验，可实现此接口扩展，直接返回入参 maxDate;<br/>
                 * 若不扩展此接口或者返回null，则继续保留标品校验逻辑  <br/>
                 *
                 * @param billIdsMap ( Map < String, Set < Long > >) -- key : 单据类型：ar_finarbill/ap_finapbill/cas_recbill/cas_paybill<br/>
                 *                   -- value：对应单据类型的ID集合  <br/>
                 * @param maxDate    SettleSchemeVO java.util.Date <br/>
                 * <p>扩展示例如下
                 * <pre><code>
                 * public Date getMaxBookDate(Map<String,Set<Long>> billIdsMap,Date maxDate){
                 *     if(billIdsMap.get("ar_finarbill") != null){
                 *         //存在财务应收单
                 *         DynamicObjectCollection finArBills = QueryServiceHelper.query("ar_finarbill",
                 *             "id,bookdate",
                 *             new QFilter[]{new QFilter("id",QCP.in,billIdsMap.get("ar_finarbill"))},"bookdate desc",1);
                 *         if(finArBills.size() > 0){
                 *             Date bookDate=finArBills.get(0).getDate("bookdate");
                 *             if(bookDate != null){
                 *                 maxDate=maxDate.after(bookDate) ? maxDate : bookDate;
                 *             }
                 *         }
                 *    }
                 *    if(billIdsMap.get("ap_finapbill") != null){
                 *        //存在财务应付单
                 *        DynamicObjectCollection finApBills = QueryServiceHelper.query("ap_finapbill",
                 *        "id,bookdate",
                 *        new QFilter[]{new QFilter("id",QCP.in,billIdsMap.get("ap_finapbill"))},"bookdate desc",1);
                 *        if(finApBills.size() > 0){
                 *            Date bookDate=finApBills.get(0).getDate("bookdate");
                 *            if(bookDate != null){
                 *                maxDate=maxDate.after(bookDate) ? maxDate : bookDate;
                 *            }
                 *        }
                 *    }
                 *    return maxDate;
                 * }
                 * </code></pre>
                 * </p>
                 */
                getMaxBookDate(billIdsMap:$.java.util.Map,maxDate:Date):Date;
            }
            type IGetMaxBookDate_T = IGetMaxBookDate_S & IGetMaxBookDate$;
            interface IGetMaxBookDate extends IGetMaxBookDate_T {
            }
        }
        namespace kd.sdk.fi.ap.extpoint.woff{
            interface IAfterWoffProcess_S {
            }
            interface IAfterWoffProcess$ {
                /**
                 * @param isWoff true代表冲回，false代表取消冲回
                 * @param woffMode 冲回模式，WoffModeEnum.value
                 * @param finBillIds 触发单到冲回的财务单ID
                 * @param srcBusBillIds 最初被冲回的源暂估单ID
                 * @param woffBillIds 生成的冲回单ID
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    public class AfterWoffProcessDemo implements IAfterWoffProcess {
                 *    @Override
                 *    public void afterProcess(boolean isWoff, String woffMode, Set<Long> finBillIds, Set<Long> srcBusBillIds, List<Object> woffBillIds) {
                 *        // 非核心单据冲回直接返回不处理
                 *        if(!WoffModeEnum.COREBILL.getValue().equals(woffMode))  return;
                 *        // 不跨库，需要使用TX.required和原有事务保持一致；若需要跨库操作，需要开启新事务处理TX.requiresNew；
                 *        try (TXHandle tx = TX.required("invokeAfterWoffProcess.afterWoffProcess")) {
                 *            try {
                 *                // 处理冲回后处理，现场根据场景进行个性化开发
                 *                if(isWoff) {
                 *                    // 冲回扩展逻辑
                 *                } else {
                 *                    // 取消冲回扩展逻辑
                 *                }
                 *            } catch (Exception ex) {
                 *                tx.markRollback();
                 *                throw ex;
                 *            }
                 *       }
                 *    }
                 *    }
                 *    </code></pre>
                 */
                afterProcess(isWoff:boolean,woffMode:string,finBillIds:$.java.util.Set,srcBusBillIds:$.java.util.Set,woffBillIds:$.java.util.List):void;
            }
            type IAfterWoffProcess_T = IAfterWoffProcess_S & IAfterWoffProcess$;
            interface IAfterWoffProcess extends IAfterWoffProcess_T {
            }
            interface IWoffMatchExt_S {
            }
            interface IWoffMatchExt$ {
                /**
                 * 对冲回匹配条件追加个性化匹配条件，支持表头和物料明细属性，物料明细属性请携带分录标识
                 * @param woffMode 冲回模式，WoffModeEnum.value
                 * @param finEntityKey 财务单单据标识，可用于应收应付区分及标识处理
                 * @return <财务单字段标识, 暂估单字段标识>
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    public class WoffMatchExtDemo implements IWoffMatchExt {
                 *    @Override
                 *    public Map<String, String> moreMatchField(String woffMode, String finEntityKey) {
                 *        Map<String, String> matchField = new HashMap<>(2);
                 *        // 核心单据冲回追加匹配条件
                 *        if(WoffModeEnum.COREBILL.getValue().equals(woffMode)) {
                 *            if("ap_finapbill".equals(finEntityKey)) {
                 *                // 若财务应收应付单字段标识不同请区分处理，物料明细属性请携带分录标识
                 *                matchField.put("paycond", "paycond");// 付款条件
                 *                matchField.put("detailentry.tracknumber", "entry.tracknumber");// 跟踪号
                 *            }
                 *        }
                 *        return matchField;
                 *    }
                 *    }
                 *    </code></pre>
                 */
                moreMatchField(woffMode:string,finEntityKey:string):$.java.util.Map;
            }
            type IWoffMatchExt_T = IWoffMatchExt_S & IWoffMatchExt$;
            interface IWoffMatchExt extends IWoffMatchExt_T {
            }
        }
        namespace kd.sdk.fi.ar.extpoint.invoice{
            interface IInvIssueCallback_S {
            }
            interface IInvIssueCallback$ {
                /**
                 *  开票回调后处理
                 *  @param callBackVoJson 对象kd.imc.bdm.common.dto.FiBotpCallBackVo.class的json
                 *  @return
                 *
                 *  <p>扩展示例如下
                 * 	 <pre><code>
                 * 	 import java.util.*
                 * 	 import java.util.stream.Collectors;
                 * 	 import com.alibaba.fastjson.JSONObject;
                 *
                 * 	 import kd.bos.db.tx.TX;
                 * 	 import kd.bos.db.tx.TXHandle;
                 * 	 import kd.bos.servicehelper.botp.BFTrackerServiceHelper;
                 * 	 import kd.fi.arapcommon.consts.EntityConst;
                 * 	 import kd.fi.arapcommon.util.EmptyUtils;
                 * 	 import kd.imc.bdm.common.dto.FiBotpCallBackArBillVo;
                 * 	 import kd.imc.bdm.common.dto.FiBotpCallBackVo;
                 * 	 import kd.sdk.fi.ar.extpoint.invoice.IInvIssueCallback;
                 *
                 * 	 public class InvIssueCallbackImpl_Demo implements IInvIssueCallback {
                 *
                 * 		public void afterProcess(String callBackVoJson) {
                 * 			FiBotpCallBackVo callBackVo = JSONObject.parseObject(callBackVoJson, FiBotpCallBackVo.class);
                 * 			String invoiceCode = callBackVo.getInvoiceCode(); //发票代码
                 * 			String invoiceNo = callBackVo.getInvoiceNo(); //发票号码
                 * 			List<FiBotpCallBackArBillVo> arBillVos = callBackVo.getArs(); //应收单据集合
                 * 			List<Long> finPks = arBillVos.stream().map(FiBotpCallBackArBillVo::getArBillPk).collect(Collectors.toList());
                 * 			//可能跨库操作，开启新事务处理
                 * 			try (TXHandle tx = TX.requiresNew("InvIssueCallback.afterProcess")) {
                 * 			    try {
                 * 			    	//找上游单据
                 * 			    	Map<String, HashSet<Long>> linkBills = BFTrackerServiceHelper.findSourceBills(EntityConst.ENTITY_FINARBILL, finPks.toArray(new Long[]{}));
                 * 			    	//上游单据
                 * 			    	Set<Long> srcPks = linkBills.get("sm_xxxbill");
                 * 			    	if (EmptyUtils.isNotEmpty(srcPks)) {
                 * 			    		// 查询上游单据，并更新上游单据
                 * 			    		// ...
                 * 			    	}
                 * 			    } catch(Exception ex) {
                 * 			        tx.markRollback();
                 * 			        throw ex;
                 * 			    }
                 * 			}
                 * 		}
                 * 	}
                 * 	</code></pre>
                 */
                afterProcess(callBackVoJson:string):void;
            }
            type IInvIssueCallback_T = IInvIssueCallback_S & IInvIssueCallback$;
            interface IInvIssueCallback extends IInvIssueCallback_T {
            }
        }
        namespace kd.sdk.fi.ar.extpoint.plan{
            interface IPlanRowSplit_S {
            }
            interface IPlanRowSplit$ {
                /**
                 *  计划行拆分扩展点，支持可覆盖
                 *  @param view 表单视图模型
                 *
                 *  <p>扩展示例如下
                 *  <pre><code>
                 * 	 public class PlanRowSplitImpl_Demo implements IPlanRowSplit {
                 *
                 * 		public void splitPlanEntry(IFormView view) {
                 * 			IDataModel m = view.getModel();
                 * 	        m.beginInit();
                 * 	        DynamicObject dataEntity = m.getDataEntity(true);//获取页面模型的整个值对象
                 * 	        String entityName = dataEntity.getDataEntityType().getName();//单据标识
                 * 	        BillModel bm = BillModelFactory.getModel(entityName);//单据字段标识对象
                 *
                 * 	        //1、删除计划行的所有数据
                 * 	        m.deleteEntryData(bm.P_ENTRY);
                 *
                 * 	        //2、根据业务处理计划行
                 * 	        for (int i = 0; i < 2; i++) {
                 * 	        	//创建计划行
                 * 	        	int iRow = m.createNewEntryRow(bm.P_ENTRY, i, null);
                 * 	        	//计划行赋值
                 * 	        	m.setValue(bm.P_PLANDUEDATE, m.getValue(bm.HEAD_DUEDATE), iRow);
                 * 	        	m.setValue(bm.P_PLANSETTLETYPE, m.getValue(bm.HEAD_SETTLEMENTTYPE), iRow);
                 * 	        	BigDecimal priceTaxTotal = new BigDecimal("100");
                 * 	        	m.setValue(bm.P_PLANPRICETAX, priceTaxTotal, iRow);
                 * 	        	// ...
                 * 			}
                 * 			m.endInit();
                 * 			view.updateView(bm.P_ENTRY);
                 * 		}
                 * 	}
                 *     </code></pre>
                 */
                splitPlanEntry(view:$.kd.bos.form.IFormView):void;
            }
            type IPlanRowSplit_T = IPlanRowSplit_S & IPlanRowSplit$;
            interface IPlanRowSplit extends IPlanRowSplit_T {
            }
        }
        namespace kd.sdk.fi.ar.extpoint.settle{
            interface IRecSettleWarnFilter_S {
            }
            interface IRecSettleWarnFilter$ {
                /**
                 *  描述：预收款结算提醒-收款单
                 *  "预收款结算提醒过滤条件扩展
                 *  @param model 页面模型对象
                 *  @return 扩展增加的付款单过滤条件
                 * <p>
                 *     <pre><code>
                 *      @Override
                 *      public QFilter addRecFilter(IDataModel iDataModel) {
                 *         Object asstacttype = iDataModel.getValue("asstacttype");
                 *         return new QFilter("itempayeetype", QCP.not_equals,asstacttype);
                 *      }
                 *     </code></pre>
                 *     </p>
                 */
                addRecFilter(model:$.kd.bos.entity.datamodel.IDataModel):$.kd.bos.orm.query.QFilter;
                /**
                 *  描述：预收款结算提醒-期初预收单
                 *  "预收款结算提醒过滤条件扩展
                 *  @param model 页面模型对象
                 *  @return 扩展增加的付款单过滤条件
                 * <p>
                 *     <pre><code>
                 *      @Override
                 *      public QFilter addReceiveFilter(IDataModel iDataModel) {
                 *         Object asstacttype = iDataModel.getValue("asstacttype");
                 *         return new QFilter("itempayeetype", QCP.not_equals,asstacttype);
                 *      }
                 *      </code></pre>
                 *      </p>
                 */
                addReceiveFilter(model:$.kd.bos.entity.datamodel.IDataModel):$.kd.bos.orm.query.QFilter;
            }
            type IRecSettleWarnFilter_T = IRecSettleWarnFilter_S & IRecSettleWarnFilter$;
            interface IRecSettleWarnFilter extends IRecSettleWarnFilter_T {
            }
        }
        namespace kd.sdk.fi.arapcommon.helper{
            interface SettleServiceSDKHelper_S {
                /**
                 * 应付冲应收指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                apArAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应付冲应收非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                apArNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应付付款指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                apPayAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应付付款非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                apPayNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应付红蓝对冲指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                apSelfAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应付红蓝对冲非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                apSelfNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应收冲应付指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                arApAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应收冲应付非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                arApNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应收收款指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                arRecAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应收收款非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                arRecNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应收红蓝对冲指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                arSelfAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 应收红蓝对冲非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                arSelfNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 付款冲收款指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                payRecAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 付款冲收款非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                payRecNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 付款红蓝对冲指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                paySelfAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 付款红蓝对冲非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                paySelfNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 收款冲付款指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                recPayAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 收款冲付款非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                recPayNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 收款红蓝对冲指定金额结算
                 * @param assignSettleParam  指定结算参数
                 * @return 结算返回结果
                 */
                recSelfAssignSettle(assignSettleParam:kd.sdk.fi.arapcommon.param.AssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
                /**
                 * 收款红蓝对冲非指定金额结算
                 * @param noAssignSettleParam  非指定结算参数
                 * @return 结算返回结果
                 */
                recSelfNoAssignSettle(noAssignSettleParam:kd.sdk.fi.arapcommon.param.NoAssignSettleParam):kd.sdk.fi.arapcommon.param.SettleResult;
            }
            interface SettleServiceSDKHelper_C extends SettleServiceSDKHelper_S {
                new():SettleServiceSDKHelper;
            }
            interface SettleServiceSDKHelper$ {
            }
            type SettleServiceSDKHelper_T = SettleServiceSDKHelper_S & SettleServiceSDKHelper$;
            interface SettleServiceSDKHelper extends SettleServiceSDKHelper_T {
            }
            interface ReportQuerySDKHelper_S {
                apAcctageAccountReportQuery(param:kd.sdk.fi.arapcommon.param.ReportQueryParam):$.kd.bos.algo.DataSet;
                apDetailReportQuery(param:kd.sdk.fi.arapcommon.param.ReportQueryParam):$.kd.bos.algo.DataSet;
                apSumReportQuery(param:kd.sdk.fi.arapcommon.param.ReportQueryParam):$.kd.bos.algo.DataSet;
                arAcctageAccountReportQuery(param:kd.sdk.fi.arapcommon.param.ReportQueryParam):$.kd.bos.algo.DataSet;
                arDetailReportQuery(param:kd.sdk.fi.arapcommon.param.ReportQueryParam):$.kd.bos.algo.DataSet;
                arSumReportQuery(param:kd.sdk.fi.arapcommon.param.ReportQueryParam):$.kd.bos.algo.DataSet;
            }
            interface ReportQuerySDKHelper_C extends ReportQuerySDKHelper_S {
                new():ReportQuerySDKHelper;
            }
            interface ReportQuerySDKHelper$ {
            }
            type ReportQuerySDKHelper_T = ReportQuerySDKHelper_S & ReportQuerySDKHelper$;
            interface ReportQuerySDKHelper extends ReportQuerySDKHelper_T {
            }
        }
        namespace kd.sdk.fi.arapcommon.param{
            interface NoAssignSettleParam_S {
            }
            type NoAssignSettleParam_ST = $.java.io.Serializable & BaseSettleParam_S & NoAssignSettleParam_S;
            interface NoAssignSettleParam_C extends NoAssignSettleParam_ST {
                new():NoAssignSettleParam;
                /**
                 * 构造方法
                 * @param orgId  组织id
                 * @param settleType   结算方式
                 */
                new(orgId:long,settleType:string):NoAssignSettleParam;
            }
            interface NoAssignSettleParam$ {
                getAsstBillIds():$.java.util.Set;
                getMainBillIds():$.java.util.Set;
                isMainOp():boolean;
                isOnlyByBotp():boolean;
                setAsstBillIds(asstBillIds:$.java.util.Set):void;
                setMainBillIds(mainBillIds:$.java.util.Set):void;
                setMainOp(mainOp:boolean):void;
                setOnlyByBotp(onlyByBotp:boolean):void;
            }
            type NoAssignSettleParam_T = BaseSettleParam & $.java.io.Serializable & NoAssignSettleParam_S & NoAssignSettleParam$;
            interface NoAssignSettleParam extends NoAssignSettleParam_T {
            }
            interface AssignSettleParam_S {
            }
            type AssignSettleParam_ST = BaseSettleParam_S & AssignSettleParam_S;
            interface AssignSettleParam_C extends AssignSettleParam_ST {
                new():AssignSettleParam;
                /**
                 * 构造方法
                 * @param orgId  组织id
                 * @param settleType  结算方式
                 * @param settleDetailType  明细结算方式（按单据头或者按分录）
                 */
                new(orgId:long,settleType:string,settleDetailType:string):AssignSettleParam;
            }
            interface AssignSettleParam$ {
                getAsstDetailParamList():$.java.util.List;
                getMainDetailParamList():$.java.util.List;
                getSettleDetailType():string;
                setAsstDetailParamList(asstDetailParamList:$.java.util.List):void;
                setMainDetailParamList(mainDetailParamList:$.java.util.List):this;
                setSettleDetailType(settleDetailType:string):void;
            }
            type AssignSettleParam_T = BaseSettleParam & AssignSettleParam_S & AssignSettleParam$;
            interface AssignSettleParam extends AssignSettleParam_T {
            }
            interface BaseSettleParam_S {
            }
            type BaseSettleParam_ST = $.java.io.Serializable & BaseSettleParam_S;
            interface BaseSettleParam_C extends BaseSettleParam_ST {
                new():BaseSettleParam;
            }
            interface BaseSettleParam$ {
                getAsstEntity():string;
                getMainEntity():string;
                getMatchServiceClass():string;
                getOrgId():long;
                getSettleDate():Date;
                getSettleType():string;
                isClaim():boolean;
                isConfirmLogo():boolean;
                isContainPre():boolean;
                isDiffCurrencySettle():boolean;
                isLockWait():boolean;
                isMatchDiffCurrency():boolean;
                isNotNeedLock():boolean;
                isOnlyByConBill():boolean;
                isOnlyByCoreBill():boolean;
                isRefundAndRenote():boolean;
                isRefundByBotp():boolean;
                setAsstEntity(asstEntity:string):void;
                setClaim(claim:boolean):void;
                setConfirmLogo(confirmLogo:boolean):void;
                setContainPre(containPre:boolean):void;
                setDiffCurrencySettle(diffCurrencySettle:boolean):void;
                setLockWait(lockWait:boolean):void;
                setMainEntity(mainEntity:string):void;
                setMatchDiffCurrency(matchDiffCurrency:boolean):void;
                setMatchServiceClass(matchServiceClass:string):void;
                setNotNeedLock(notNeedLock:boolean):void;
                setOnlyByConBill(onlyByConBill:boolean):void;
                setOnlyByCoreBill(onlyByCoreBill:boolean):void;
                setOrgId(orgId:long):void;
                setRefundAndRenote(refundAndRenote:boolean):void;
                setRefundByBotp(refundByBotp:boolean):void;
                setSettleDate(settleDate:Date):void;
                setSettleType(settleType:string):void;
            }
            type BaseSettleParam_T = $.java.io.Serializable & BaseSettleParam_S & BaseSettleParam$;
            interface BaseSettleParam extends BaseSettleParam_T {
            }
            interface ReportQueryParam_S {
            }
            type ReportQueryParam_ST = $.java.io.Serializable & ReportQueryParam_S;
            interface ReportQueryParam_C extends ReportQueryParam_ST {
                new():ReportQueryParam;
            }
            interface ReportQueryParam$ {
                getCommonFs():$.kd.bos.orm.query.QFilter;
                getConfigId():long;
                getCustomParam():$.java.util.Map;
                getPrincipleProcessParam():$.java.util.Map;
                getShowKeyCols():$.java.util.Set;
                getShowQtyCols():$.java.util.Set;
                getSumKeyCols():$.java.util.Set;
                isShowTotalQty():boolean;
                setCommonFs(commonFs:$.kd.bos.orm.query.QFilter):void;
                setConfigId(configId:long):void;
                setCustomParam(customParam:$.java.util.Map):void;
                setPrincipleProcessParam(principleProcessParam:$.java.util.Map):void;
                setShowKeyCols(showKeyCols:$.java.util.Set):void;
                setShowQtyCols(showQtyCols:$.java.util.Set):void;
                setShowTotalQty(showTotalQty:boolean):void;
                setSumKeyCols(sumKeyCols:$.java.util.Set):void;
            }
            type ReportQueryParam_T = $.java.io.Serializable & ReportQueryParam_S & ReportQueryParam$;
            interface ReportQueryParam extends ReportQueryParam_T {
            }
            interface SettleResult_S {
            }
            type SettleResult_ST = $.java.io.Serializable & SettleResult_S;
            interface SettleResult_C extends SettleResult_ST {
                new():SettleResult;
            }
            interface SettleResult$ {
                getData():any;
                getSettleRecordPKs():$.java.util.List;
                setData(data:any):void;
                setSettleRecordPKs(settleRecordPKs:$.java.util.List):void;
            }
            type SettleResult_T = $.java.io.Serializable & SettleResult_S & SettleResult$;
            interface SettleResult extends SettleResult_T {
            }
        }
        namespace kd.sdk.fi.bd.service.balance{
            interface RecalLogParam_S {
            }
            type RecalLogParam_ST = $.java.io.Serializable & RecalLogParam_S;
            interface RecalLogParam_C extends RecalLogParam_ST {
                new():RecalLogParam;
            }
            interface RecalLogParam$ {
                getBookTypeIds():long[];
                getOrgIds():long[];
                setBookTypeIds(bookTypeIds:long[]):void;
                setOrgIds(orgIds:long[]):void;
            }
            type RecalLogParam_T = $.java.io.Serializable & RecalLogParam_S & RecalLogParam$;
            interface RecalLogParam extends RecalLogParam_T {
            }
            interface QueryParam_S {
            }
            type QueryParam_ST = $.java.io.Serializable & QueryParam_S;
            interface QueryParam_C extends QueryParam_ST {
                new():QueryParam;
            }
            interface QueryParam$ {
                getAccountFilter():$.kd.bos.orm.query.QFilter;
                getAccountVersionPeriodId():long;
                getAssGrpIds():$.java.util.Set;
                getCurrencyIds():long[];
                getCustomFilter():$.java.util.List;
                getMeasureUnitIds():long[];
                isAddAmountFilter():boolean;
                isOnlyLeafAcctBal():boolean;
                isSpecialAccount():boolean;
                isSubstractPL():boolean;
                isSumAssgrp():boolean;
                isZeroAmtNoDisplay():boolean;
                isZeroBalNoDisplay():boolean;
                setAccountFilter(accountFilter:$.kd.bos.orm.query.QFilter):void;
                setAccountVersionPeriodId(accountVersionPeriodId:long):void;
                setAddAmountFilter(isAddAmountFilter:boolean):void;
                setAssGrpIds(assGrpIds:$.java.util.Set):void;
                setCurrencyIds(currencyIds:long[]):void;
                setCustomFilter(customFilter:$.java.util.List):void;
                setMeasureUnitIds(measureUnitIds:long[]):void;
                setOnlyLeafAcctBal(isOnlyLeafAcctBal:boolean):void;
                setSpecialAccount(isSpecialAccount:boolean):void;
                setSubstractPL(isSubstractPL:boolean):void;
                setSumAssgrp(sumAssgrp:boolean):void;
                setZeroAmtNoDisplay(zeroAmtNoDisplay:boolean):void;
                setZeroBalNoDisplay(zeroBalNoDisplay:boolean):void;
            }
            type QueryParam_T = $.java.io.Serializable & QueryParam_S & QueryParam$;
            interface QueryParam extends QueryParam_T {
            }
            interface BalanceExecutorSdk_S {
                /**
                 * 根据参数查询科目余额表,返回不限制数据量的DataSet
                 *
                 * @param selector 需要查询的字段 例："org,booktype,account,assgrp,endlocal"  如果查询字段包含period则只查询条件范围内有发生额的科目余额数据
                 *
                 * @param orgIds 核算组织id
                 * @param bookTypeId 账簿类型id
                 * @param accountTableId 科目表id
                 * @param beginPeriodId 查询的开始期间
                 * @param endPeriodId 查询的结束期间 查询一个期间的数据则与开始期间一致即可
                 * @param param 其他查询参数
                 *
                 * @return 科目余额Dataset数据
                 *
                 * <pre> <code>
                 * 调用示例:
                 *
                 * 构造相关参数
                 *  String selector="org,booktype,account,assgrp,endlocal";
                 *  Long[] orgIds=new Long[]{0001};
                 *  long bookTypeId =1L;
                 *  long accountTableId = 1L;
                 *  long beginPeriodId = 120220080L;
                 *  long endPeriodId =120220080L;
                 *  QueryParam param =new QueryParam();
                 *  调用接口查询 并对返回的DataSet进行处理
                 *  try(DataSet ds= kd.sdk.fi.bd.service.balance.BalanceExecutorSdk.getBalance(selector,orgIds,bookTypeId,accountTableId,beginPeriodId,endPeriodId,param)){
                 *     for(Row row:ds){
                 *         BigDecimal endlocal=row.getBigDecimal("endlocal");
                 *         ...
                 *     }
                 *  };
                 *
                 * </code></pre>
                 */
                getBalance(selector:string,orgIds:long[],bookTypeId:long,accountTableId:long,beginPeriodId:long,endPeriodId:long,param:QueryParam):$.kd.bos.algo.DataSet;
                /**
                 * 根据参数查询科目余额表,返回不限制数据量的DataSet
                 *
                 * @param selector 需要查询的字段 例："org,booktype,account,assgrp,endlocal"  如果查询字段包含period则只查询条件范围内有发生额的科目余额数据
                 *
                 * @param orgIds 核算组织id
                 * @param bookTypeId 账簿类型id
                 * @param accountTableId 科目表id
                 * @param beginPeriodId 查询的开始期间
                 * @param endPeriodId 查询的结束期间 查询一个期间的数据则与开始期间一致即可
                 * @param param 其他查询参数
                 * @param flexFilter 核算维度过滤条件：只要指定了核算维度过滤条件，构建相应的inner join过滤条件
                 *
                 * @return 科目余额Dataset数据
                 *
                 * <pre> <code>
                 * 调用示例:
                 *
                 * 构造相关参数
                 * String selector = "account,beginlocal,debitlocal,creditlocal,endlocal";
                 * long bookTypeId = 237528347981256704L;
                 * long accountTableId = 1974724534976457728L;
                 * long beginPeriodId = 120240010L;
                 * long endPeriodId = 120240010L;
                 * long orgid = 1974719168960077824L;//少林
                 * Long[] orgIds = new Long[]{orgid};
                 * long currencyId = 1L;//币别
                 * Long[] currencyIds = new Long[]{currencyId};
                 * QueryParam querParam = new QueryParam();
                 * // 不传，查所有币别
                 * querParam.setCurrencyIds(currencyIds);
                 * Map<String, Set<Object>> flexFilter = new HashMap<>(8);
                 * flexFilter.put("f0001", new HashSet<Object>(){{add(1401309412475298816L);}});
                 * flexFilter.put("f000005", new HashSet<Object>());
                 * flexFilter.put("f000099", new HashSet<Object>(){{add("123");add("456");}});
                 *  调用接口查询 并对返回的DataSet进行处理
                 *  try(DataSet ds= kd.sdk.fi.bd.service.balance.BalanceExecutorSdk.getBalanceWithAssistFilter
                 *  (selector,orgIds,bookTypeId,accountTableId,beginPeriodId,endPeriodId,param,flexFilter)){
                 *     for(Row row:ds){
                 *         BigDecimal endlocal=row.getBigDecimal("endlocal");
                 *         ...
                 *     }
                 *  };
                 *
                 * </code></pre>
                 */
                getBalanceWithAssistFilter(selector:string,orgIds:long[],bookTypeId:long,accountTableId:long,beginPeriodId:long,endPeriodId:long,param:QueryParam,flexFilter:$.java.util.Map):$.kd.bos.algo.DataSet;
                /**
                 * @Description 重算余额和现金流量日志
                 * @param param 查询参数
                 *
                 * <pre> <code>
                 * 调用示例:
                 *  RecalLogParam recalLogParam = new RecalLogParam();
                 *  recalLogParam.setOrgIds(new long[]{1630503722540880896L});
                 *  BalanceExecutorSdk.recalBalanceAndCashflowLog(recalLogParam);
                 * </code></pre>
                 */
                recalBalanceAndCashflowLog(param:RecalLogParam):$.kd.bos.algo.DataSet;
            }
            interface BalanceExecutorSdk_C extends BalanceExecutorSdk_S {
                new():BalanceExecutorSdk;
            }
            interface BalanceExecutorSdk$ {
            }
            type BalanceExecutorSdk_T = BalanceExecutorSdk_S & BalanceExecutorSdk$;
            interface BalanceExecutorSdk extends BalanceExecutorSdk_T {
            }
        }
        namespace kd.sdk.fi.bd.service.cdc{
            interface CDCServiceGLIntegratorSDK_S {
                /**
                 * 触发凭证摘要集成
                 * <p>
                 * 凭证更新事务提交后，请求同步ES，内部异步实现，无需关注结果
                 *
                 * @param operationType 变动类型
                 * @param voucherIdColl 凭证ID集合
                 * @return 触发成功？
                 */
                raiseCDCEvent(operationType:CDCRecOperationTypeEnum,voucherIdColl:$.java.util.Collection):boolean;
            }
            interface CDCServiceGLIntegratorSDK_C extends CDCServiceGLIntegratorSDK_S {
                new():CDCServiceGLIntegratorSDK;
            }
            interface CDCServiceGLIntegratorSDK$ {
                /**
                 * 注册凭证摘要变动记录
                 * <p>
                 * 凭证更新事务中,凭证保存执行完毕，调用同步注册凭证变动记录
                 *
                 * @param operationType 变动类型
                 * @param voucherIdColl 凭证ID集合
                 * @return 注册成功？
                 */
                registerCDCChangedRecord(operationType:CDCRecOperationTypeEnum,voucherIdColl:$.java.util.Collection):boolean;
            }
            type CDCServiceGLIntegratorSDK_T = CDCServiceGLIntegratorSDK_S & CDCServiceGLIntegratorSDK$;
            interface CDCServiceGLIntegratorSDK extends CDCServiceGLIntegratorSDK_T {
            }
            enum CDCRecOperationTypeEnum {
                New,
                Update,
                Delete
            }
        }
        namespace kd.sdk.fi.cal.extpoint.bal{
            interface CalBalDataSDK_S {
                getBalDataForCache(qFilter:$.kd.bos.orm.query.QFilter):string;
            }
            interface CalBalDataSDK_C extends CalBalDataSDK_S {
                new():CalBalDataSDK;
            }
            interface CalBalDataSDK$ {
            }
            type CalBalDataSDK_T = CalBalDataSDK_S & CalBalDataSDK$;
            interface CalBalDataSDK extends CalBalDataSDK_T {
            }
        }
        namespace kd.sdk.fi.cal.extpoint.calintime{
            interface ICalMoveGroupCost_S {
            }
            interface ICalMoveGroupCost$ {
                /**
                 *  @function 缓冲池计算实时移动成组成本加价处理
                 *  @param acctRecIdEleCostMap
                 *  分项：key：成本账簿ID+ "|" + 成本记录分录id + "|" + 成本子要素ID
                 *  不分项：key：成本账簿ID+ "|" + 成本记录分录id + "|" + “materialcost”（材料成本）
                 *   或 “processcost”（加工费） 或  “fee”（费用） 或 “manufacturecost”（制造费用） 或  “RESOURCE”（资源费用）
                 *  value：对应金额
                 *  @param entity 库存业务对象编码
                 *  @param bizBillIds 业务单据id
                 *  @return   void
                 * <pre><code>
                 *  package kd.sdk.fi.cal.extpoint.calintime;
                 *
                 *  import kd.bos.algo.DataSet;
                 *  import kd.bos.algo.Row;
                 *  import kd.bos.orm.query.QCP;
                 *  import kd.bos.orm.query.QFilter;
                 *  import kd.bos.servicehelper.QueryServiceHelper;
                 *
                 *  import java.math.BigDecimal;
                 *  import java.util.HashSet;
                 *  import java.util.Map;
                 *  import java.util.Set;
                 *
                 *  public class CalMoveGroupCostTest implements ICalMoveGroupCost{
                 *      @Override
                 *      public void doCalGroupCostEx(Map<String, BigDecimal> acctRecIdEleCostMap, String entity, Set<Long> bizBillIds) {
                 *          String splitStr = "|";
                 *          DataSet costRecordDs = getCostRecordDs(acctRecIdEleCostMap, bizBillIds);
                 *          for (Row row : costRecordDs) {
                 *              Long costAcctId = row.getLong("costaccount");
                 *              Long costRecEid = row.getLong("entryid");
                 *              Long costSubelEment = row.getLong("costsubelement");
                 *              //key：成本账簿ID+ "|" + 成本记录分录id + "|" + 成本子要素ID，value：对应金额
                 *              String key;
                 *              //成本账簿-核算政策-启用分项结转
                 *              if(row.getBoolean("calbycostelement")){
                 *                  key = costAcctId + splitStr + costRecEid + splitStr + costSubelEment;
                 *              }else {
                 *                  //不分项材料成本单价增加一块钱 材料成本（materialcost）加工费（processcost）费用（fee）制造费用（manufacturecost）资源费用（resource）
                 *                  key = costAcctId + splitStr + costRecEid + splitStr + "materialcost";
                 *              }
                 *              //源单成本
                 *              BigDecimal srcCost = acctRecIdEleCostMap.get(key);
                 *              if(srcCost == null){
                 *                  continue;
                 *              }
                 *              BigDecimal baseqty = row.getBigDecimal("baseqty");
                 *              //单价增加一块钱
                 *              BigDecimal addCost = srcCost.add(BigDecimal.ONE.multiply(baseqty));
                 *              //返回数据
                 *              acctRecIdEleCostMap.put(key, addCost);
                 *          }
                 *      }
                 *
                 *      private DataSet getCostRecordDs(Map<String, BigDecimal> acctRecIdEleCostMap, Set<Long> bizBillIds) {
                 *          //成本账簿id
                 *          Set<Long> costAcctIds = new HashSet<>(16);
                 *          //成本记录分录id
                 *          Set<Long> recEids = new HashSet<>(16);
                 *          for (Map.Entry<String, BigDecimal> entry : acctRecIdEleCostMap.entrySet()) {
                 *              String key = entry.getKey();
                 *              String[] keySplit = key.split("\\|");
                 *              //成本账簿
                 *              String costAcctIdStr = keySplit[0];
                 *              //成本记录分录id
                 *              String calEidStr = keySplit[1];
                 *              costAcctIds.add(Long.valueOf(costAcctIdStr));
                 *              recEids.add(Long.valueOf(calEidStr));
                 *          }
                 *          //业务单据id（库存单据id）
                 *          QFilter bizBillIdFilter = new QFilter("bizbillid", QCP.in, bizBillIds);
                 *          QFilter eIdFilter = new QFilter("entry.id", QCP.in, recEids);
                 *          String sels = "bizentityobject,bizbillid,costaccount,entry.calentryid as calentryid,entry.id as entryid,entry.baseqty as baseqty,entry.subentrycostelement.costsubelement as costsubelement,costaccount.calpolicy.calbycostelement as calbycostelement";
                 *          //查询成本记录信息
                 *          DataSet costRecordDs = QueryServiceHelper.queryDataSet(this.getClass().getName(),
                 *                  "cal_costrecord_subentity", sels, new QFilter[]{bizBillIdFilter, eIdFilter}, null);
                 *          return costRecordDs;
                 *      }
                 *
                 *  }
                 *
                 *  </code></pre>
                 */
                doCalGroupCostEx(acctRecIdEleCostMap:$.java.util.Map,entity:string,bizBillIds:$.java.util.Set):void;
            }
            type ICalMoveGroupCost_T = ICalMoveGroupCost_S & ICalMoveGroupCost$;
            interface ICalMoveGroupCost extends ICalMoveGroupCost_T {
            }
        }
        namespace kd.sdk.fi.cal.extpoint.costrecord{
            interface IQueueTypeMatch_S {
            }
            interface IQueueTypeMatch$ {
                /**
                 *  获取序列类型
                 *  @param costAccountId  成本账簿ID
                 *  @param bizEntityObject 业务对象
                 *  @param billId  业务单据ID
                 *  @return queueType: "0"为入库序列，"1"为出库序列，其余结果无效
                 *
                 *  <p>扩展示例如下
                 *  <pre><code>
                 *  package kd.sdk.fi.cal.extpoint.costrecord;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.bos.servicehelper.QueryServiceHelper;
                 * import kd.bos.util.StringUtils;
                 * import kd.sdk.fi.cal.extpoint.costrecord.IQueueTypeMatch;
                 *
                 * public class SrcBill4QueuePlugin_Test implements IQueueTypeMatch {
                 *
                 * 	public String getQueueType(Long costAccountId, String bizEntityObject, Long billId) {
                 * 		//非销售出库单 或者 账簿不等于指定账簿，直接返回
                 * 		if(!bizEntityObject.equals("im_saloutbill") || costAccountId != 88888888L){
                 * 			return null;
                 * 		}
                 * 		QFilter q = new QFilter("bizbillid", "=", billId);
                 * 		q.and("costaccount.ismainaccount", "=", true);
                 * 		DynamicObject info = QueryServiceHelper.queryOne("cal_costrecord", "id,period,entry.srcbillentity,entry.srcbillid", q.toArray());
                 * 		//没有成本记录，则无需判断插件逻辑，直接返回
                 * 		if(info == null){
                 * 			return null;
                 * 		}
                 * 		String srcMainEntity = info.getString("entry.srcbillentity");
                 * 		//来源单类型为空，直接返回
                 * 		if(StringUtils.isEmpty(srcMainEntity)){
                 * 			return null;
                 * 		}
                 * 		long period = info.getLong("period");
                 * 		long srcBillId = info.getLong("entry.srcbillid");
                 * 		DynamicObject srcInfo = null;
                 * 		//源单类型相同，都是销售出库单
                 * 		if(bizEntityObject.equals(srcMainEntity)){
                 * 			q = new QFilter("bizbillid", "=", srcBillId);
                 * 			q.and("costaccount.ismainaccount", "=", true);
                 * 			//源单
                 * 			srcInfo = QueryServiceHelper.queryOne("cal_costrecord", "id,period,entry.srcbillentity,entry.srcbillid", q.toArray());
                 * 			//VMI红字销售出库单源单蓝字销售出库单为物流单不进核算
                 * 			if(srcInfo == null){
                 * 				return null;
                 * 			}
                 * 			long srcPeriod = srcInfo.getLong("period");
                 * 			//源单类型=销售出库单且源单为往期（期间不等）
                 * 			if(period != srcPeriod){
                 * 				//返回为入库序列
                 * 				return "0";
                 * 			}
                 * 		}
                 * 		return null;
                 * 	}
                 * }
                 * </code></pre>
                 */
                getQueueType(costAccountId:long,bizEntityObject:string,billId:long):string;
            }
            type IQueueTypeMatch_T = IQueueTypeMatch_S & IQueueTypeMatch$;
            interface IQueueTypeMatch extends IQueueTypeMatch_T {
            }
        }
        namespace kd.sdk.fi.cal.extpoint.groupcostacct{
            interface ICalGroupCostAcct_S {
            }
            interface ICalGroupCostAcct$ {
                /**
                 *  @function 集团成本排除单据、不排除单据扩展点，注意只支持整单排除
                 *  @param entity cal_costrecord（成本记录）、cal_costadjustbill（成本调整单）、cal_stdcostdiffbill（标准成本差异单）
                 *  @param srcBillDs 法人账单据数据，其中 "needgen" 字段为true时表示需要生成集团单据，为false时标识不需要生成集团单据
                 *  @return   kd.bos.algo.DataSet
                 *   法人账单据数据，需要生成集团单据则设置 "needgen" 字段为true，不需要生成集团单据则设置 "needgen" 字段为false
                 * <pre><code>
                 *      package kd.sdk.fi.cal.extpoint.groupcostacct;
                 *
                 *  import kd.bos.algo.DataSet;
                 *  import kd.bos.algo.Field;
                 *  import kd.bos.algo.MapFunction;
                 *  import kd.bos.algo.Row;
                 *  import kd.bos.algo.RowMeta;
                 *
                 *  import java.util.HashSet;
                 *  import java.util.Set;
                 *
                 *  //集团成本排除单据、不排除单据扩展测试
                 *  public class ICalGroupCostAcctTest implements ICalGroupCostAcct{
                 *
                 *  //
                 *  //   @function 获取排除单据需要的字段，可以避免二开接口需要再次查询数据库。
                 *  //    注意： 如果标准的单据字段已经可以判断，则可以不实现该扩展逻辑，可以直接返回null或空集合
                 *  //   @param  entity cal_costrecord（成本记录）、cal_costadjustbill（成本调整单）、cal_stdcostdiffbill（标准成本差异单）
                 *  //   @return   java.util.Set<java.lang.String>
                 *  //
                 *      @Override
                 *      public Set<String> getExcludeNeedBillFields(String entity) {
                 *          //单据字段全路径，例如成本记录物料字段：entry.material as material_ext (注意别名加上二开后缀"_ext"，避免字段重复报错)
                 *          Set<String> extFields = new HashSet<>(16);
                 *          //成本记录
                 *          if("cal_costrecord".equals(entity)) {
                 *              extFields.add("entry.material as material_ext");
                 *          }
                 *          return extFields;
                 *      }
                 *
                 *  //     @function 根据单据信息，设置"needgen" 字段为true时表示需要生成集团单据，为false时标识不需要生成集团单据
                 *  //     @param entity entity cal_costrecord（成本记录）、cal_costadjustbill（成本调整单）、cal_stdcostdiffbill（标准成本差异单）
                 *  //     @param srcBillDs
                 *  //     @return   kd.bos.algo.DataSet
                 *      @Override
                 *      public DataSet dealGroupAcctBillExclude(String entity, DataSet srcBillDs) {
                 *          //其中 "needgen" 字段为true时表示需要生成集团单据，为false时标识不需要生成集团单据
                 *          ExtGroupAcctBillExcludeFunc extFunc = new ExtGroupAcctBillExcludeFunc(entity, srcBillDs.getRowMeta());
                 *          srcBillDs = srcBillDs.map(extFunc);
                 *          return srcBillDs;
                 *      }
                 *
                 *      public class ExtGroupAcctBillExcludeFunc extends MapFunction{
                 *
                 *          private static final long serialVersionUID = 772036626721085321L;
                 *          private final String entity;
                 *          private final RowMeta rowMeta;
                 *
                 *          public ExtGroupAcctBillExcludeFunc(String entity, RowMeta rowMeta) {
                 *              this.entity = entity;
                 *              this.rowMeta = rowMeta;
                 *          }
                 *
                 *          @Override
                 *          public Object[] map(Row row) {
                 *              Object[] newRow = createNewRow(row, rowMeta);
                 *              //成本记录
                 *              if("cal_costrecord".equals(entity)) {
                 *                  //这里能拿到标准的字段（material），以及前面添加的二开字段kd.sdk.fi.cal.extpoint.groupcostacct.ICalGroupCostAcctTest.getExcludeNeedBillFields
                 *                  Long matExt = row.getLong(rowMeta.getFieldIndex("material_ext"));
                 *                  //根据单据信息，设置"needgen" 字段为true时表示需要生成集团单据，为false时标识不需要生成集团单据
                 *                  newRow[rowMeta.getFieldIndex("needgen")] = false;
                 *              }
                 *              return newRow;
                 *          }
                 *
                 *          @Override
                 *          public RowMeta getResultRowMeta() {
                 *              return rowMeta;
                 *          }
                 *
                 *          private Object[] createNewRow(Row row, RowMeta rowMeta) {
                 *              int resultFieldCount = rowMeta.getFieldCount();
                 *              Object[] newValues = new Object[resultFieldCount];
                 *              Field[] srcFields = rowMeta.getFields();
                 *              for (int i = 0; i < rowMeta.getFieldCount(); i++) {
                 *                  newValues[i] = row.get(srcFields[i].getName());
                 *              }
                 *              return newValues;
                 *          }
                 *
                 *      }
                 *
                 *  }
                 *  </code></pre>
                 */
                dealGroupAcctBillExclude(entity:string,srcBillDs:$.kd.bos.algo.DataSet):$.kd.bos.algo.DataSet;
                /**
                 *  @function 获取排除单据需要的字段，可以避免二开接口需要再次查询数据库。
                 *    注意： 如果标准的单据字段已经可以判断，则可以不实现该扩展逻辑，可以直接返回null或空集合
                 *  @param entity cal_costrecord（成本记录）、cal_costadjustbill（成本调整单）、cal_stdcostdiffbill（标准成本差异单）
                 *  @return   单据字段全路径，例如成本记录物料字段：entry.material as material_ext (注意别名加上二开后缀"_ext"，避免字段重复报错)
                 * <pre><code>
                 *     @Override
                 *      public Set<String> getExcludeNeedBillFields(String entity) {
                 *          //单据字段全路径，例如成本记录物料字段：entry.material as material_ext (注意别名加上二开后缀"_ext"，避免字段重复报错)
                 *          Set<String> extFields = new HashSet<>(16);
                 *          //成本记录
                 *          if("cal_costrecord".equals(entity)) {
                 *              extFields.add("entry.material as material_ext");
                 *          }
                 *          return extFields;
                 *      }
                 *  </code></pre>
                 */
                getExcludeNeedBillFields(entity:string):$.java.util.Set;
            }
            type ICalGroupCostAcct_T = ICalGroupCostAcct_S & ICalGroupCostAcct$;
            interface ICalGroupCostAcct extends ICalGroupCostAcct_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.agentpay{
            interface IAgentPayBillRepay_S {
            }
            interface IAgentPayBillRepay$ {
                /**
                 *  @param entityName 单据实体名
                 *  @param billList 业务单据集合
                 *  @return key->银行单据id；value->二开字段名和值的键值对
                 *
                 *  <p>扩展示例如下
                 *  <pre><code>
                 *   package kd.sdk.tmc.ext.extpoint.agentpay;
                 * 	import kd.bos.dataentity.entity.DynamicObject;
                 * 	import kd.sdk.fi.cas.extpoint.agentpay.IAgentPayBillRepay;
                 *
                 * 	import java.util.HashMap;
                 * 	import java.util.List;
                 * 	import java.util.Map;
                 *
                 * 	public class AgentPayBillRepay implements IAgentPayBillRepay {
                 * 	    @Override
                 * 	    public Map<Long, Map<String, Object>> extFillAgentPayBill(String entityName, List<DynamicObject> billList) {
                 * 	        Map<Long, Map<String, Object>> result = new HashMap<>();
                 * 	        switch (entityName) {
                 * 	            case "代发处理单标识":
                 * 	                Map<String, Object> prop = new HashMap<>();
                 * 	                for (DynamicObject bill : billList) {
                 * 	                    prop.put("exfield", "二开字段");
                 * 	                    result.put(bill.getLong("id"), prop);
                 * 	                }
                 * 	                break;
                 * 	        }
                 * 	        return result;
                 * 	    }
                 * 	}
                 *
                 *  }</code></pre>
                 */
                extFillAgentPayBill(entityName:string,billList:$.java.util.List):$.java.util.Map;
            }
            type IAgentPayBillRepay_T = IAgentPayBillRepay_S & IAgentPayBillRepay$;
            interface IAgentPayBillRepay extends IAgentPayBillRepay_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.claimbill{
            interface IClaimbillMuiltErpSelectCoreBill_S {
            }
            interface IClaimbillMuiltErpSelectCoreBill$ {
                /**
                 * 收款认领处理单
                 * 跨租户选择核心单据后子租户关键信息回填主租户认领处理分录
                 * 销售订单和合同不需要扩展，标品第一版已经写死支持，若需要补充条件可以进一步埋点进行字段的回填（核心单据行号必须回填）
                 *
                 * @param listSelectedRow 过滤条件，用于二开自定义扩展
                 * @param rowData         认领处理单数据模型，用于二开获取当前认领处理单据页面数据和二开或业务单据进行认领处理单的回填
                 *
                 *                        <p>默认扩展示例如下
                 *                        <pre><code>
                 *                                   public class ClaimbillFillCoreIfo implements IClaimbillMuiltErpSelectCoreBill {
                 *                            @Override
                 *                            public void setCoreIfoByMuiltyERP(ListSelectedRow listSelectedRow, DynamicObject rowData, String coreBillType) {
                 *                                if (rowData != null && listSelectedRow != null) {
                 *                                    DynamicObject settleorg = (DynamicObject) rowData.get(RecClaimBillModel.E_SETTLEORG);//结算组织
                 *                                    //获取远程调用子租户信息
                 *                                    CtsyTenant tenant = CtsyBaseServiceHelper.getCtsyTenant(settleorg.getLong("id"));
                 *                                    if (tenant == null) {
                 *                                        return;
                 *                                    }
                 *                                    Object pkValue = listSelectedRow.getPrimaryKeyValue();//所选核心单据id
                 *                                    String entryEntityKey = listSelectedRow.getEntryEntityKey();//所选核心单据分录标识
                 *                                    //所选核心单据分录id； 有分录，才需要查seq；没有分录和分录id则说明选择的是单头无需查询seq，无需赋值核心单据行id
                 *                                    Object entryPKValue = listSelectedRow.getEntryPrimaryKeyValue();
                 *                                    Map<String, Object> param = new HashMap<>(16);
                 *                                    param.put("id", pkValue);
                 *                                    param.put("entryid", entryEntityKey);
                 *                                    param.put("entrytype", entryPKValue);
                 *                                    Map<String, Object> params = new HashMap<>(16);
                 *                                    params.put("param", Collections.singletonList(param));
                 *                                    //远程调用接口（按需，如果除了核心单据id和核心分录id的回填则无需调用自定义接口，
                 *                                    // 一般选择了分录或者还有核心单据其他属性的引用都要调用接口获取后回填）可参考,不会的可以找核心单据所在业务指导下
                 *                                    if ("sm_salorder".equals(coreBillType)) {//假设核心单据类型是销售订单
                 *                                        //kd.scmc.sm.webapi.service.SmOrderController
                 *                                        String URL_QUERY_ORD = "/v2/sm/getSalOrderEntrys";
                 *                                        String tenantId = tenant.getTenantId();
                 *                                        String accountId = tenant.getAccountId().toString();
                 *                                        Map<String, Object> returns = (Map<String, Object>) CtsyApiDispatchServiceHelper.invokeWebApi(tenantId, accountId, URL_QUERY_ORD, params);
                 *                                        String info = String.valueOf(returns);
                 *                                        boolean isSuc = returns.get("status") == null ? true : (Boolean) returns.get("status");
                 *                                        if (!isSuc) {
                 *                                            throw new KDBizException(info);
                 *                                        }
                 *                                        Map<String, Object> dataResults = (Map<String, Object>) returns.get("data");
                 *                                        if (dataResults != null && dataResults.size() > 0) {
                 *                                            rowData.set("e_corebillentryseq", dataResults.get("seq"));//核心单据行号
                 *                                            rowData.set(RecClaimBillModel.ENTRY_CONBILLENTITY, "conm_salcontract"); //合同实体，默认都是销售合同
                 *                                            rowData.set(RecClaimBillModel.ENTRY_CONBILLNUMBER, dataResults.get("conbillnumber"));//合同编号
                 *                                            rowData.set(RecClaimBillModel.ENTRY_CONBILLROWNUM, dataResults.get("conbillrownum"));//合同行号
                 *                                            rowData.set(RecClaimBillModel.ENTRY_CONBILLID, dataResults.get("conbillid"));//合同id
                 *                                            rowData.set(RecClaimBillModel.ENTRY_CONBILLENTRYID, dataResults.get("conbillentryid"));//合同行id
                 *                                        }
                 *                                    }
                 *                                }
                 *                            }
                 *                        }
                 *                        </pre></code>
                 *                        </p>
                 */
                setCoreIfoByMuiltyERP?(listSelectedRow:$.kd.bos.entity.datamodel.ListSelectedRow,rowData:$.kd.bos.dataentity.entity.DynamicObject,coreBillType:string):void;
                /**
                 * 收款认领处理单过滤条件扩展
                 * 用于认领处理单分录行选择核心单据F7页面过滤条件扩展
                 * 销售订单和合同不需要扩展，标品第一版已经写死支持，若需要补充条件可以进一步埋点过滤
                 *
                 * @param lfp       过滤条件，用于二开自定义扩展
                 * @param dataModel 认领处理单数据模型，用于二开获取当前认领处理单据页面数据
                 *                  <p>默认扩展示例如下
                 *                  <pre><code>
                 *                    public class ClaimbillFilter implements IClaimbillMuiltErpSelectCoreBill {
                 *                      @Override
                 *                      public void setIFilters(ListFilterParameter lfp, IDataModel dataModel) {
                 *                          //主要是把里面的基础资料过滤进行转换，比如：客户、供应商、部门、币别，以及二开的一些基础资料（被同步打子租户，id不同转number查询）
                 *                          int currrow = dataModel.getEntryCurrentRowIndex(RecClaimBillModel.ENTRYENTITY);// 获取当前点击分录行行号
                 *                          String coreBillType = (String) dataModel.getValue(RecClaimBillModel.E_COREBILLTYPE, currrow);// 获取分录行核心单据类型
                 *                          //不同的核心单据类型的过滤条件是不同的逻辑
                 *                          DynamicObject currency = (DynamicObject) dataModel.getValue("currency");//币别
                 *                          DynamicObject settleorg = (DynamicObject) dataModel.getValue(RecClaimBillModel.E_SETTLEORG, currrow);//结算方式
                 *                          //条件都来自于取目标子租户核心单据的过滤，需要跨租户转number查询以及根据自己需要适配的核心单据做条件拼接（现场保证核心单据取数逻辑）
                 *                          if (StringUtils.equals(coreBillType, ClaimCoreBillTypeEnum.SALORDER.getValue())) {
                 *                              lfp.getQFilters().forEach(qFilter -> {
                 *                                  if ("billentry.entrysettleorg".equals(qFilter.getProperty())) {
                 *                                      qFilter.__setProperty("billentry.entrysettleorg.number");
                 *                                      qFilter.__setValue(settleorg.getString("number"));
                 *                                  }
                 *                                  if("customer".equals(qFilter.getProperty())){
                 *                                     //todo  根据客商类型去查基础资料，用客商的number关联取数接口。如为其他则不用处理（或者拼接ID=0L）
                 *                                  }
                 *                              });
                 *                          }
                 *                          if (coreBillType.startsWith(ClaimCoreBillTypeEnum.FINARBILL.getValue())) {   //财务应收单，，，
                 *                              lfp.getQFilters().forEach(qFilter -> {
                 *                                  if ("org".equals(qFilter.getProperty())) {
                 *                                      qFilter.__setProperty("org.number");
                 *                                      qFilter.__setValue(settleorg.getString("number"));
                 *                                  }
                 *                                  if ("currency".equals(qFilter.getProperty())) {
                 *                                      qFilter.__setProperty("currency.number");
                 *                                      qFilter.__setValue(currency.getString("number"));
                 *                                  }
                 *                              });
                 *                          }
                 *                      }
                 *                  }
                 *                  </pre></code>
                 *                  </p>
                 */
                setIFilters?(lfp:$.kd.bos.list.ListFilterParameter,dataModel:$.kd.bos.entity.datamodel.IDataModel):void;
            }
            type IClaimbillMuiltErpSelectCoreBill_T = IClaimbillMuiltErpSelectCoreBill_S & IClaimbillMuiltErpSelectCoreBill$;
            interface IClaimbillMuiltErpSelectCoreBill extends IClaimbillMuiltErpSelectCoreBill_T {
            }
            interface IClaimcenterHote_S {
                readonly logger:$.kd.bos.logging.Log;
            }
            interface IClaimcenterHote$ {
                setNewRecBillField?(recBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IClaimcenterHote_T = IClaimcenterHote_S & IClaimcenterHote$;
            interface IClaimcenterHote extends IClaimcenterHote_T {
            }
            interface IBatchClaimBillInterface_S {
            }
            interface IBatchClaimBillInterface$ {
                /**
                 * 批量认领自定义值携带到下游认领处理单扩展
                 *
                 * @param type                     认领类型： 收款 "rec" , 付款 "pay"
                 * @param claimBill                认领处理单
                 * @param claimBillFirstEntryRow   认领处理单分录行第一行对象
                 * @param batchClaimBillCurrentRow 批量认领当前分录行对象
                 * @return
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.fi.cas.formplugin.recclaim.claimnotice;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.sdk.fi.cas.extpoint.claimbill.IBatchClaimBillInterface;
                 *
                 * public class ClaimBillExtTest implements IBatchClaimBillInterface {
                 *
                 *      public DynamicObject setClaimBillExt(String type, DynamicObject claimBill, DynamicObject claimBillFirstEntryRow, DynamicObject batchClaimBillCurrentRow) {
                 *          // 收款认领
                 *          if ("rec".equals(type)) {
                 *              // 认领处理单单头扩展字段赋值
                 *              claimBill.set("sdkexttest", batchClaimBillCurrentRow.get("sdkexttest"));
                 *              // 认领处理单分录扩展字段赋值
                 *              claimBillFirstEntryRow.set("sdkentryexttest", batchClaimBillCurrentRow.getDynamicObject("sdkentryexttest"));
                 *              return claimBill;
                 *          } else {
                 *              // 付款认领
                 *              // 认领处理单单头扩展字段赋值
                 *              claimBill.set("sdkexttest", batchClaimBillCurrentRow.get("sdkexttest"));
                 *              // 认领处理单分录扩展字段赋值
                 *              claimBillFirstEntryRow.set("sdkentryexttest2", batchClaimBillCurrentRow.getDynamicObject("sdkentryexttest2"));
                 *              return claimBill;
                 *          }
                 *      }
                 * }
                 * </pre></code>
                 * </p>
                 */
                setClaimBillExt?(type_arg:string,claimBill:$.kd.bos.dataentity.entity.DynamicObject,claimBillFirstEntryRow:$.kd.bos.dataentity.entity.DynamicObject,batchClaimBillCurrentRow:$.kd.bos.dataentity.entity.DynamicObject):$.kd.bos.dataentity.entity.DynamicObject;
            }
            type IBatchClaimBillInterface_T = IBatchClaimBillInterface_S & IBatchClaimBillInterface$;
            interface IBatchClaimBillInterface extends IBatchClaimBillInterface_T {
            }
            interface IClaimbillFilter_S {
            }
            interface IClaimbillFilter$ {
                /**
                 * 收款认领处理单过滤条件扩展
                 * 用于认领处理单分录行选择核心单据F7页面过滤条件扩展
                 *
                 * @param lfp  过滤条件，用于二开自定义扩展
                 * @param dataModel  认领处理单数据模型，用于二开获取当前认领处理单据页面数据
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.fi.cas.formplugin.recclaim.claimhandle
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.entity.datamodel.IDataModel;
                 * import kd.bos.list.ListFilterParameter;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.fi.cas.consts.RecClaimBillModel;
                 * import kd.sdk.fi.cas.extpoint.claimbill.IClaimbillFilter;
                 *
                 * public class ClaimbillFilter implements IClaimbillFilter
                 *
                 *      public void setIFilters(ListFilterParameter lfp, IDataModel dataModel) {
                 *         // 获取当前点击分录行行号
                 *         int currrow = dataModel.getEntryCurrentRowIndex(RecClaimBillModel.ENTRYENTITY);
                 *         // 获取分录行核心单据类型
                 *         String coreBillType = (String) dataModel.getValue(RecClaimBillModel.E_COREBILLTYPE, currentRowIndex);
                 *         // 获取当前单据实体
                 *         DynamicObject claimBill = dataModel.getDataEntity();
                 *         // 通过认领处理单数据添加自定义过滤条件
                 *         lfp.setFilter(new QFilter("accountingorg", QCP.equals, claimBill.getString("billstatus")));
                 *      }
                 * }
                 * </pre></code>
                 * </p>
                 */
                setIFilters(lfp:$.kd.bos.list.ListFilterParameter,dataModel:$.kd.bos.entity.datamodel.IDataModel):void;
                /**
                 * 收款认领单过滤条件扩展插件,用于二开项目扩展过滤条件
                 * @param lfp 列表过滤条件参数
                 * @param claimBill 页面单据
                 * @return void
                 *
                 * <p>扩展示例如下
                 *          <pre><code>
                 *          import kd.bos.dataentity.entity.DynamicObject;
                 *          import kd.bos.list.ListFilterParameter;
                 *
                 *          public class ClaimbillFilter implements IClaimbillFilter {
                 *
                 *              public void setIFilters(ListFilterParameter lfp, DynamicObject claimBill) {
                 *                  IClaimbillFilter.super.setIFilters(lfp, claimBill);
                 *                  lfp.setFilter(new QFilter("accountingorg", QCP.equals, claimBill.getString("billstatus")));
                 *              }
                 *          }
                 *
                 *          </code></pre>
                 */
                setIFilters(lfp:$.kd.bos.list.ListFilterParameter,claimBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IClaimbillFilter_T = IClaimbillFilter_S & IClaimbillFilter$;
            interface IClaimbillFilter extends IClaimbillFilter_T {
            }
            interface BankAutoMatchCheck_S {
                readonly logger:$.kd.bos.logging.Log;
            }
            interface BankAutoMatchCheck$ {
                setBankAutoMatchCheck?(ruleList:$.java.util.List):void;
            }
            type BankAutoMatchCheck_T = BankAutoMatchCheck_S & BankAutoMatchCheck$;
            interface BankAutoMatchCheck extends BankAutoMatchCheck_T {
            }
            interface IClaimHandlePluginSDK_S {
            }
            interface IClaimHandlePluginSDK$ {
                /**
                 *  处理数据集，此为步骤3，将idValue集合中的数据赋值到rowData中，相当于给界面分录数据进行赋值
                 *  @param idValue 存放查询的id及对应数据集
                 *  @param rowData 分录数据对象
                 *
                 * <p>扩展示例如下
                 * <pre><code>
                 *       public void dealResult(Map<Long, Map<String, Object>> idValue, DynamicObject rowData) {
                 *                 Long id = (Long)rowData.get("e_corebillid");
                 *                 rowData.set("e_fee", idValue.get(id).get("e_fee"));
                 *      }</code></pre>
                 */
                dealResult(idValue:$.java.util.Map,rowData:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 *  填充数据集，此为步骤2，允许针对选择的核心单据根据id去获取单据头属性或其他属性，存储到idValue中以便步骤3使用
                 *  @param coreBillType 核心单据类型
                 *  @param ids 选择的核心单据id
                 *  @param idValue 存放查询的id及对应数据集
                 *
                 * <p>扩展示例如下
                 * <pre><code>
                 *      public void fillResult(String coreBillType, Set<Long> ids, Map<Long, Map<String, Object>> idValue) {
                 *          DynamicObject obj = QueryServiceHelper.queryOne(coreBillType,"e_fee",new QFiter("id",QCP.in,ids));
                 *          Map<String,Object> s = new HashMap<>();
                 *          s.put("e_fee", obj.get("e_fee"));
                 *          idValue.put(obj.getLong("id"),s);
                 *      }</code></pre>
                 */
                fillResult(coreBillType:string,ids:$.java.util.Set,idValue:$.java.util.Map):void;
                /**
                 *  此为步骤1，二开属性查询出来的数据将在后面步骤使用
                 *  @param coreBillType 核心单据类型
                 *  @param entryEntityKey 分录标识
                 *  @param srcSelectField 标品原始查询属性
                 *  @return 添加二开查询属性
                 *
                 * <p>扩展示例如下
                 *  <pre><code>
                 *  pubilc String getSelectFieldWithEntry(String coreBillType, String entryEntityKey,String srcSelectField){
                 *      String field = ",amt,entry.e_fee";// 可以根据coreBillType、entryEntityKey返回二开需要查询的属性
                 *      return field;
                 *  }</code></pre>
                 */
                getSelectFieldWithEntry(coreBillType:string,entryEntityKey:string,srcSelectField:string):$.java.util.Set;
            }
            type IClaimHandlePluginSDK_T = IClaimHandlePluginSDK_S & IClaimHandlePluginSDK$;
            interface IClaimHandlePluginSDK extends IClaimHandlePluginSDK_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.closeperiod{
            interface ICheckArchiveBillTypeInterface_S {
            }
            interface ICheckArchiveBillTypeInterface$ {
                /**
                 *  期末结账反结账时需要校验是否已经归档的单据类型，已归档的不允许反结账
                 *  默认有银行日记账和现金日记账两种单据类型，其他需要在此接口中扩展添加
                 *
                 *  <p>扩展示例如下</p>
                 *  <pre><code>
                 *  package kd.sdk.fi.cas.extpoint.closeperiod;
                 *
                 *  import java.util.Arrays;
                 *  import java.util.List;
                 *
                 *  public class CheckArchiveBillType implements ICheckArchiveBillTypeInterface{
                 *  @Override
                 *    public List<String> getOtherBillTypes() {
                 *        // 返回需要判断是否已经归档的单据类型
                 *        return Arrays.asList("单据类型一","单据类型一");
                 *    }
                 * }</code></pre>
                 */
                getOtherBillTypes():$.java.util.List;
            }
            type ICheckArchiveBillTypeInterface_T = ICheckArchiveBillTypeInterface_S & ICheckArchiveBillTypeInterface$;
            interface ICheckArchiveBillTypeInterface extends ICheckArchiveBillTypeInterface_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.dynamiclisthelper{
            interface IDynamicListHelper_S {
            }
            interface IDynamicListHelper$ {
                /**
                 * @param showFields 展示字段
                 * @return 展示字段
                 * <p>默认拓展示例如下
                 * <pre><code>
                 * package kd.sdk.fi.cas.extpoint.dynamiclisthelper;
                 *
                 * public class DynamicListHelperExt implements IDynamicListHelper{
                 *
                 *     @Override
                 *     public List<String> getShowFields(List<String> showFields) {
                 *
                 *         //增加需要展示的字段
                 *         showFields.add("xxx");
                 *         return showFields;
                 *     }
                 * }
                 *
                 * </pre></code>
                 * </p>
                 */
                setShowFieldsForCustomerBankInfo?(showFields:$.java.util.List):$.java.util.List;
                setShowFieldsForSupplierBankInfo?(showFields:$.java.util.List):$.java.util.List;
            }
            type IDynamicListHelper_T = IDynamicListHelper_S & IDynamicListHelper$;
            interface IDynamicListHelper extends IDynamicListHelper_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.journal{
            interface IJournalVoucherBookInterface_S {
            }
            interface IJournalVoucherBookInterface$ {
                /**
                 * 现金日记账-凭证登账扩展
                 * @return  extFieldName 凭证分录现金账户id扩展字段标识
                 *
                 * <p>扩展示例如下
                 * <pre><code>
                 * package kd.fi.cas.helper;
                 *
                 * import kd.sdk.fi.cas.extpoint.journal.IJournalVoucherBookInterface;
                 *
                 * public class voucherBookCashAccountExtPlugin implements IJournalVoucherBookInterface {
                 *     public String cashJournalBookExt() {
                 *         return "kdtest_accountCashId_ext";
                 *     }
                 * }
                 * </code></pre>
                 */
                cashJournalBookExt?():string;
            }
            type IJournalVoucherBookInterface_T = IJournalVoucherBookInterface_S & IJournalVoucherBookInterface$;
            interface IJournalVoucherBookInterface extends IJournalVoucherBookInterface_T {
            }
            interface IBankJournalField_S {
            }
            interface IBankJournalField$ {
                /**
                 *  获取下载银行日记账时二开需要从交易明细携带到银行日记账的字段映射
                 *  <pre>字段需在银行日记账和交易明细中同时存在，字段类型和长度一致</pre>
                 *
                 * @return 二开需要交易明细携带到银行日记账的字段映射
                 * <pre>key:银行日记账的字段标识</br>
                 * value:交易明细的字段标识</pre>
                 *
                 * <pre><code>
                 * package kd.fi.cas.business.journal.extpoint;
                 *
                 * import kd.sdk.fi.cas.extpoint.journal.IBankJournalField;
                 *
                 * import java.util.HashMap;
                 * import java.util.Map;
                 *
                 * public class BankJournalFieldDemo implements IBankJournalField {
                 *
                 *     @Override
                 *     public Map<String, String> getExtDownloadFieldMap() {
                 *         // 下载银行日记账时额外需要从交易明细携带到银行日记账的标品或二开字段，例子中kdtest_为二开字段前缀
                 *         Map<String, String> extFieldMap = new HashMap<>(16);
                 *         extFieldMap.put("kdtest_extfield", "kdtest_extfield");
                 *         return extFieldMap;
                 *     }
                 * }
                 * </code></pre>
                 */
                getExtDownloadFieldMap():$.java.util.Map;
            }
            type IBankJournalField_T = IBankJournalField_S & IBankJournalField$;
            interface IBankJournalField extends IBankJournalField_T {
            }
            interface ICheckBalanceAdjust_S {
            }
            interface ICheckBalanceAdjust$ {
                /**
                 *  二开自己定义要检查余额调节表的时间范围
                 * @return 组织和时间范围
                 *
                 * <p>扩展示例如下
                 * <pre><code>
                 *   public class CheckBalanceAdjustTest implements ICheckBalanceAdjust {
                 *
                 *       @Override
                 *       public List<CheckBalanceAdjust> checkBalanceAdjustDate() {
                 *
                 *           CheckBalanceAdjust checkBalanceAdjust = new CheckBalanceAdjust();
                 *           checkBalanceAdjust.setOrgId(1381187715759885312l); // 组织ID
                 *           checkBalanceAdjust.setStartDate(DateUtils.stringToDate("2025-01-10","yyyy-MM-dd")); // 开始时间
                 *           checkBalanceAdjust.setEndDate(DateUtils.stringToDate("2025-01-20","yyyy-MM-dd")); // 结束时间
                 *
                 *           List<CheckBalanceAdjust> checkBalanceAdjusts = new ArrayList<>(10);
                 *           checkBalanceAdjusts.add(checkBalanceAdjust);
                 *
                 *           return checkBalanceAdjusts;
                 *            }
                 *        }
                 * </code></pre>
                 */
                checkBalanceAdjustDate?():$.java.util.List;
            }
            type ICheckBalanceAdjust_T = ICheckBalanceAdjust_S & ICheckBalanceAdjust$;
            interface ICheckBalanceAdjust extends ICheckBalanceAdjust_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.noticeclaim{
            interface INoticeClaimSchemeInterface_S {
            }
            interface INoticeClaimSchemeInterface$ {
                /**
                 * 通知认领对象拓展
                 * 扩展调用时机：
                 * 1.【通知规则】界面选择“自定义”时触发扩展
                 * 2.点击“通知认领”操作且检测到未匹配到通知规则后在“通知认领”弹出框重新选择“自定义”时触发扩展
                 *
                 * @param noticeObjectMap
                 * @return Map<String, Object> key:"userids", value:userIdList
                 *
                 * <p>拓展示例如下
                 * <pre><code> package kd.fi.cas.formplugin.recclaim.extpoint;
                 *
                 * import kd.sdk.fi.cas.extpoint.noticeclaim.INoticeClaimSchemeInterface;
                 *
                 * import java.util.ArrayList;
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class NoticeClaimSchemesDefaultExt implements INoticeClaimSchemeInterface {
                 *
                 *     public Map<String, Object> noticeObjectExt(Map<String, Object> noticeObjectMap) {
                 *         // 自定义通知对象用户ID
                 *         List<Object> userIds = new ArrayList<>(2);
                 *         userIds.add(1540672005563544576L);
                 *         noticeObjectMap.put("userids", userIds);
                 *
                 *         return noticeObjectMap;
                 *     }
                 * }</code></pre>
                 */
                noticeObjectExt?(noticeObjectMap:$.java.util.Map):$.java.util.Map;
            }
            type INoticeClaimSchemeInterface_T = INoticeClaimSchemeInterface_S & INoticeClaimSchemeInterface$;
            interface INoticeClaimSchemeInterface extends INoticeClaimSchemeInterface_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.paybill{
            interface IGenBankBillSDKService_S {
            }
            interface IGenBankBillSDKService$ {
                /**
                 * @param entityName 单据实体名
                 * @param billList 业务单据集合
                 * @return key->银行单据id；value->二开字段名和值的键值对
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.ext.extpoint.committobe;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 *
                 * import java.util.HashMap;
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class GenBankBillService implements IGenBankBillSDKService{
                 *
                 *     @Override
                 *     public Map<Long, Map<String, Object>> extFillBankBill(String entityName, List<DynamicObject> billList) {
                 *         Map<Long, Map<String, Object>> result = new HashMap<>();
                 *         switch (entityName){
                 *             case "付款单":
                 *                 Map<String,Object> prop = new HashMap<>();
                 *                 for(DynamicObject bill:billList) {
                 *                     prop.put("exfield", "二开字段");
                 *                     result.put(bill.getLong("id"), prop);
                 *                 }
                 *                 break;
                 *         }
                 *         return result;
                 *     }
                 * }</code></pre>
                 */
                extFillBankBill(entityName:string,billList:$.java.util.List):$.java.util.Map;
            }
            type IGenBankBillSDKService_T = IGenBankBillSDKService_S & IGenBankBillSDKService$;
            interface IGenBankBillSDKService extends IGenBankBillSDKService_T {
            }
            interface IInterPayPlanField_S {
            }
            interface IInterPayPlanField$ {
                /**
                 *  获取二开需要填充的付款处理的字段映射
                 *  <pre>字段需在付款处理和智能填充设置中同时存在，字段类型和长度一致，可参考e_expenseitem</pre>
                 *
                 * @return 二开需要智能填充的付款处理的字段映射
                 * <pre>key:付款处理的标品或二开字段标识，其中分录字段格式：分录标识.分录字段标识</br>
                 * value:智能填充设置的字段标识</pre>
                 *
                 * <pre><code>
                 * package kd.fi.cas.opplugin;
                 *
                 * import kd.sdk.fi.cas.extpoint.paybill.IInterPayPlanField;
                 *
                 * import java.util.HashMap;
                 * import java.util.Map;
                 *
                 * public class InterPayPlanFieldExtDemo implements IInterPayPlanField {
                 *
                 *     @Override
                 *     public Map<String, String> getExtFieldMap() {
                 *         // 额外需要填充的付款处理的标品或二开字段，例子中kdtest_为二开字段前缀
                 *         Map<String, String> extFieldMap = new HashMap<>(16);
                 *         extFieldMap.put("entry.e_fundflowitem", "kdtest_e_fundflowitem");
                 *         extFieldMap.put("kdtest_extfield", "kdtest_extfield");
                 *         return extFieldMap;
                 *     }
                 * }
                 * </code></pre>
                 */
                getExtFieldMap():$.java.util.Map;
            }
            type IInterPayPlanField_T = IInterPayPlanField_S & IInterPayPlanField$;
            interface IInterPayPlanField extends IInterPayPlanField_T {
            }
            interface IPayeeBankInfoFilter_S {
            }
            interface IPayeeBankInfoFilter$ {
                /**
                 * 付款处理客商收款账号过滤条件扩展插件
                 * @param lfp 列表过滤条件参数
                 * @param payBill 页面单据
                 * @return void
                 *
                 * <b>扩展示例如下
                 *        <pre><code>
                 *          import kd.bos.dataentity.entity.DynamicObject;
                 *          import kd.bos.list.ListFilterParameter;
                 *
                 *          public class PayeeBankInfoFilter implements IPayeeBankInfoFilter {
                 *
                 *              public void setIFilters(ListFilterParameter lfp, DynamicObject payBill) {
                 *                  IPayeeBankInfoFilter.super.setIFilters(lfp, payBill);
                 *                  lfp.setFilter(new QFilter("accountingorg", QCP.equals, payBill.getString("billstatus")));
                 *              }
                 *
                 *          }
                 *
                 *        </code></pre>
                 */
                setIFilters?(lfp:$.kd.bos.list.ListFilterParameter,payBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IPayeeBankInfoFilter_T = IPayeeBankInfoFilter_S & IPayeeBankInfoFilter$;
            interface IPayeeBankInfoFilter extends IPayeeBankInfoFilter_T {
            }
            interface IPaybillWriteback_S {
            }
            interface IPaybillWriteback$ {
                /**
                 * 付款单反写参数扩展属性返回,用于二开项目返回扩展字段反写
                 *
                 * @param payBillId 付款单id
                 * @return Map<Long, Map < String, Object>> key:分录ID value:扩展属性 (以键值对形式返回)
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *        public class PaybillWritebackImpl implements IPaybillWriteback{
                 *           public Map<Long, Map<String, Object>> loadExtendInfo(Long payBillId) {
                 *                Map<Long, Map<String, Object>> extendInfoMap = new HashMap<>();
                 *                try {
                 *                DynamicObject payWriteConfig = ExtendConfigHelper.getExtendConfig(ExtendConfigHelper.CONFIG_WRITEBACK_PAY);
                 *                if(payWriteConfig != null && StringUtils.isNotBlank(payWriteConfig.getString("configvalue"))){
                 *                    IPaybillWriteback iPaybillWriteback = (IPaybillWriteback) Class.forName(payWriteConfig.getString("configvalue")).newInstance();
                 *                    extendInfoMap.putAll(iPaybillWriteback.loadExtendInfo(payBillId));
                 *                }
                 *                } catch (Exception e) {
                 *                    logger.info("加载扩展服务异常，%s",e.toString());
                 *                }
                 *                return extendInfoMap;
                 *            }
                 *        }
                 *    </code></pre>
                 */
                loadExtendInfo(payBillId:long):$.java.util.Map;
            }
            type IPaybillWriteback_T = IPaybillWriteback_S & IPaybillWriteback$;
            interface IPaybillWriteback extends IPaybillWriteback_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.paysche{
            interface IPayScheSecondaryFieldFill_S {
            }
            interface IPayScheSecondaryFieldFill$ {
                /**
                 * 开票回调后处理
                 * @param secondaryFields 付款排程单下带的二开字段与值 Map 集合
                 * @param paybill 付款处理单动态对象
                 * @return
                 *
                 * <p>扩展示例如下
                 *         <pre><code>
                 *         import kd.bos.dataentity.entity.DynamicObject;
                 *         import kd.bos.ext.fi.botp.consts.PaymentBillModel;
                 *         import java.util.Map;
                 *         public class IPayScheSecondaryFieldFill_Demo implements IPayScheSecondaryFieldFill {
                 *             public void fillSecondaryFields(Map<String, Object> secondaryFields, DynamicObject paybill) {
                 *                 IPayScheSecondaryFieldFill.super.fillSecondaryFields(secondaryFields, paybill);
                 *                 paybill.set(PaymentBillModel.HEAD_USAGE, secondaryFields.get("a1"));
                 *             }
                 *         }
                 *         </code></pre>
                 */
                fillSecondaryFields?(secondaryFields:$.java.util.Map,paybill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IPayScheSecondaryFieldFill_T = IPayScheSecondaryFieldFill_S & IPayScheSecondaryFieldFill$;
            interface IPayScheSecondaryFieldFill extends IPayScheSecondaryFieldFill_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.recbill{
            interface IRecBillF7Filter_S {
            }
            interface IRecBillF7Filter$ {
                /**
                 * 收款处理单收款账户字段F7界面列表数据过滤条件扩展
                 *
                 * @param listFilterParameter 列表过滤条件参数
                 * @param paramMap            预置两个参数 :
                 *                            K1:"isBotpCreate", V1: true/false  // botp下推的收款处理单为true
                 *                            K2:"recBill", V2: IDataModel       // 收款处理单
                 * @return void
                 *
                 * <b>扩展示例如下
                 * <pre><code>
                 * package kd.fi.cas.formplugin;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.list.ListFilterParameter;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.fi.cas.extpoint.recbill.IRecBillF7Filter;
                 *
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class ReceivPayeeInfoEditF7Test implements IRecBillF7Filter {
                 *
                 *      public void setFilterForAcctBank(ListFilterParameter listFilterParameter, Map<String, Object> paramMap) {
                 *          boolean isBotpCreate = (boolean) paramMap.get("isBotpCreate");
                 *          // botp不做操作
                 *          if (isBotpCreate) {
                 *              return;
                 *          }
                 *          IDataModel recBill = (IDataModel) paramMap.get("recBill");
                 *          // 获取收款处理单币种
                 *          DynamicObject currencyDo = (DynamicObject) recBill.getValue("currency");
                 *          // 获取标品前置的过滤条件
                 *          List<QFilter> qFilters = listFilterParameter.getQFilters();
                 *          qFilters.clear();
                 *          // 自定义提F7过滤条件
                 *          qFilters.add(new QFilter("bankaccountnumber", QCP.equals, "U20230421001"));
                 *      }
                 * }
                 *
                 * </code></pre>
                 */
                setFilterForAcctBank?(listFilterParameter:$.kd.bos.list.ListFilterParameter,paramMap:$.java.util.Map):void;
            }
            type IRecBillF7Filter_T = IRecBillF7Filter_S & IRecBillF7Filter$;
            interface IRecBillF7Filter extends IRecBillF7Filter_T {
            }
            interface IAgentPayField_S {
            }
            interface IAgentPayField$ {
                setAgentPayField?(info:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IAgentPayField_T = IAgentPayField_S & IAgentPayField$;
            interface IAgentPayField extends IAgentPayField_T {
            }
            interface IHotRecField_S {
            }
            interface IHotRecField$ {
                /**
                 *  红冲收款单赋值逻辑二开扩展
                 *  @param info 红冲收款单
                 *
                 * <p>扩展示例如下
                 *  <pre><code>
                 *
                 *  public class HotRecField implements IHotRecField {
                 *
                 *         public void setAHotRecField(DynamicObject info) {
                 *                  info.set(propName.propValue);
                 *
                 *                            }
                 *           }
                 *  }</code></pre>
                 */
                setAHotRecField?(info:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IHotRecField_T = IHotRecField_S & IHotRecField$;
            interface IHotRecField extends IHotRecField_T {
            }
            interface IRecbillFilter_S {
            }
            interface IRecbillFilter$ {
                /**
                 * 收款单过滤条件扩展插件,用于二开项目扩展过滤条件
                 * @param lfp 列表过滤条件参数
                 * @param recBill 页面单据
                 * @return void
                 *
                 * <b>扩展示例如下
                 *        <pre><code>
                 *          import kd.bos.dataentity.entity.DynamicObject;
                 *          import kd.bos.list.ListFilterParameter;
                 *
                 *          public class RecbillFilter implements IRecbillFilter {
                 *
                 *              public void setIFilters(ListFilterParameter lfp, DynamicObject recBill) {
                 *                  IRecbillFilter.super.setIFilters(lfp, recBill);
                 *                  lfp.setFilter(new QFilter("accountingorg", QCP.equals, recBill.getString("billstatus")));
                 *              }
                 *          }
                 *
                 *        </code></pre>
                 */
                setIFilters?(lfp:$.kd.bos.list.ListFilterParameter,recBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IRecbillFilter_T = IRecbillFilter_S & IRecbillFilter$;
            interface IRecbillFilter extends IRecbillFilter_T {
            }
            interface IRecBillCalcEFee_S {
            }
            interface IRecBillCalcEFee$ {
                /**
                 *  计算并返回收款明细分录第i行的手续费
                 *
                 * @param recBill 收款处理对象(包含分录)
                 * @param i 收款明细分录第i行
                 * @return 收款明细分录第i行的手续费
                 *
                 * <pre><code>
                 * package kd.fi.cas.formplugin.extpoint;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.dataentity.entity.DynamicObjectCollection;
                 * import kd.sdk.fi.cas.extpoint.recbill.IRecBillCalcEFee;
                 *
                 * import java.math.BigDecimal;
                 *
                 * public class RecBillCalcEFeeExtDemo implements IRecBillCalcEFee {
                 *
                 *     @Override
                 *     public BigDecimal calcEFee(DynamicObject recBill, int i) {
                 *         BigDecimal eFee = BigDecimal.ZERO;
                 *         // 二开按需获取收款明细分录第i行的手续费
                 *         DynamicObjectCollection entry = recBill.getDynamicObjectCollection("entry");
                 *         if (entry != null && !entry.isEmpty() && entry.get(i) != null) {
                 *             eFee = entry.get(i).getBigDecimal("e_fee");
                 *         }
                 *         // eFee = 二开计算逻辑
                 *         return eFee;
                 *     }
                 * }
                 * </code></pre>
                 */
                calcEFee(recBill:$.kd.bos.dataentity.entity.DynamicObject,i:number):$.java.math.BigDecimal;
            }
            type IRecBillCalcEFee_T = IRecBillCalcEFee_S & IRecBillCalcEFee$;
            interface IRecBillCalcEFee extends IRecBillCalcEFee_T {
            }
        }
        namespace kd.sdk.fi.cas.extpoint.statement{
            interface IBankStatementField_S {
            }
            interface IBankStatementField$ {
                /**
                 *  获取下载银行对账单时二开需要从交易明细携带到银行对账单的字段映射
                 *  <pre>字段需在银行对账单和交易明细中同时存在，字段类型和长度一致</pre>
                 *
                 * @return 二开需要交易明细携带到银行对账单的字段映射
                 * <pre>key:银行对账单的字段标识</br>
                 * value:交易明细的字段标识</pre>
                 *
                 * <pre><code>
                 * package kd.fi.cas.business.service.extpoint;
                 *
                 * import kd.sdk.fi.cas.extpoint.statement.IBankStatementField;
                 *
                 * import java.util.Map;
                 * import java.util.HashMap;
                 *
                 * public class BankStatementFieldDemo implements IBankStatementField {
                 *
                 *     @Override
                 *     public Map<String, String> getExtDownloadFieldMap() {
                 *         // 下载银行对账单时额外需要从交易明细携带到银行对账单的标品或二开字段，例子中kdtest_为二开字段前缀
                 *         Map<String, String> extFieldMap = new HashMap<>(16);
                 *         extFieldMap.put("kdtest_extfield", "kdtest_extfield");
                 *         return extFieldMap;
                 *     }
                 * }
                 * </code></pre>
                 */
                getExtDownloadFieldMap():$.java.util.Map;
            }
            type IBankStatementField_T = IBankStatementField_S & IBankStatementField$;
            interface IBankStatementField extends IBankStatementField_T {
            }
        }
        namespace kd.sdk.fi.dhc.extpoint{
            interface ISynchronizationDataExtPlugin_S {
            }
            interface ISynchronizationDataExtPlugin$ {
                /**
                 * 接口调用时机：各场景下同步数据前获取映射配置关系时
                 *
                 * @param billType 要同步数据的单据类型。接入报账工作台的单据的实体编码
                 * @return 自定义增加的{billType}单与{dhc_mybilllist}的同步映射关系
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *     public class SynchronizationDataExtTestPlugin implements ISynchronizationDataExtPlugin {
                 *
                 *        @Override
                 *        public Map<String, String> addMappingFields(String billType) {
                 *            Map<String, String> mappingFields = new HashMap<>();
                 *            switch (billType) {
                 *                case "dhc_reimorder":
                 *                    mappingFields.put("extField", "biztype");
                 *                    break;
                 *                case "ssc_tallyapplybill":
                 *                    mappingFields.put("extField", "mainbiztype");
                 *                    mappingFields.put("entryentity.extEntryField", "tallyentryentity.bizdetailtype");
                 *                    break;
                 *                default:
                 *                    break;
                 *            }
                 *            return mappingFields;
                 *        }
                 *     }
                 *    </code></pre>
                 */
                addMappingFields?(billType:string):$.java.util.Map;
            }
            type ISynchronizationDataExtPlugin_T = ISynchronizationDataExtPlugin_S & ISynchronizationDataExtPlugin$;
            interface ISynchronizationDataExtPlugin extends ISynchronizationDataExtPlugin_T {
            }
        }
        namespace kd.sdk.fi.er.extpoint.ai{
            interface IAIReimburseService_S {
                readonly BIZCODE:string;
            }
            interface IAIReimburseService$ {
                /**
                 * 创建view和model后执行，用于修改model便于二开赋值
                 * @param view
                 * @param params 对话平台传进来的参数
                 * @return
                 */
                afterCreateView?(view:$.kd.bos.form.IFormView,params:$.java.util.Map):void;
                /**
                 * 初始化时修改实体标识、appid。
                 * @param plugin 智能语音报销的插件对象
                 * @return
                 */
                initDataMember?(plugin:$.kd.bos.bill.AbstractBillWebApiPlugin,params:$.java.util.Map):void;
                /**
                 * 生成返回给对话平台的结果集后触发，便于修改结果集
                 * @param view
                 * @param responseModel 返回给对话平台的结果
                 * @param params 对话平台传进来的参数
                 * @return
                 */
                responseModelExt?(view:$.kd.bos.form.IFormView,responseModel:any,params:$.java.util.Map):void;
            }
            type IAIReimburseService_T = IAIReimburseService_S & IAIReimburseService$;
            interface IAIReimburseService extends IAIReimburseService_T {
            }
        }
        namespace kd.sdk.fi.er.extpoint.dailyreimbursebill{
            interface IEntryMustInput_S {
            }
            interface IEntryMustInput$ {
                /**
                 * 返回true时，校验资产报账单资产分录必填，false不校验
                 * @param bill
                 * @return
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *    public class AssetentryMustInput implements IEntryMustInput {
                 *    @Override
                 *    public Boolean checkAssetEntryMustInput(DynamicObject bill) {
                 *    return Boolean.FALSE;
                 *    }
                 *    }
                 *    </code></pre>
                 */
                checkAssetEntryMustInput(bill:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type IEntryMustInput_T = IEntryMustInput_S & IEntryMustInput$;
            interface IEntryMustInput extends IEntryMustInput_T {
            }
            interface ITripStandardControl_S {
            }
            interface ITripStandardControl$ {
                /**
                 * 提交时是否要启用差旅标准
                 * @param DynamicObject 单据页面提交时的元数据
                 * @return boolean
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *            public class TripStandardControl implements ITripStandardControl {
                 *                    public Boolean controlTripStandard(DynamicObject dynamicObject) {
                 *                    return true;
                 *                }
                 *            }
                 *        </code></pre>
                 */
                controlTripStandard(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type ITripStandardControl_T = ITripStandardControl_S & ITripStandardControl$;
            interface ITripStandardControl extends ITripStandardControl_T {
            }
            interface ISuperClosedCallBack_S {
            }
            interface ISuperClosedCallBack$ {
                /**
                 * 在标准逻辑的 ClosedCallBack 执行之后进行个性处理
                 */
                afterClosedCallBack?(clazz:$.java.lang.Class,actionId:string,isPc:boolean,...params:any[]):void;
                /**
                 * 为true，执行标准逻辑；为false，则执行完此方法跳过标准逻辑
                 * @return 是否执行标准的closedCallBack
                 */
                beforeClosedCallBack?(clazz:$.java.lang.Class,actionId:string,isPc:boolean,...params:any[]):boolean;
                /**
                 * @param clazz      ShowFrom 所在的插件
                 * @param foromid    ShowFrom 即将打开的界面标识
                 * @param isPc       是否为PC端
                 * @param params     可变传参，
                 * @return 是否执行标准的view.showfrom; 为true，执行标准逻辑；为false，则执行完此方法跳过标准逻辑
                 */
                beforeShowFrom?(clazz:$.java.lang.Class,foromid:string,isPc:boolean,...params:any[]):boolean;
            }
            type ISuperClosedCallBack_T = ISuperClosedCallBack_S & ISuperClosedCallBack$;
            interface ISuperClosedCallBack extends ISuperClosedCallBack_T {
            }
            interface IWriteBackService_S {
            }
            interface IWriteBackService$ {
                /**
                 * 出纳付款单反写
                 * @return Object 必须实现kd.fi.er.mservice.botp.writeback.AbstractWriteBackServcie
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *    public class WriteBackService implements IWriteBackService {
                 *    public Object getSelfBackService() {
                 *    return new DailyLoanBillWriteBackService();
                 *    }
                 *    }
                 *    </code></pre>
                 */
                getSelfBackService():any;
            }
            type IWriteBackService_T = IWriteBackService_S & IWriteBackService$;
            interface IWriteBackService extends IWriteBackService_T {
            }
            interface IInitBillInfo_S {
            }
            interface IInitBillInfo$ {
                /**
                 * 费用报销单据新增初始化单据信息
                 * @param view 单据页面
                 * @return void
                 *
                 * <p>扩展示例如下</p>
                 *       <pre><code>
                 *        public class InitBillInfo implements IInitBillInfo{
                 *            public void initBillInfo(IFormView view) {
                 *                if (view == null){
                 *                    return;
                 *                }
                 *                Long companyId = 1247657405731330048L;//根据具体业务获取公司id
                 *                view.getModel().setValue("company", companyId);
                 *            }
                 *        }
                 *       </code></pre>
                 */
                initBillInfo(view:$.kd.bos.form.IFormView):void;
            }
            type IInitBillInfo_T = IInitBillInfo_S & IInitBillInfo$;
            interface IInitBillInfo extends IInitBillInfo_T {
            }
            interface IPayAmountCal_S {
            }
            interface IPayAmountCal$ {
                /**
                 * @param view 单据及界面
                 * @return 付现金额 返回类型为kd.fi.er.business.daily.reimburse.AmountObject 否则标准逻辑获取不到
                 *
                 * <p>扩展示例如下</p>
                 *          <pre><code>
                 *                public Object payAmountCalc(IFormView view) {
                 *                    if (view == null) {
                 *                        return null;
                 *                    }
                 *                    BigDecimal orgiPayAmount = (BigDecimal) view.getModel().getValue("orgiPayAmount");
                 *                    BigDecimal currPayAmount = (BigDecimal) view.getModel().getValue("orgiPayAmount");
                 *                    AmountObject result = new AmountObject(orgiPayAmount, currPayAmount);
                 *                    return result;
                 *                }
                 *         </code></pre>
                 */
                payAmountCalc(view:$.kd.bos.form.IFormView):any;
            }
            type IPayAmountCal_T = IPayAmountCal_S & IPayAmountCal$;
            interface IPayAmountCal extends IPayAmountCal_T {
            }
            interface IWriteOffMoney_S {
                readonly BIZCODE:string;
            }
            interface IWriteOffMoney$ {
                afterWriteoffWithholdingByCurrcy(dataModel:$.kd.bos.entity.datamodel.IDataModel):void;
                /**
                 * 冲预提分录联动 按原币冲销：费用明细 冲预提 相同币种冲销
                 * @param
                 */
                afterWriteoffWithholdingByOrgiCurrcy(dataModel:$.kd.bos.entity.datamodel.IDataModel):void;
            }
            type IWriteOffMoney_T = IWriteOffMoney_S & IWriteOffMoney$;
            interface IWriteOffMoney extends IWriteOffMoney_T {
            }
            interface IAmountControl_S {
            }
            interface IAmountControl$ {
                /**
                 * 提交时是否要超额判断逻辑
                 * @param DynamicObject 单据页面提交时的元数据
                 * @return boolean
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *        public class AmountControl implements IAmountControl {
                 *            public boolean cancelAmountControl(DynamicObject dynamicObject) {
                 *            //要超额判断
                 *            return true;
                 *            }
                 *        }
                 *    </code></pre>
                 */
                cancelAmountControl(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type IAmountControl_T = IAmountControl_S & IAmountControl$;
            interface IAmountControl extends IAmountControl_T {
            }
            interface IChangeReceiveAmount_S {
            }
            interface IChangeReceiveAmount$ {
                /**
                 * 允许二开在收款信息分录联动结束后，重新计算收款信息分录金额
                 * 作用于 kd.fi.er.formplugin.daily.web.util.WriteOffMoneyUtils.refreshReceiveAmount
                 *      kd.fi.er.formplugin.daily.web.util.WriteOffMoneyUtils#refreshReceiveAmount
                 * @param dataModel 页面model
                 * @param writeOffType 冲销方式
                 * @return kd.fi.er.business.daily.reimburse.AmountObject对象
                 */
                afterChangeReciveAmount?(dataModel:$.kd.bos.entity.datamodel.IDataModel,writeOffType:string):any;
                /**
                 * @param view 单据界面
                 * @return 是否联动收款金额
                 *
                 * <p>扩展示例如下</p>
                 *        <pre><code>
                 *            public boolean isChangeReceiveAmount(IFormView iFormView) {
                 *                return false;
                 *            }
                 *        </code></pre>
                 */
                isChangeReceiveAmount(view:$.kd.bos.form.IFormView):boolean;
            }
            type IChangeReceiveAmount_T = IChangeReceiveAmount_S & IChangeReceiveAmount$;
            interface IChangeReceiveAmount extends IChangeReceiveAmount_T {
            }
            interface IReimburseAmount_S {
            }
            interface IReimburseAmount$ {
                /**
                 * 获取获取在途的已用部门额度
                 * @param param
                 * @return
                 */
                getDeptCurrentInReimbursedAmountBetween(param:$.java.util.Map):$.java.util.List;
                /**
                 * 获取已报销的部门额度
                 * @param param
                 * @return
                 */
                getDeptReimbursedAmountBetween(param:$.java.util.Map):$.java.math.BigDecimal;
                /**
                 * 获取某个部门，某项费用项目，在某个时间区间内已报销的额度详情
                 * @param param
                 * @return
                 */
                getDeptReimbursedAmountDetailBetween(param:$.java.util.Map):$.java.util.List;
                /**
                 * 获取某个员工，某项费用项目，在某个时间区间内 正在报销流程中的单据金额（状态：已提交B，审核中C）
                 * @param param 额度处理参数key分别为 company 公司 dept/userid 部门或人员id expenseitem 费用项目
                 *              currency 本位币 begindate 开始时间 enddate 结束时间 existids
                 * @return 额度
                 *
                 * <p>扩展示例如下</p>
                 *        <pre><code>
                 *            public BigDecimal getEmployeeCurrentInReimbursedAmountBetween(Map<String, Object> map) {
                 *                BigDecimal result = BigDecimal.ZERO;
                 *                String amount = ErStdConfig.get("Amont.Ctrl.Ext.Dept");
                 *                result = new BigDecimal(amount);
                 *                if(result == null) {
                 *                    result = BigDecimal.ZERO;
                 *                }
                 *                return result;
                 *            }
                 *        </code></pre>
                 */
                getEmployeeCurrentInReimbursedAmountBetween(param:$.java.util.Map):$.java.math.BigDecimal;
                /**
                 * 获取某个员工，某项费用项目，在某个时间区间内已报销的额度
                 * @param param
                 * @return
                 */
                getEmployeeReimbursedAmountBetween(param:$.java.util.Map):$.java.math.BigDecimal;
                /**
                 * 获取某个员工，某项费用项目，在某个时间区间内已报销的额度详情
                 * @param param
                 * @return
                 */
                getEmployeeReimbursedAmountDetailBetween(param:$.java.util.Map):$.java.math.BigDecimal;
            }
            type IReimburseAmount_T = IReimburseAmount_S & IReimburseAmount$;
            interface IReimburseAmount extends IReimburseAmount_T {
            }
            interface IAssetentryMustInput_S {
            }
            interface IAssetentryMustInput$ {
                /**
                 * 返回true时，校验资产报账单资产分录必填，false不校验
                 * @param bill
                 * @return
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *    public class AssetentryMustInput implements IAssetentryMustInput {
                 *        @Override
                 *        public Boolean checkAssetEntryMustInput(DynamicObject bill) {
                 *        return Boolean.FALSE;
                 *        }
                 *    }
                 *    </code></pre>
                 */
                checkAssetEntryMustInput(bill:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type IAssetentryMustInput_T = IAssetentryMustInput_S & IAssetentryMustInput$;
            interface IAssetentryMustInput extends IAssetentryMustInput_T {
            }
        }
        namespace kd.sdk.fi.er.extpoint.draw{
            interface IDrawRuleService_S {
            }
            interface IDrawRuleService$ {
                /**
                 *  对于标准产品代码里写死的ruleid，允许现场通过此方法修改掉。
                 *  @param srcEntity 上拉的实体
                 *  @param tarEntity 目标实体
                 *  @param tarView  目标view
                 *  @param rows  选择的数据
                 *  @param ruleId 现有的ruleId
                 *  @return  期望的ruleId
                 *
                 *  <p>扩展示例如下</p>
                 *         <pre><code>
                 *             public String getRuleId(String srcEntity, String tarEntity, IFormView tarView, ListSelectedRowCollection rows,
                 * 			String ruleId) {
                 * 		//如果是二开的报销单上拉二开的借款单
                 * 		if("4b3z_er_dailyloanbill_inh".equals(srcEntity) && "4b3z_er_dailyreimbursebill_inh".equals(tarEntity)){
                 * 			return "123622523888";
                 * 		}
                 * 		//其他情况走原有规则不动
                 * 		return ruleId;
                 * 	}
                 *         </code></pre>
                 */
                getRuleId(srcEntity:string,tarEntity:string,tarView:$.kd.bos.form.IFormView,rows:$.kd.bos.entity.datamodel.ListSelectedRowCollection,ruleId:string):string;
            }
            type IDrawRuleService_T = IDrawRuleService_S & IDrawRuleService$;
            interface IDrawRuleService extends IDrawRuleService_T {
            }
        }
        namespace kd.sdk.fi.er.extpoint.invoicecloud{
            interface IAfterHandleBillPool_S {
                readonly BIZCODE:string;
            }
            interface IAfterHandleBillPool$ {
                /**
                 * 金额回写账单池后根据扩展参数二开处理
                 *
                 * @param extMap      扩展参数
                 * @param billingPool 目标账单池对象
                 */
                handleExtMapAfterAmountBack?(extMap:$.java.util.Map,billingPool:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 账单池对象生成后根据扩展参数二开处理
                 *
                 * @param extMap      扩展参数
                 * @param billingPool 目标账单池对象
                 * @return void
                 *
                 * <p>扩展示例如下</p>
                 *    <pre><code>
                 *    public class Test2 implements IAfterHandleBillPool{
                 *        public void handleExtMapAfterGenBillPool(Map<String, Object> extMap, DynamicObject billingPool) {
                 *            String tt =  extMap.get("testKey").toString();
                 *            billingPool.set("testKey",tt);
                 *        }
                 *
                 *        public void handleExtMapAfterAmountBack(Map<String, Object> extMap, DynamicObject billingPool) {
                 *            String tt =  extMap.get("testKey").toString();
                 *            billingPool.set("testKey",tt);
                 *        }
                 *    }
                 *    </code></pre>
                 */
                handleExtMapAfterGenBillPool?(extMap:$.java.util.Map,billingPool:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IAfterHandleBillPool_T = IAfterHandleBillPool_S & IAfterHandleBillPool$;
            interface IAfterHandleBillPool extends IAfterHandleBillPool_T {
            }
            interface IBeforeHandleBillPoolParamPrepare_S {
                readonly BIZCODE:string;
            }
            interface IBeforeHandleBillPoolParamPrepare$ {
                /**
                 * 金额回写账单池前扩展参数准备处理
                 *
                 * @param sourceBill 来源报销单对象
                 * @param extMap     扩展参数Map
                 */
                prepareExtParamBeforeAmountBack?(sourceBill:$.kd.bos.dataentity.entity.DynamicObject,extMap:$.java.util.Map):void;
                /**
                 * 生成账单池前扩展参数准备处理
                 *
                 * @param sourceBill 来源报销单对象
                 * @param extMap     扩展参数Map
                 * @return void
                 *
                 * <p>扩展示例如下</p>
                 *        <pre><code>
                 *        public class Test1 implements IBeforeHandleBillPoolParamPrepare{
                 *
                 *            public void prepareExtParamBeforeGenBillPool(DynamicObject sourceBill, Map<String, Object> extMap) {
                 *                extMap.put("testKey","prepareExtParamBeforeGenBillPool");
                 *            }
                 *
                 *            public void prepareExtParamBeforeAmountBack(DynamicObject sourceBill, Map<String, Object> extMap) {
                 *                extMap.put("testKey","prepareExtParamBeforeAmountBack");
                 *            }
                 *
                 *            public String prepareSelectPropertiesBeforeAmountBack(Map<String, Object> extMap) {
                 *                return ",testKey,usage";
                 *            }
                 *        }
                 *        </code></pre>
                 */
                prepareExtParamBeforeGenBillPool?(sourceBill:$.kd.bos.dataentity.entity.DynamicObject,extMap:$.java.util.Map):void;
                /**
                 * 金额回写账单池补充需要处理的账单池字段
                 *
                 * @param extMap     扩展参数Map
                 */
                prepareSelectPropertiesBeforeAmountBack?(extMap:$.java.util.Map):string;
            }
            type IBeforeHandleBillPoolParamPrepare_T = IBeforeHandleBillPoolParamPrepare_S & IBeforeHandleBillPoolParamPrepare$;
            interface IBeforeHandleBillPoolParamPrepare extends IBeforeHandleBillPoolParamPrepare_T {
            }
            interface AfterSelectInvoice_S {
                readonly BIZCODE:string;
            }
            interface AfterSelectInvoice$ {
                /**
                 *  选择发票后，缓存发票云传回的原始的发票json信息。
                 *  @param jsonFromInvoiceCloud 选择发票后，发票云传回的原始的发票json信息。
                 *  @return
                 *
                 *  <p>扩展示例如下
                 *  <pre><code>
                 * 	public class AfterSelectInvoiceDemo implements AfterSelectInvoice {
                 *
                 * 	private String jsonFromInvoiceCloud = null;
                 *
                 * 	@Override
                 * 	public void cacheJsonFromInvoiceCloud(String jsonFromInvoiceCloud){
                 * 		this.jsonFromInvoiceCloud = jsonFromInvoiceCloud;
                 * 	}
                 *
                 * }
                 *  </code></pre>
                 */
                cacheJsonFromInvoiceCloud?(jsonFromInvoiceCloud:string):void;
                /**
                 *  标准产品的代码根据发票信息完成发票信息分录、发票明细分录、费用/差旅明细分录等一切界面字段的填充后，调用此方法。<p>
                 *  @param view 单据界面的view
                 *  @return
                 *
                 *  <p>扩展示例如下
                 *
                 *  <pre><code>
                 * public class AfterSelectInvoiceDemo implements AfterSelectInvoice {
                 * 	private static final Log logger = LogFactory.getLog(AfterSelectInvoiceDemo.class);
                 *
                 * 	// 定义成员变量，缓存cacheJsonFromInvoiceCloud所传入的参数
                 * 	private String jsonFromInvoiceCloud = null;
                 *
                 * 	@Override
                 * 	public void cacheJsonFromInvoiceCloud(String jsonFromInvoiceCloud){
                 * 		logger.info("sdk: 选择发票后，缓存发票云传回的原始的发票json信息: " + jsonFromInvoiceCloud);
                 * 		this.jsonFromInvoiceCloud = jsonFromInvoiceCloud;
                 * 	}
                 *
                 * 	@Override
                 * 	public void finish(IFormView view){
                 * 		logger.info("sdk: 标准产品的代码根据发票信息完成发票信息分录、发票明细分录、费用/差旅明细分录等一切界面字段的填充后，调用此方法。");
                 * 		// 单据上的发票信息分录
                 * 		IDataModel model = view.getModel();
                 * 		DynamicObjectCollection invoiceentries = model.getEntryEntity("invoiceentry");
                 *
                 * 		// 发票云返回的原始发票信息
                 * 		Map<String, Object> mapFromInvoiceCloud = SerializationUtils.fromJsonString(this.jsonFromInvoiceCloud, Map.class);
                 * 		List<Map> invoiceInfos = (List)mapFromInvoiceCloud.get("data");
                 * 	}
                 * }
                 *  </code></pre>
                 */
                finish?(view:$.kd.bos.form.IFormView):void;
            }
            type AfterSelectInvoice_T = AfterSelectInvoice_S & AfterSelectInvoice$;
            interface AfterSelectInvoice extends AfterSelectInvoice_T {
            }
        }
        namespace kd.sdk.fi.er.extpoint.share{
            interface IAfterHandleShareLogic_S {
                readonly BIZCODE:string;
            }
            interface IAfterHandleShareLogic$ {
                /**
                 * 事前分摊生成摊销明细后根据扩展参数二开处理
                 * @param bill 目标单据对象
                 */
                handleLogicAfterBuildDoneEntry?(bill:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 预览摊销明细或事后分摊生成摊销明细后扩展处理
                 * @param view
                 */
                handleLogicAfterExpenseShareView?(view:$.kd.bos.form.IFormView):void;
                /**
                 * 自动生成分摊单字段二开逻辑
                 * @param reimbill 报销单据对象
                 * @param sharebill 分摊单据对象
                 */
                handleLogicAfterFillFields?(sharebill:$.kd.bos.dataentity.entity.DynamicObject,reimbill:$.kd.bos.dataentity.entity.DynamicObject):void;
                /**
                 * 注册二开属性处理
                 * @param entityName       单据类型
                 * @param preparePropertys 属性列表
                 */
                handleLogicAfterGetPreparePropertys?(entityName:string,preparePropertys:$.java.util.List):void;
            }
            type IAfterHandleShareLogic_T = IAfterHandleShareLogic_S & IAfterHandleShareLogic$;
            interface IAfterHandleShareLogic extends IAfterHandleShareLogic_T {
            }
        }
        namespace kd.sdk.fi.er.extpoint.trip{
            interface ITripCheckReqBillCloseService_S {
                readonly BIZCODE:string;
            }
            interface ITripCheckReqBillCloseService$ {
                /**
                 * 校验出差申请单是否可以关闭
                 * @param reqBill 出差申请单
                 * @param operateKey 操作类型
                 * @return true 可关闭，false 不可关闭
                 */
                checkReqBillClose(reqBill:$.kd.bos.dataentity.entity.DynamicObject,operateKey:string):boolean;
            }
            type ITripCheckReqBillCloseService_T = ITripCheckReqBillCloseService_S & ITripCheckReqBillCloseService$;
            interface ITripCheckReqBillCloseService extends ITripCheckReqBillCloseService_T {
            }
            interface ITripOrderUpdateReimService_S {
                readonly BIZCODE:string;
            }
            interface ITripOrderUpdateReimService$ {
                /**
                 * 订单追加差旅报销单扩展
                 * @param reim 差旅报销单
                 */
                orderUpdateReim(reim:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type ITripOrderUpdateReimService_T = ITripOrderUpdateReimService_S & ITripOrderUpdateReimService$;
            interface ITripOrderUpdateReimService extends ITripOrderUpdateReimService_T {
            }
            interface ITripCheckOrderUserStatusService_S {
                readonly BIZCODE:string;
            }
            interface ITripCheckOrderUserStatusService$ {
                /**
                 * 校验订单是否已使用
                 * @param dynamicObject orderbill
                 * @return true 已使用，false 未使用
                 */
                checkOrderUserStatus(dynamicObject:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type ITripCheckOrderUserStatusService_T = ITripCheckOrderUserStatusService_S & ITripCheckOrderUserStatusService$;
            interface ITripCheckOrderUserStatusService extends ITripCheckOrderUserStatusService_T {
            }
        }
        namespace kd.sdk.fi.fatvs.extpoint.skill{
            interface ISkillRunnableExtPlugin_S {
            }
            interface ISkillRunnableExtPlugin$ {
                /**
                 * 获取技能运行数据
                 *
                 * @param runExtContext
                 *            技能运行数据入参
                 * @return 技能运行数据
                 */
                pullData?(runExtContext:SkillRunExtContext):SkillRunExtResult;
                /**
                 * 展示技能使用情况指标
                 *
                 * @param indicatorParam
                 *            技能使用情况指标入参
                 */
                showSkillIndicator?(indicatorParam:SkillIndicatorParam):void;
                /**
                 * 展示技能运行分析页
                 *
                 * @param pageParam
                 *            技能分析页入参
                 */
                showSkillRunAnalysisPage?(pageParam:SkillRunAnalysisPageParam):void;
            }
            type ISkillRunnableExtPlugin_T = ISkillRunnableExtPlugin_S & ISkillRunnableExtPlugin$;
            interface ISkillRunnableExtPlugin extends ISkillRunnableExtPlugin_T {
            }
            interface SkillRunExtResult_S {
            }
            interface SkillRunExtResult_C extends SkillRunExtResult_S {
                new():SkillRunExtResult;
            }
            interface SkillRunExtResult$ {
                getData():$.java.util.List;
                getDate():Date;
                getEndTime():Date;
                getFailCount():number;
                getSkillNum():string;
                getStartTime():Date;
                getTotalCount():number;
                setData(data:$.java.util.List):void;
                setDate(date:Date):void;
                setEndTime(endTime:Date):void;
                setFailCount(failCount:number):void;
                setSkillNum(skillNum:string):void;
                setStartTime(startTime:Date):void;
                setTotalCount(totalCount:number):void;
            }
            type SkillRunExtResult_T = SkillRunExtResult_S & SkillRunExtResult$;
            interface SkillRunExtResult extends SkillRunExtResult_T {
            }
            interface SkillRunAnalysisPageParam_S {
            }
            interface SkillRunAnalysisPageParam_C extends SkillRunAnalysisPageParam_S {
                new():SkillRunAnalysisPageParam;
            }
            interface SkillRunAnalysisPageParam$ {
                getExtParam():$.java.util.Map;
                getSkillId():long;
                getSkillNum():string;
                getView():$.kd.bos.form.IFormView;
                setExtParam(extParam:$.java.util.Map):void;
                setSkillId(skillId:long):void;
                setSkillNum(skillNum:string):void;
                setView(view:$.kd.bos.form.IFormView):void;
            }
            type SkillRunAnalysisPageParam_T = SkillRunAnalysisPageParam_S & SkillRunAnalysisPageParam$;
            interface SkillRunAnalysisPageParam extends SkillRunAnalysisPageParam_T {
            }
            interface SkillIndicatorParam_S {
            }
            interface SkillIndicatorParam_C extends SkillIndicatorParam_S {
                new():SkillIndicatorParam;
            }
            interface SkillIndicatorParam$ {
                getExtParam():$.java.util.Map;
                getIndicatorNum():string;
                getSkillId():long;
                getSkillNum():string;
                getView():$.kd.bos.form.IFormView;
                setExtParam(extParam:$.java.util.Map):void;
                setIndicatorNum(indicatorNum:string):void;
                setSkillId(skillId:long):void;
                setSkillNum(skillNum:string):void;
                setView(view:$.kd.bos.form.IFormView):void;
            }
            type SkillIndicatorParam_T = SkillIndicatorParam_S & SkillIndicatorParam$;
            interface SkillIndicatorParam extends SkillIndicatorParam_T {
            }
            interface SkillRunExtContext_S {
            }
            interface SkillRunExtContext_C extends SkillRunExtContext_S {
                new():SkillRunExtContext;
            }
            interface SkillRunExtContext$ {
                getEndTime():Date;
                getSkillId():long;
                getSkillNum():string;
                getSkillResult():SkillRunExtResult;
                getStartTime():Date;
                setEndTime(endTime:Date):void;
                setSkillId(skillId:long):void;
                setSkillNum(skillNum:string):void;
                setSkillResult(skillResult:SkillRunExtResult):void;
                setStartTime(startTime:Date):void;
            }
            type SkillRunExtContext_T = SkillRunExtContext_S & SkillRunExtContext$;
            interface SkillRunExtContext extends SkillRunExtContext_T {
            }
        }
        namespace kd.sdk.fi.fca.extpoint{
            interface ITranSupBillVoucher_S {
            }
            interface ITranSupBillVoucher$ {
                /**
                 * 上划处理单凭证号扩展插件
                 * @param rows 列表数据
                 * @return void
                 *
                 * <b>扩展示例如下
                 *    <pre><code>
                 *    package kd.tmc.fca.formplugin.transbill;
                 *
                 *    import kd.bos.dataentity.entity.DynamicObject;
                 *    import kd.bos.dataentity.entity.DynamicObjectCollection;
                 *    import kd.sdk.fi.fca.extpoint.ITranSupBillVoucher;
                 *
                 *    public class TranSupBillVoucher implements ITranSupBillVoucher {
                 *    @Override
                 *    public void setIVoucher(DynamicObjectCollection rows) {
                 *    ITranSupBillVoucher.super.setIVoucher(rows);
                 *    for(DynamicObject row :rows){
                 *    row.set("description","123456");
                 *    }
                 *    }
                 *    }
                 *    </code></pre>
                 */
                setIVoucher?(rows:$.kd.bos.dataentity.entity.DynamicObjectCollection):void;
            }
            type ITranSupBillVoucher_T = ITranSupBillVoucher_S & ITranSupBillVoucher$;
            interface ITranSupBillVoucher extends ITranSupBillVoucher_T {
            }
        }
        namespace kd.sdk.fi.fcm.extpoint.checkitem{
            interface CheckContext_S {
            }
            type CheckContext_ST = $.java.io.Serializable & CheckContext_S;
            interface CheckContext_C extends CheckContext_ST {
            }
            interface CheckContext$ {
                /**
                 * 当前业务应用系统简码(非必须)
                 */
                getBizAppId():string;
                /**
                 * 核算组织ID
                 */
                getOrgId():long;
                /**
                 * 自定义期间结束时间, 一定不为null
                 */
                getPeriodEndDate():Date;
                /**
                 * 会计期间ID - 对于具体的应用可能不存在， 视调用方传参而定
                 */
                getPeriodId():long;
                /**
                 * 自定义期间开始时间, 一定不为null
                 */
                getPeriodStartDate():Date;
                /**
                 * 插件配置参数 - 用户在配置检查项时进行设置
                 */
                getPluginDefineParams():$.java.util.Map;
                /**
                 * 结账子业务类型，根据不同的业务系统有不同的主账簿类型
                 *     总账是账簿类型
                 *     资产是资产用途
                 *     应收是政策类型
                 *     库存是账簿类别
                 */
                setBizAppId(bizAppId:string):void;
            }
            type CheckContext_T = $.java.io.Serializable & CheckContext_S & CheckContext$;
            interface CheckContext extends CheckContext_T {
            }
            interface IClosePeriodCheckPlugin_S {
            }
            interface IClosePeriodCheckPlugin$ {
                /**
                 * 根据指定的结账检查上下文 context，实现特定的业务检查。
                 *
                 * Note: 插件必须提供一个无参构造函数，由执行程序通过反射进行调用
                 *
                 * @param context 结账检查上下文， 包含检查项定义的信息
                 * @return 结账检查结果
                 * @throws Throwable 检查项的逻辑异常
                 *
                 *     <p>扩展示例如下
                 *
                 *     <pre><code>
                 *         public class PostChecker implements IClosePeriodCheckPlugin {
                 *                &#64;Override
                 *                public CheckResult execute(CheckContext context) throws Throwable {
                 *     	        	CheckResult result = new CheckResult();
                 *     	        	QFilter post = new QFilter("ispost", "=", "0");
                 *     	        	boolean ispost = checkPost();
                 *     	        	if (!ispost) {
                 *     	        		result.setIsSuccess(true);
                 *                    } else {
                 *     	        		QFilter qf = new QFilter("booktype", QCP.equals, Long.valueOf(context.getSubBizAppId()));
                 *     	        		qf.and("ispost", QCP.equals, '0');
                 *     	        		qf.and("period", QCP.equals, context.getPeriodId());
                 *     	        		qf.and("org, QCP.equals, context.getOrgId());
                 *     	        		result.setIsSuccess(false);
                 *     	        		result.setOnlineQueryParams(qf.toSerializedString());
                 *     	        		result.setOnlineViewId("gl_voucher);
                 *     	        		List<String> errorMsg = new ArrayList<String>(1);
                 *     	        		errorMsg.add(ResManager.loadKDString("存在未过账", "VoucherPostChecker_0", "fi-gl-common"));
                 *     	        		result.setMessages(errorMsg);
                 *                    }
                 *     	        	return result;
                 *                }
                 *          }
                 *     </code></pre>
                 */
                execute(context:CheckContext):CheckResult;
            }
            type IClosePeriodCheckPlugin_T = IClosePeriodCheckPlugin_S & IClosePeriodCheckPlugin$;
            interface IClosePeriodCheckPlugin extends IClosePeriodCheckPlugin_T {
            }
            interface CheckResult_S {
            }
            type CheckResult_ST = $.java.io.Serializable & CheckResult_S;
            interface CheckResult_C extends CheckResult_ST {
                new():CheckResult;
            }
            interface CheckResult$ {
                /**
                 * 是否检查成功, 如果不成功，将会提供联查页面给客户联查
                 */
                setIsSuccess(success:boolean):void;
                /**
                 * 插件执行过程中返回的消息列表
                 */
                setMessages(messages:$.java.util.List):void;
                /**
                 * 联查页面数据过滤条件(参数), 该值做为联查页面视图的过滤条件，请确保该联查参数跟联查页面视图是匹配的
                 *
                 * 该参数的可能取值类型为:
                 * 1. 该参数可以为外部URL的查询参数，在<code>onlineViewId</code> 为URL协议开头时， 该参数会拼接到其后面，构成整个联查页面的
                 * URL， 参见 kd.bos.ext.fi.fcm.mservice.CheckItemDetail#buildExternalUrl()
                 * 2. 该参数如果为应用内的过滤条件，其为QFilter的序列化字符串
                 */
                setOnlineQueryParams(onlineQueryParams:string):void;
                /**
                 * 联查页面视图ID, 如果该值为null或empty, 将不会提供联查页面
                 * 既可以为应用内部的实体entityname, 也可以是外部URL，以http:// 或者https://开头
                 */
                setOnlineViewId(onlineViewId:string):void;
            }
            type CheckResult_T = $.java.io.Serializable & CheckResult_S & CheckResult$;
            interface CheckResult extends CheckResult_T {
            }
        }
        namespace kd.sdk.fi.fgptas.extpoint.attachment{
            interface IPictureAnalysis_S {
            }
            interface IPictureAnalysis$ {
                /**
                 * 把图片转换后的文本转化成自然语言，并放入提示词中
                 * @param pictureAnalysisResult
                 * @return
                 */
                toPrompt?(pictureAnalysisResult:string):string;
                /**
                 * 把图片转换成文本
                 * @param attachInfos 所有需要处理的图片信息<br/>
                 *                    数据来源附件面板服务，键值对参考附件面板服务的返回值 kd.bos.servicehelper.AttachmentServiceHelper#getAttachments<br/>
                 *                    在此扩展点可能用到的键：relativeUrl/url/previewurl: 相对路径/全路径/预览路径
                 * @return PictureAnalysisResult集合
                 *
                 * @see kd.bos.servicehelper.AttachmentServiceHelper#getAttachments(String, Object[], String, boolean)
                 * @see PictureAnalysisResult
                 */
                toText(attachInfos:$.java.util.List):$.java.util.List;
            }
            type IPictureAnalysis_T = IPictureAnalysis_S & IPictureAnalysis$;
            interface IPictureAnalysis extends IPictureAnalysis_T {
            }
            interface MultiScanPdfOrcResponse_S {
            }
            interface MultiScanPdfOrcResponse_C extends MultiScanPdfOrcResponse_S {
                new():MultiScanPdfOrcResponse;
            }
            interface MultiScanPdfOrcResponse$ {
                getData():MultiScanPdfOrcData;
                getErrCode():string;
                getErrMsg():string;
                getPageNum():number;
                isSuccess():boolean;
                setData(data:MultiScanPdfOrcData):void;
                setErrCode(errCode:string):void;
                setErrMsg(errMsg:string):void;
                setPageNum(pageNum:number):void;
                setSuccess(success:boolean):void;
            }
            type MultiScanPdfOrcResponse_T = MultiScanPdfOrcResponse_S & MultiScanPdfOrcResponse$;
            interface MultiScanPdfOrcResponse extends MultiScanPdfOrcResponse_T {
            }
            interface SealOcrResponse_S {
            }
            interface SealOcrResponse_C extends SealOcrResponse_S {
                new():SealOcrResponse;
                new(success:boolean,errCode:string,errMsg:string):SealOcrResponse;
            }
            interface SealOcrResponse$ {
                getErrCode():string;
                getErrMsg():string;
                getSealOcrResultList():$.java.util.List;
                isSuccess():boolean;
                setErrCode(errCode:string):void;
                setErrMsg(errMsg:string):void;
                setSealOcrResultList(sealOcrResultList:$.java.util.List):void;
                setSuccess(success:boolean):void;
            }
            type SealOcrResponse_T = SealOcrResponse_S & SealOcrResponse$;
            interface SealOcrResponse extends SealOcrResponse_T {
            }
            enum AttachmentType {
                PICTURE,
                TEXT
            }
            interface PreProcessResult_S {
            }
            interface PreProcessResult_C extends PreProcessResult_S {
                new():PreProcessResult;
            }
            interface PreProcessResult$ {
                getAttachTemplateId():long;
                getAuditElementParseResponse():AuditElementParseResponse;
                getExtractAuditElementCost():number;
                getExtractRequestId():string;
                getLlmParticipateStatus():LLMParticipateStatus;
                getMatchTemplateCost():number;
                getSealOcrResponse():SealOcrResponse;
                getTemplateRequestId():string;
                setAttachTemplateId(attachTemplateId:long):void;
                setAuditElementParseResponse(auditElementParseResponse:AuditElementParseResponse):void;
                setExtractAuditElementCost(extractAuditElementCost:number):void;
                setExtractRequestId(extractRequestId:string):void;
                setLlmParticipateStatus(llmParticipateStatus:LLMParticipateStatus):void;
                setMatchTemplateCost(matchTemplateCost:number):void;
                setSealOcrResponse(sealOcrResponse:SealOcrResponse):void;
                setTemplateRequestId(templateRequestId:string):void;
            }
            type PreProcessResult_T = PreProcessResult_S & PreProcessResult$;
            interface PreProcessResult extends PreProcessResult_T {
            }
            interface IAuditElementParser_S {
            }
            interface IAuditElementParser$ {
                /**
                 * 解析ocr结果
                 * @param ocrData ocrData
                 * @param attachTemplateId 附件模板编号
                 * @return 审核要素结果
                 * {
                 *     success:  是否解析成功  true/false
                 *     errCode: 错误码  错误码可以自己定义，错误时会将错误码和错误信息记录到审核要素结果中
                 *     errMsg: 错误信息
                 *     data：审核要素信息，做成JSONString(成功时会将data记录到审核要素结果)。JSON格式大概如下 eg:
                 *      {
                 *         "totalAmount":"总金额",   数据头分组的审核要素
                 *         "item":[{   数据分录分组的编号
                 *             "kind":"种类",  tem分组下的审核要素
                 *             "amount":"20.02"  tem分组下的审核要素
                 *         }]
                 *      }
                 * }
                 */
                parse(ocrData:OcrData,attachTemplateId:long):AuditElementParseResponse;
            }
            type IAuditElementParser_T = IAuditElementParser_S & IAuditElementParser$;
            interface IAuditElementParser extends IAuditElementParser_T {
            }
            interface OcrData_S {
            }
            interface OcrData_C extends OcrData_S {
                new():OcrData;
            }
            interface OcrData$ {
                getAttachmentSource():AttachmentSource;
                getFileType():string;
                getFileUrl():string;
                getOcrResultList():$.java.util.List;
                getOcrSysNo():string;
                getPreviewUrl():string;
                getSourceImgSys():string;
                setAttachmentSource(attachmentSource:AttachmentSource):void;
                setFileType(fileType:string):void;
                setFileUrl(fileUrl:string):void;
                setOcrResultList(ocrResultList:$.java.util.List):void;
                setOcrSysNo(ocrSysNo:string):void;
                setPreviewUrl(previewUrl:string):void;
                setSourceImgSys(sourceImgSys:string):void;
            }
            type OcrData_T = OcrData_S & OcrData$;
            interface OcrData extends OcrData_T {
            }
            enum LLMParticipateStatus {
                MATCH_TEMPLATE,
                EXTRACT_AUDIT_ELEMENT,
                ALL,
                NONE
            }
            interface MultiScanPdfOrcData_S {
            }
            interface MultiScanPdfOrcData_C extends MultiScanPdfOrcData_S {
                new():MultiScanPdfOrcData;
            }
            interface MultiScanPdfOrcData$ {
                getFileUrl():string;
                getOcrSysNo():string;
                getResult():any;
                setFileUrl(fileUrl:string):void;
                setOcrSysNo(ocrSysNo:string):void;
                setResult(result:any):void;
            }
            type MultiScanPdfOrcData_T = MultiScanPdfOrcData_S & MultiScanPdfOrcData$;
            interface MultiScanPdfOrcData extends MultiScanPdfOrcData_T {
            }
            interface IBillAuditHandler_S {
            }
            interface IBillAuditHandler$ {
                /**
                 *  接口调用时机：标品附件预处理之后
                 *
                 *  @param forceAll     是否强制执行
                 *  @param billId       单据id
                 *  @param entityNumber 单据实体标识
                 *  @param preResultId     附件预处理结果id
                 *
                 *  <p>扩展示例如下</p>
                 * <pre><code>
                 *  public class BillAuditHandlerTest implements IBillAuditHandler {
                 *      @Override
                 *      public void afterExecuteBillAudit(boolean forceAll, Object billId, String entityNumber, long preResultId) {
                 *          // 强制执行
                 *          if (forceAll) {
                 *              if (preResultId > 0) {
                 *                  // 查询预处理数据，执行业务拓展逻辑
                 *              }
                 *          } else {
                 *              // 非强制执行通过业务上处理的时间与预处理时间对比再判断是否需要执行业务拓展逻辑
                 *          }
                 *      }
                 *  }
                 * </code></pre>
                 */
                afterExecuteBillAudit(forceAll:boolean,billId:any,entityNumber:string,preResultId:long):void;
            }
            type IBillAuditHandler_T = IBillAuditHandler_S & IBillAuditHandler$;
            interface IBillAuditHandler extends IBillAuditHandler_T {
            }
            interface AuditElementParseResponse_S {
            }
            interface AuditElementParseResponse_C extends AuditElementParseResponse_S {
                new():AuditElementParseResponse;
            }
            interface AuditElementParseResponse$ {
                getData():string;
                getErrCode():string;
                getErrMsg():string;
                isSuccess():boolean;
                setData(data:string):void;
                setErrCode(errCode:string):void;
                setErrMsg(errMsg:string):void;
                setSuccess(success:boolean):void;
            }
            type AuditElementParseResponse_T = AuditElementParseResponse_S & AuditElementParseResponse$;
            interface AuditElementParseResponse extends AuditElementParseResponse_T {
            }
            interface IAttachPicturePreProcess_S {
            }
            interface IAttachPicturePreProcess$ {
                /**
                 * 图片附件预处理
                 * @param ocrData ocrData
                 * @return 预处理结果。
                 * 返回对象中
                 * attachTemplateId：匹配上的附件模板ID
                 * auditElementParseResponse:{
                 *     success:  是否解析成功  true/false
                 *     errCode: 错误码  错误码可以自己定义，错误时会将错误码和错误信息记录到审核要素结果中
                 *     errMsg: 错误信息
                 *     data：审核要素信息，做成JSONString(成功时会将data记录到审核要素结果)。JSON格式大概如下 eg:
                 *      {
                 *         "totalAmount":"总金额",   数据头分组的审核要素
                 *         "item":[{   数据分录分组的编号
                 *             "kind":"种类",  tem分组下的审核要素
                 *             "amount":"20.02"  tem分组下的审核要素
                 *         }]
                 *      }
                 * }
                 * llmParticipateStatus: 大模型参与状态枚举   MATCH_TEMPLATE(匹配附件模板) EXTRACT_AUDIT_ELEMENT(提取审核要素) ALL(都参与了) NONE(都没参与)
                 * matchTemplateCost:  匹配附件模板耗时(单位：毫秒)
                 * extractAuditElementCost:提取审核要素耗时(单位：毫秒)
                 */
                processPicture(ocrData:OcrData):PreProcessResult;
                /**
                 * 图片附件预处理（上面接口的增强实现，上面接口先一个迭代发布，不做删除）
                 * @param ocrData ocrData
                 * @param entityNumber 实体编码 用于过滤附件模板上的关联单据，加强模板匹配准确度，若不实现则默认使用全部
                 * @return
                 */
                processPicture(ocrData:OcrData,entityNumber:string):PreProcessResult;
            }
            type IAttachPicturePreProcess_T = IAttachPicturePreProcess_S & IAttachPicturePreProcess$;
            interface IAttachPicturePreProcess extends IAttachPicturePreProcess_T {
            }
            interface IAttachmentHandler_S {
            }
            interface IAttachmentHandler$ {
                /**
                 * 对附件进行分类，示例
                 * <pre>
                 *      AttachmentType clarifyAttachmentType(Map<String, Object> attachInfo) {
                 *          if ("txt".equalsIgnoreCase(attachInfo.get("type")) {
                 *               return AttachmentType.TEXT;
                 *           }
                 *           if ("jpg".equalsIgnoreCase(attachInfo.get("type")) {
                 *              return AttachmentType.PICTURE;
                 *           }
                 *           return null;
                 *      }
                 * </pre>
                 * @param attachInfo 图片信息<br/>
                 *                   数据来源附件面板服务，键值对参考附件面板服务的返回值 kd.bos.servicehelper.AttachmentServiceHelper#getAttachments<br/>
                 *                   在此扩展点可能用到的键：name/type: 附件名称/附件扩展名
                 * @return AttachmentType.PICTURE 或者 AttachmentType.TEXT，如果忽略这个附件返回null
                 * @see AttachmentType
                 */
                clarifyAttachmentType(attachInfo:$.java.util.Map):AttachmentType;
            }
            type IAttachmentHandler_T = IAttachmentHandler_S & IAttachmentHandler$;
            interface IAttachmentHandler extends IAttachmentHandler_T {
            }
            interface IMatchAttachTemplate_S {
            }
            interface IMatchAttachTemplate$ {
                /**
                 * ocr结果匹配附件模板，若没有匹配的附件模板，可返回null值，后续则会交给大模型做匹配
                 * @param ocrData ocr结果
                 * @return 附件模板基础资料的id，如果没有匹配合适的附件模板可以返回null，后续会交由大模型识别结果
                 */
                match(ocrData:OcrData):long;
            }
            type IMatchAttachTemplate_T = IMatchAttachTemplate_S & IMatchAttachTemplate$;
            interface IMatchAttachTemplate extends IMatchAttachTemplate_T {
            }
            enum AttachmentSource {
                ATTACHMENT,
                IMAGE_SYSTEM
            }
            interface OcrResponse_S {
            }
            interface OcrResponse_C extends OcrResponse_S {
                new():OcrResponse;
            }
            interface OcrResponse$ {
                getData():OcrData;
                getErrCode():string;
                getErrMsg():string;
                isSuccess():boolean;
                setData(data:OcrData):void;
                setErrCode(errCode:string):void;
                setErrMsg(errMsg:string):void;
                setSuccess(success:boolean):void;
            }
            type OcrResponse_T = OcrResponse_S & OcrResponse$;
            interface OcrResponse extends OcrResponse_T {
            }
            interface IOcr4Picture_S {
            }
            interface IOcr4Picture$ {
                /**
                 *  获取多页pdf的ocr结果
                 * @param filePath 文件路径
                 * @param fileNum  文件页码
                 */
                geMultiScanPdfOrcResult(filePath:string,fileNum:number):MultiScanPdfOrcResponse;
                /**
                 *  获取OCR结果
                 * @param filePath 文件路径
                 * @param fileType 文件类型（pdf、ofd...）
                 * @param attachmentSource 附件来源（附件、影像）
                 * @param sourceImgSys 来源影像系统
                 * @return ocrResponse
                 * {
                 *     success:  是否解析成功  true/false
                 *     errCode: 错误码  错误码可以自己定义，错误时会将错误码和错误信息记录到审核要素结果中
                 *     errMsg: 错误信息
                 *     ocrData：ocr识别结果及其他数据
                 *      {
                 *         "ocrSysNo":"BD",   执行本次OCR的外部ocr系统的编号
                 *         "fileUrl":"http://xxxxxx",   文件下载地址
                 *         "previewUrl": "http://xxxx",   预览地址
                 *         "fileType":"jpg",   文件类型,入参中的fileType
                 *         "sourceImgSys":"",  入参中的sourceImgSys
                 *         "attachmentSource":xx, 入参中的attachmentSource,
                 *         "ocrResultList"[
                 *              {
                 *                  "success": true/false,
                 *                  "result":{}  OCR结果
                 *              }
                 *         ]
                 *         "item":[{   数据分录分组的编号
                 *             "kind":"种类",  tem分组下的审核要素
                 *             "amount":"20.02"  tem分组下的审核要素
                 *         }]
                 *      }
                 * }
                 */
                getOcrResult(filePath:string,fileType:string,attachmentSource:AttachmentSource,sourceImgSys:string):OcrResponse;
                /**
                 * 获取印章OCR识别结果
                 * @param filePath 文件路径
                 * @param fileType 文件类型
                 * @param prePageNum 文件前几页
                 * @param lastPageNum 文件后几页
                 * @return 印章识别结果
                 */
                getSealOcrResult(filePath:string,fileType:string,prePageNum:number,lastPageNum:number):SealOcrResponse;
            }
            type IOcr4Picture_T = IOcr4Picture_S & IOcr4Picture$;
            interface IOcr4Picture extends IOcr4Picture_T {
            }
        }
        namespace kd.sdk.fi.fgptas.extpoint.decision{
            interface RuleRepoExecutionPlugin_S {
            }
            interface RuleRepoExecutionPlugin$ {
                /**
                 * @param parameter 调用参数
                 * @param ruleRepo  规则库
                 * @param modalPre  预处理结果
                 * @return 决策项结果
                 */
                process(parameter:RuleRepoParam,ruleRepo:$.kd.bos.dataentity.entity.DynamicObject,modalPre:$.kd.bos.dataentity.entity.DynamicObject):DecisionResultItem;
            }
            type RuleRepoExecutionPlugin_T = RuleRepoExecutionPlugin_S & RuleRepoExecutionPlugin$;
            interface RuleRepoExecutionPlugin extends RuleRepoExecutionPlugin_T {
            }
            interface DecisionResultItem_S {
                readonly STATUS_ALARMING:string;
                readonly STATUS_ERROR:string;
                readonly STATUS_GREEN:string;
                readonly STATUS_MISS:string;
                buildErr(showText:string):DecisionResultItem;
                buildFail(showText:string):DecisionResultItem;
                /**
                 *  构造失败返回
                 * @param showText 展示文本
                 * @param requestId 大模型会话id
                 * @return
                 */
                buildFail(showText:string,requestId:string):DecisionResultItem;
                buildMiss(showText:string):DecisionResultItem;
                buildSuccess(showText:string):DecisionResultItem;
                /**
                 *  构造成功返回
                 * @param showText 展示文本
                 * @param requestId 大模型会话id
                 * @return
                 */
                buildSuccess(showText:string,requestId:string):DecisionResultItem;
            }
            interface DecisionResultItem_C extends DecisionResultItem_S {
                new():DecisionResultItem;
            }
            interface DecisionResultItem$ {
                getFileNames():string[];
                getHoverContents():$.java.util.List;
                getLlmParticipateStatus():string;
                getRequestId():string;
                getShowText():string;
                getStatus():string;
                setFileNames(fileNames:string[]):void;
                setHoverContents(hoverContents:$.java.util.List):void;
                setLlmParticipateStatus(llmParticipateStatus:string):void;
                setRequestId(requestId:string):void;
                setShowText(showText:string):void;
                setStatus(status:string):void;
            }
            type DecisionResultItem_T = DecisionResultItem_S & DecisionResultItem$;
            interface DecisionResultItem extends DecisionResultItem_T {
            }
            interface FGPTASDecisionParam_S {
            }
            interface FGPTASDecisionParam_C extends FGPTASDecisionParam_S {
                new():FGPTASDecisionParam;
            }
            interface FGPTASDecisionParam$ {
                getBillId():long;
                getDecisionPk():string;
                getDescript():string;
                getEntityNumber():string;
                getSchemaId():long;
                isRefresh():boolean;
                setBillId(billId:long):void;
                setDecisionPk(decisionPk:string):void;
                setDescript(descript:string):void;
                setEntityNumber(entityNumber:string):void;
                setRefresh(refresh:boolean):void;
                setSchemaId(schemaId:long):void;
            }
            type FGPTASDecisionParam_T = FGPTASDecisionParam_S & FGPTASDecisionParam$;
            interface FGPTASDecisionParam extends FGPTASDecisionParam_T {
            }
            interface RuleRepoParam_S {
            }
            type RuleRepoParam_ST = FGPTASDecisionParam_S & RuleRepoParam_S;
            interface RuleRepoParam_C extends RuleRepoParam_ST {
                new():RuleRepoParam;
            }
            interface RuleRepoParam$ {
                getRuleRepoId():long;
                setRuleRepoId(ruleRepoId:long):void;
            }
            type RuleRepoParam_T = FGPTASDecisionParam & RuleRepoParam_S & RuleRepoParam$;
            interface RuleRepoParam extends RuleRepoParam_T {
            }
        }
        namespace kd.sdk.fi.fr.extpoint{
            interface IBankInfoF7Service_S {
            }
            interface IBankInfoF7Service$ {
                setBankF7Filter(listShowParameter:$.kd.bos.list.ListShowParameter,extArgs:string):$.kd.bos.list.ListShowParameter;
            }
            type IBankInfoF7Service_T = IBankInfoF7Service_S & IBankInfoF7Service$;
            interface IBankInfoF7Service extends IBankInfoF7Service_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.adjust{
            interface IPeriodEndAllowDulpicate_S {
                readonly BIZCODE:string;
            }
            interface IPeriodEndAllowDulpicate$ {
                /**
                 * 是否允许不同调汇方案下同科目、同币别、同核算维度值重复
                 * @return {@code true} 允许重复， {@code false} 不允许重复
                 */
                allowDulpicateSameDimensionValue():boolean;
            }
            type IPeriodEndAllowDulpicate_T = IPeriodEndAllowDulpicate_S & IPeriodEndAllowDulpicate$;
            interface IPeriodEndAllowDulpicate extends IPeriodEndAllowDulpicate_T {
            }
            interface IPeriodEndBalanceProcess_S {
                readonly BIZCODE:string;
            }
            interface IPeriodEndBalanceProcess$ {
                /**
                 * 处理标准产品的期末调汇科目余额数据
                 * 该方法对标准产品期末调汇方案查询到的科目余额进行处理，支持DataSet的所有操作，不允许减少或重命名standardDataSet字段
                 *
                 * <p>使用示例：</p>
                 * <pre>
                 * public class PeriodEndBalanceProcessImpl implements IPeriodEndBalanceProcess {
                 *     <code>@Override</code>
                 *     public DataSet balanceProcess(DataSet standardDataSet) {
                 *         // 取期末余额小于零的余额数据
                 *         return standardDataSet.where("endfor < 0");
                 *     }
                 * }
                 * </pre>
                 *
                 * @param id 期末调汇方案主键
                 * @param standardDataSet:  标准产品提供的科目余额数据集<br>
                 * standardDataSet字段说明：
                 * <table>
                 * <tr><th width="100px">字段</th><th>描述</th></tr>
                 * <tr><td>accountid</td><td>科目内码</td></tr>
                 * <tr><td>measureunit</td><td>计量单位</td></tr>
                 * <tr><td>acctnumber</td><td>科目编码</td></tr>
                 * <tr><td>acctdc</td><td>科目方向</td></tr>
                 * <tr><td>account</td><td>科目内码</td></tr>
                 * <tr><td>acctisqty</td><td>科目数量核算</td></tr>
                 * <tr><td>endfor</td><td>原币期末余额</td></tr>
                 * <tr><td>endlocal</td><td>本位币期末余额</td></tr>
                 * <tr><td>currency</td><td>币别</td></tr>
                 * <tr><td>assgrp</td><td>核算维度组合ID</td></tr>
                 * </table>
                 * @return kd.bos.algo.DataSet 二次过滤后的科目余额数据
                 * @since 7.0.1
                 */
                balanceProcess(id:long,standardDataSet:$.kd.bos.algo.DataSet):$.kd.bos.algo.DataSet;
            }
            type IPeriodEndBalanceProcess_T = IPeriodEndBalanceProcess_S & IPeriodEndBalanceProcess$;
            interface IPeriodEndBalanceProcess extends IPeriodEndBalanceProcess_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.amort{
            interface IAmountAllocate_S {
                readonly BIZCODE:string;
            }
            interface IAmountAllocate$ {
                /**
                 * 根据待摊凭证分录自定义转入的凭证分录
                 * @param destEntries   转入凭证分录，可进行自定义修改
                 * @param targetEntries 待摊凭证分录，对其的修改将无效
                 * @param schemeDyn     凭证摊销方案对象，可用来判断参数，对其的修改将无效
                 *
                 * <pre><code>
                 *  public class AmortExtTest implements IAmountAllocate {
                 *
                 *      public void dealDestEntries(List>DynamicObject< destEntries, List<DynamicObject> targetEntries, DynamicObject schemeDyn) {
                 *          destEntries.forEach(destRow->{
                 *              for (DynamicObject targetRow: targetEntries){
                 *                  if (destRow.getLong("assgrp_id") == targetRow.getLong("assgrp_id")){
                 *                      destRow.set("debitori", targetRow.getBigDecimal("creditori"));
                 *                      destRow.set("debitlocal", targetRow.getBigDecimal("creditlocal"));
                 *                  }
                 *              }
                 *          });
                 *      }
                 *  }
                 * </code></pre>
                 */
                dealDestEntries(destEntries:$.java.util.List,targetEntries:$.java.util.List,schemeDyn:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IAmountAllocate_T = IAmountAllocate_S & IAmountAllocate$;
            interface IAmountAllocate extends IAmountAllocate_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.bal{
            interface ICFBalCalculator_S {
                readonly BIZ_CODE:string;
            }
            interface ICFBalCalculator$ {
                /**
                 * 删除时事件触发，比如
                 * ID startperiod endperiod
                 * 1  120210020   120210040
                 * 2  120210040   120220050
                 * 3  120210050   99999999999 当删除ID为1的数据时，会把对应的余额数据的开始期间和结束期间作为参数传递
                 * @param orgId
                 * @param bookTypeId
                 * @param delDemension 被删除的维度
                 */
                deleteBal(orgId:long,bookTypeId:long,delDemension:$.java.util.List):void;
                /**
                 * 更新余额事件触发，此次发生余额变动的余额的modifytime》=updateTime
                 * @param orgId
                 * @param bookTypeId
                 * @param upadateTime
                 */
                updateBal(orgId:long,bookTypeId:long,upadateTime:Date):void;
            }
            type ICFBalCalculator_T = ICFBalCalculator_S & ICFBalCalculator$;
            interface ICFBalCalculator extends ICFBalCalculator_T {
            }
            interface IAcctBalCalculator_S {
                readonly BIZ_CODE:string;
            }
            interface IAcctBalCalculator$ {
                /**
                 * 删除时事件触发，比如
                 * ID startperiod endperiod
                 * 1  120210020   120210040
                 * 2  120210040   120220050
                 * 3  120210050   99999999999 当删除ID为1的数据时，会把对应的余额数据的开始期间和结束期间作为参数传递
                 * @param orgId
                 * @param bookTypeId
                 * @param delDemension 被删除的维度
                 */
                deleteBal(orgId:long,bookTypeId:long,delDemension:$.java.util.List):void;
                /**
                 * 更新余额事件触发，此次发生余额变动的余额的modifytime》=updateTime
                 * @param orgId
                 * @param bookTypeId
                 * @param upadateTime
                 */
                updateBal(orgId:long,bookTypeId:long,upadateTime:Date):void;
            }
            type IAcctBalCalculator_T = IAcctBalCalculator_S & IAcctBalCalculator$;
            interface IAcctBalCalculator extends IAcctBalCalculator_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.cashflow{
            interface ICashFlowQueryExtPlugin_S {
                readonly BIZ_CODE:string;
            }
            interface ICashFlowQueryExtPlugin$ {
                /**
                 * 根据报表查询参数，构建额外的现金流量项目过滤条件，用于过滤现金流量表界面展示的现金流量项目数据
                 *
                 * @param reportQueryParam 报表查询参数，只读对象，任何对该对象的修改均不会生效
                 * @return 针对现金流量项目实体（gl_cashflowitem）的增强过滤条件
                 */
                buildExtraCashFlowItemFilter(reportQueryParam:$.kd.bos.entity.report.ReportQueryParam):$.kd.bos.orm.query.QFilter;
            }
            type ICashFlowQueryExtPlugin_T = ICashFlowQueryExtPlugin_S & ICashFlowQueryExtPlugin$;
            interface ICashFlowQueryExtPlugin extends ICashFlowQueryExtPlugin_T {
            }
            interface ICashFlowItemMapping_S {
                readonly BIZ_CODE:string;
            }
            interface ICashFlowItemMapping$ {
                /**
                 * 根据现金流量映射关系映射到的现金流量项目ID
                 *
                 * @param orgId            组织ID
                 * @param accountTableId   科目表ID
                 * @param presetCfItems 现金流量映射需要用到的凭证分录属性值
                 * @return Map<PresetCashFlowItem, Long> 现金流量映射关系映射到的现金流量项目ID
                 */
                cfItemMappingRelation(orgId:long,accountTableId:long,presetCfItems:$.java.util.List):$.java.util.Map;
            }
            type ICashFlowItemMapping_T = ICashFlowItemMapping_S & ICashFlowItemMapping$;
            interface ICashFlowItemMapping extends ICashFlowItemMapping_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.notice{
            interface INoticeVoucherIdsProvider_S {
                readonly BIZCODE:string;
            }
            interface INoticeVoucherIdsProvider$ {
                /**
                 * 不需要过滤，需要返回参数参入的voucherIds。
                 * @param voucherIds 标准产品需要发送通知单的凭证ids
                 * @return 扩展插件过滤后需要发送通知单的凭证ids
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    package kd.sdk.fi.gl.extpoint.notice;
                 *    import java.util.Set;
                 *    public class NoticeVoucherIdsProviderImpl implements INoticeVoucherIdsProvider{
                 *    @Override
                 *    public Set<Long> customFilterVchIds(Set<Long> voucherIds) {
                 *    //自定义逻辑
                 *    return voucherIds;
                 *    }}
                 *    </code></pre>
                 */
                customFilterVchIds(voucherIds:$.java.util.Set):$.java.util.Set;
            }
            type INoticeVoucherIdsProvider_T = INoticeVoucherIdsProvider_S & INoticeVoucherIdsProvider$;
            interface INoticeVoucherIdsProvider extends INoticeVoucherIdsProvider_T {
            }
            interface INoticeVoucherSourceType_S {
                readonly AUTOTRANS_VALUE:string;
                readonly BIZCODE:string;
                readonly CARRY_OVER:string;
                readonly FROMIMPORT:string;
                readonly HANDCRAFT_VALUE:string;
                readonly MECHANISM_VALUE:string;
                readonly OFFSET:string;
                readonly PERIOD_END_EXCHANGERATE_ADJUSTMENT_VALUE:string;
                readonly PROFIT_AND_LOSS_VALUE:string;
                readonly SCAN_VALUE:string;
                readonly SCHEMA_VALUE:string;
                readonly SYCBOOK:string;
                readonly VOUCHERAMORT_VALUE:string;
                readonly VOUCHER_REF:string;
            }
            interface INoticeVoucherSourceType$ {
                /**
                 * 自定义校验接口
                 * @return 不发送通知单的凭证来源类型集合。目前标准产品结转损益类型的凭证不发通知，无需再控制。
                 * @throws
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    package kd.sdk.fi.gl.extpoint.notice;
                 *
                 *    import java.util.ArrayList;
                 *    import java.util.List;
                 *
                 *    public class NoticeVoucherSourceTypeCtl implements INoticeVoucherSourceType{
                 *
                 *    @Override
                 *    public List<String> noSendNoticeSourceType() {
                 *    List<String> sourceTypes = new ArrayList<>(6);
                 *    sourceTypes.add(PERIOD_END_EXCHANGERATE_ADJUSTMENT_VALUE);//来源类型为期末调汇的凭证不发通知单。
                 *    return sourceTypes;
                 *    }
                 *    }
                 *    </code></pre>
                 */
                noSendNoticeSourceType():$.java.util.List;
            }
            type INoticeVoucherSourceType_T = INoticeVoucherSourceType_S & INoticeVoucherSourceType$;
            interface INoticeVoucherSourceType extends INoticeVoucherSourceType_T {
            }
            interface INoticeCheck_S {
                readonly BIZCODE:string;
            }
            interface INoticeCheck$ {
                /**
                 * 自定义校验接口
                 * @param sendList 发送通知单列表,receiveList 接收通知单列表
                 * @return 是，检查通过，否，检查不通过
                 * @throws
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    package hx.fi.gl.extpoint.notice;
                 *    import kd.bos.report.ReportList;
                 *    import kd.sdk.fi.gl.extpoint.notice.INoticeCheck;
                 *
                 *    public class HxNoticeCHeck implements INoticeCheck {
                 *        public boolean extCheck(ReportList sendList, ReportList receiveList) {
                 *            if(sendList ==null||receiveList==null){
                 *                return false;
                 *            }
                 *            ...
                 *            return false;
                 *        }
                 *    }
                 *    </code></pre>
                 */
                extCheck(sendList:$.kd.bos.report.ReportList,receiveList:$.kd.bos.report.ReportList):boolean;
            }
            type INoticeCheck_T = INoticeCheck_S & INoticeCheck$;
            interface INoticeCheck extends INoticeCheck_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.report{
            interface IReportQuery_S {
                readonly BIZCODE:string;
            }
            interface IReportQuery$ {
                /**
                 * 往来对账单扩展
                 */
                acCheck(standardDataSet:$.kd.bos.algo.DataSet,reportQueryParam:$.kd.bos.entity.report.ReportQueryParam,selectedObj:any):$.kd.bos.algo.DataSet;
                /**
                 * 多组织辅助明细账扩展
                 */
                auxSubLedger(standardDataSet:$.kd.bos.algo.DataSet,reportQueryParam:$.kd.bos.entity.report.ReportQueryParam,selectedObj:any):$.kd.bos.algo.DataSet;
                /**
                 * 辅助明细账扩展
                 * @param standardDataSet 标准产品报表查询数据集合
                 * @param reportQueryParam 报表查询参数
                 * @param selectedObj 左表选中对象(如有)
                 * @return 扩展处理后数据集合
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    import kd.bos.algo.DataSet;
                 *    import kd.bos.entity.report.FilterInfo;
                 *    import kd.bos.entity.report.ReportQueryParam;
                 *
                 *    public class ExtReportQuery implements IReportQuery{
                 *
                 *    @Override
                 *    public DataSet subLedger(DataSet standardDataSet, ReportQueryParam reportQueryParam, Object selectedObj) {
                 *            DataSet extDataSet = standardDataSet;
                 *            FilterInfo filter = reportQueryParam.getFilter();
                 *            if(filter.getBoolean("showqty")){
                 *                extDataSet = extDataSet.addField("10L", "cusQty");
                 *            }
                 *            return extDataSet;
                 *        }
                 *
                 *        @Override
                 *        public DataSet auxSubLedger(DataSet standardDataSet, ReportQueryParam reportQueryParam, Object selectedObj) {
                 *            DataSet extDataSet = standardDataSet;
                 *            return extDataSet;
                 *        }
                 *
                 *        @Override
                 *        public DataSet acCheck(DataSet standardDataSet, ReportQueryParam reportQueryParam, Object selectedObj) {
                 *            DataSet extDataSet = standardDataSet;
                 *            return extDataSet;
                 *        }
                 *    }
                 *    </code></pre>
                 */
                subLedger(standardDataSet:$.kd.bos.algo.DataSet,reportQueryParam:$.kd.bos.entity.report.ReportQueryParam,selectedObj:any):$.kd.bos.algo.DataSet;
            }
            type IReportQuery_T = IReportQuery_S & IReportQuery$;
            interface IReportQuery extends IReportQuery_T {
            }
            interface ReportParam_S {
            }
            interface ReportParam_C extends ReportParam_S {
                new(reportType:ReportParam$ReportType,queryParam:$.kd.bos.entity.report.ReportQueryParam):ReportParam;
            }
            interface ReportParam$ {
                /**
                 * @return 报表查询的查询参数
                 */
                getQueryParam():$.kd.bos.entity.report.ReportQueryParam;
                /**
                 * @return 报表类型，用于识别是那张报表
                 */
                getReportType():ReportParam$ReportType;
            }
            type ReportParam_T = ReportParam_S & ReportParam$;
            interface ReportParam extends ReportParam_T {
            }
            enum ReportParam$ReportType {
                UNSUPPORTED,
                SUB_LEDGER,
                SUBSI_DIARY_LEDGER,
                AUX_SUB_LEDGER,
                GENERAL_LEDGER,
                MULTI_COLUMN_ACCOUNT
            }
            interface IReportRowHideSpi_S {
                readonly BIZCODE:string;
            }
            interface IReportRowHideSpi$ {
                /**
                 * @param param 报表查询上下文
                 * @param rowType 行类型
                 * @return 返回Ture则隐藏该报表查询结果集中对应rowType的所有列
                 *
                 * <p>扩展示例如下
                 *    <pre><code>
                 *    package kd.sdk.fi.gl.extpoint.report;
                 *
                 *    import kd.bos.algo.DataSet;
                 *    import kd.bos.entity.report.FilterInfo;
                 *
                 *    public class SummaryFilter implements IReportRowHideSpi {
                 *
                 *        @Override
                 *        public Boolean needHide(ReportParam param, RowType rowType) {
                 *            switch (param.getReportType()) {
                 *                case SUB_LEDGER:
                 *                    FilterInfo filter = param.getQueryParam().getFilter();
                 *                    if(!filter.getBoolean("showsummary")) {
                 *                        //明细分类账过滤本期合计
                 *                        return rowType == RowType.ROW_TYPE_BEGIN;
                 *                    }
                 *                    break;
                 *                case AUX_SUB_LEDGER:
                 *                case SUBSI_DIARY_LEDGER:
                 *                    break;
                 *            }
                 *            return false;
                 *        }
                 *    }
                 *    </code></pre>
                 */
                needHide(param:ReportParam,rowType:RowType):boolean;
            }
            type IReportRowHideSpi_T = IReportRowHideSpi_S & IReportRowHideSpi$;
            interface IReportRowHideSpi extends IReportRowHideSpi_T {
            }
            enum RowType {
                ROW_TYPE_BEGIN,
                ROW_TYPE_LEAF,
                ROW_TYPE_DAILY,
                ROW_TYPE_PERIOD,
                ROW_TYPE_YEAR,
                ROW_TOTAL_SUMMARY
            }
            interface IAccBalReportQuery_S {
                readonly BIZCODE:string;
            }
            interface IAccBalReportQuery$ {
                /**
                 * 根据查询参数判断是否启用扩展插件
                 * @return 返回为真时科目余额表查询的其他方法均走本插件
                 */
                enable?(queryParam:$.kd.bos.entity.report.ReportQueryParam):boolean;
                /**
                 * 同kd.bos.entity.report.IReportListDataPlugin#export
                 * @param ignored 该参数为报表查询的选中节点，科目余额表暂时未使用
                 */
                export?(queryParam:$.kd.bos.entity.report.ReportQueryParam,ignored:any):$.kd.bos.algo.DataSet;
                /**
                 * 同kd.bos.entity.report.IReportListDataPlugin#exportWithSheet
                 * @param ignored 该参数为报表查询的选中节点，科目余额表暂时未使用
                 */
                exportWithSheet?(queryParam:$.kd.bos.entity.report.ReportQueryParam,ignored:any):$.java.util.List;
                /**
                 * 同kd.bos.entity.report.IReportListDataPlugin#getColumns
                 */
                getColumns?(columns:$.java.util.List):$.java.util.List;
                /**
                 * 在IAccBalReportQuery#getColumns结果的基础上对报表列
                 * 进行修改属性、排序等操作。
                 */
                handleColumns?(columns:$.java.util.List):$.java.util.List;
                /**
                 * 同kd.bos.entity.report.IReportListDataPlugin#query
                 * @param ignored 该参数为报表查询的选中节点，科目余额表暂时未使用
                 */
                query?(queryParam:$.kd.bos.entity.report.ReportQueryParam,ignored:any):$.kd.bos.algo.DataSet;
                /**
                 * 同kd.bos.entity.report.IReportListDataPlugin#queryBatchBy
                 */
                queryBatchBy?(queryParam:$.kd.bos.entity.report.ReportQueryParam):$.kd.bos.algo.DataSet;
            }
            type IAccBalReportQuery_T = IAccBalReportQuery_S & IAccBalReportQuery$;
            interface IAccBalReportQuery extends IAccBalReportQuery_T {
            }
            interface IReportColumnSetting_S {
                readonly BIZCODE:string;
            }
            interface IReportColumnSetting$ {
                /**
                 * 科目余额表
                 * @param columns 报表列集合
                 * @param reportQueryParam 界面查询参数
                 * @return
                 */
                acctBal(columns:$.java.util.List,reportQueryParam:$.kd.bos.entity.report.ReportQueryParam):void;
                /**
                 * 核算维度余额表
                 * @param columns 报表列集合
                 * @param reportQueryParam 界面查询参数
                 * @return
                 */
                assistBal(columns:$.java.util.List,reportQueryParam:$.kd.bos.entity.report.ReportQueryParam):void;
                /**
                 * 总分类账
                 * @param columns 报表列集合
                 * @param reportQueryParam 界面查询参数
                 * @return
                 */
                generalLedger(columns:$.java.util.List,reportQueryParam:$.kd.bos.entity.report.ReportQueryParam):void;
            }
            type IReportColumnSetting_T = IReportColumnSetting_S & IReportColumnSetting$;
            interface IReportColumnSetting extends IReportColumnSetting_T {
            }
            interface IAccBalOrgNumberOrder_S {
                readonly BIZCODE:string;
            }
            interface IAccBalOrgNumberOrder$ {
                /**
                 * 科目余额表扩展接口
                 * @param standardDataSet 标品报表集合
                 * @param filterInfo 报表查询过滤条件
                 * @param orgs 组织id集合
                 * @return
                 */
                process(standardDataSet:$.kd.bos.algo.DataSet,filterInfo:$.kd.bos.entity.report.FilterInfo,orgs:$.java.util.Set):$.kd.bos.algo.DataSet;
            }
            type IAccBalOrgNumberOrder_T = IAccBalOrgNumberOrder_S & IAccBalOrgNumberOrder$;
            interface IAccBalOrgNumberOrder extends IAccBalOrgNumberOrder_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.syncbookvch{
            interface AccountAssgrpMappingParam_S {
            }
            interface AccountAssgrpMappingParam_C extends AccountAssgrpMappingParam_S {
                new(srcBookId:long,tarBookId:long):AccountAssgrpMappingParam;
                new(srcBookId:long,tarBookId:long,voucherIdList:$.java.util.List):AccountAssgrpMappingParam;
            }
            interface AccountAssgrpMappingParam$ {
                getSrcBookId():long;
                getTarBookId():long;
                getVoucherIdList():$.java.util.List;
            }
            type AccountAssgrpMappingParam_T = AccountAssgrpMappingParam_S & AccountAssgrpMappingParam$;
            interface AccountAssgrpMappingParam extends AccountAssgrpMappingParam_T {
            }
            interface AccountAssgrpMapping_S {
            }
            interface AccountAssgrpMapping_C extends AccountAssgrpMapping_S {
                new():AccountAssgrpMapping;
                new(srcAccNum:string,srcAssgrpId:long,tarAccNum:string,tarAssgrpMap:$.java.util.Map):AccountAssgrpMapping;
            }
            interface AccountAssgrpMapping$ {
                getSrcAccNum():string;
                getSrcAssgrpId():long;
                getTarAccNum():string;
                getTarAssgrpMap():$.java.util.Map;
                setSrcAccNum(srcAccNum:string):void;
                setSrcAssgrpId(srcAssgrpId:long):void;
                setTarAccNum(tarAccNum:string):void;
                setTarAssgrpMap(tarAssgrpMap:$.java.util.Map):void;
            }
            type AccountAssgrpMapping_T = AccountAssgrpMapping_S & AccountAssgrpMapping$;
            interface AccountAssgrpMapping extends AccountAssgrpMapping_T {
            }
            interface IAccountAssgrpMapping_S {
                readonly BIZ_CODE:string;
            }
            interface IAccountAssgrpMapping$ {
                /**
                 * @param param 映射关系表依赖的参数
                 * @return 二开自定义的科目映射关系List
                 */
                dealMapping(param:AccountAssgrpMappingParam):$.java.util.List;
            }
            type IAccountAssgrpMapping_T = IAccountAssgrpMapping_S & IAccountAssgrpMapping$;
            interface IAccountAssgrpMapping extends IAccountAssgrpMapping_T {
            }
        }
        namespace kd.sdk.fi.gl.extpoint.voucher{
            interface IVoucherReversalDescPlugin_S {
            }
            interface IVoucherReversalDescPlugin$ {
                /**
                 * 根据凭证头获取摘要的构建器
                 *
                 * @param voucher 被冲销凭证头
                 * @return 摘要的构建器，可以根据给定的分录返回摘要信息
                 */
                getDescriptionBuilder(voucher:$.kd.bos.dataentity.entity.DynamicObject):IDescriptionBuilder;
            }
            type IVoucherReversalDescPlugin_T = IVoucherReversalDescPlugin_S & IVoucherReversalDescPlugin$;
            interface IVoucherReversalDescPlugin extends IVoucherReversalDescPlugin_T {
            }
            interface IDescriptionBuilder_S {
            }
            interface IDescriptionBuilder$ {
                /**
                 * 根据分录构建凭证摘要
                 *
                 * @param entry 被冲销分录行
                 * @return 摘要
                 */
                build(entry:$.kd.bos.dataentity.entity.DynamicObject):string;
            }
            type IDescriptionBuilder_T = IDescriptionBuilder_S & IDescriptionBuilder$;
            interface IDescriptionBuilder extends IDescriptionBuilder_T {
            }
        }
        namespace kd.sdk.fi.ict.extpoint{
            interface IAutoReconcValidate_S {
                readonly BIZCODE:string;
            }
            interface IAutoReconcValidate$ {
                /**
                 * @param bRecordIdList 本方交易对账数据
                 * @param dRecordIdList 对方交易数据
                 * @param infoMap
                 * org->本方组织id
                 * oppoorg->对方组织id
                 * period->期间id
                 * currency->币别id
                 * verifyscheme->对账方案id
                 * bRecordIdList，dRecordIdList为本对方方交易对账数据id，因为自动对账是单条去对账的，为了避免每次对账都去查询数据，
                 * 可以用infoMap里面的条件再加上单据状态去查询该对账方案的所有交易对账数据集合，然后再用bRecordIdList，dRecordIdList中的id去获取数据
                 * @return 无校验住数据返回null，有校验数据需要组装成String类型的提示语
                 */
                noDiffManualAutoValidate?(bRecordIdList:$.java.util.List,dRecordIdList:$.java.util.List,infoMap:$.java.util.Map):string;
            }
            type IAutoReconcValidate_T = IAutoReconcValidate_S & IAutoReconcValidate$;
            interface IAutoReconcValidate extends IAutoReconcValidate_T {
            }
        }
        namespace kd.sdk.fi.qitc.extpoint.inspect{
            interface ITaskRectiferService_S {
            }
            interface ITaskRectiferService$ {
                /**
                 * 设置整改人
                 *
                 * @param taskId 质检任务Id
                 * @param billId 单据Id
                 * @param extMap 其它入参Map
                 * @return 扩展点返回结果   Example: map.put("rectifer", "整改人（Long类型）")
                 */
                setReformPerson(taskId:long,billId:long,extMap:$.java.util.Map):$.java.util.Map;
            }
            type ITaskRectiferService_T = ITaskRectiferService_S & ITaskRectiferService$;
            interface ITaskRectiferService extends ITaskRectiferService_T {
            }
        }
    }
}
export {};