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

/// <reference types="../../@cosmic/bos-script" />
/// <reference types="../../@cosmic/bos-core" />
declare global {
    namespace $ {
        namespace kd.sdk.tmc{
            interface SdkTmcModule_S {
            }
            type SdkTmcModule_ST = $.kd.sdk.module.Module & SdkTmcModule_S;
            interface SdkTmcModule_C extends SdkTmcModule_ST {
                new():SdkTmcModule;
            }
            interface SdkTmcModule$ {
            }
            type SdkTmcModule_T = $.kd.sdk.module.Module & SdkTmcModule_S & SdkTmcModule$;
            interface SdkTmcModule extends SdkTmcModule_T {
            }
        }
        namespace kd.sdk.tmc.am.extpoint.bankacct{
            interface ILinkPayRelationAddCompanyFilter_S {
            }
            interface ILinkPayRelationAddCompanyFilter$ {
                /**
                 * 支付关系维护分录的母账户的过滤条件中添加申请公司
                 * @param companyIdList 母账户过滤的申请公司
                 *
                 * <p>扩展示例如下
                 * <pre>
                 *      <code>
                 *              import java.util.Set;
                 *              import kd.sdk.tmc.am.extpoint.bankacct.ILinkPayRelationAddCompanyFilter;
                 *
                 *              public class LinkPayRelationAddCompany implements ILinkPayRelationAddCompanyFilter {
                 *
                 *                  public void parentAcctAddCompanyIdList(Set<Object> companyIdList){
                 *                          companyIdList.add(1L);
                 *                  }
                 *              }
                 *      </code>
                 * </pre>
                 */
                parentAcctAddCompanyIdList?(companyIdList:$.java.util.Set):void;
            }
            type ILinkPayRelationAddCompanyFilter_T = ILinkPayRelationAddCompanyFilter_S & ILinkPayRelationAddCompanyFilter$;
            interface ILinkPayRelationAddCompanyFilter extends ILinkPayRelationAddCompanyFilter_T {
            }
            interface IBankAccountFilter_S {
            }
            interface IBankAccountFilter$ {
                /**
                 * 银行账户增加“是否虚拟账户”字段方法1
                 * @param args  页面的过滤条件
                 * @param formView  页面的参数
                 * @return void
                 *
                 * <p>扩展示例如下
                 *     <pre><code>
                 *     import kd.bos.form.IFormView;
                 *     import kd.bos.form.events.FilterContainerInitArgs;
                 *
                 *     public class BankAccountFilter implements IBankAccountFilter {
                 *
                 *         public void addIFilterColumn(FilterContainerInitArgs args, IFormView formView) {
                 *
                 *         }
                 *     }
                 *     </code></pre>
                 */
                addIFilterColumn?(args:$.kd.bos.form.events.FilterContainerInitArgs,formView:$.kd.bos.form.IFormView):void;
                /**
                 * 银行账户增加“是否虚拟账户”字段方法2
                 * @param e  页面的事件
                 * @param formView  页面的参数
                 * @return void
                 *
                 * <p>扩展示例如下
                 *     <pre><code>
                 *     import kd.bos.form.IFormView;
                 *     import kd.bos.form.events.SetFilterEvent;
                 *
                 *     public class BankAccountFilter implements IBankAccountFilter {
                 *
                 *        public void setIFilters(SetFilterEvent e, IFormView formView) {
                 *
                 *         }
                 *     }
                 *     </code></pre>
                 */
                setIFilters?(e:$.kd.bos.form.events.SetFilterEvent,formView:$.kd.bos.form.IFormView):void;
            }
            type IBankAccountFilter_T = IBankAccountFilter_S & IBankAccountFilter$;
            interface IBankAccountFilter extends IBankAccountFilter_T {
            }
        }
        namespace kd.sdk.tmc.am.extpoint.inspect{
            interface IInspectPushMyself_S {
            }
            interface IInspectPushMyself$ {
                /**
                 * 账户巡检处理单自定义下推获取目标单实体
                 * @param srcOpinion    变更前处理意见
                 * @return              实体编码
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.am.extpoint.inspect;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import java.util.List;
                 *
                 * public String getDestEntity(String srcOpinion) {
                 *
                 *   return "am_test_aaa";
                 * }</code></pre>
                 */
                getDestEntity(srcOpinion:string):string;
                /**
                 * 账户巡检处理单自定义下推销户申请与变更申请
                 * @param opKey         操作标识：audit || unaudit || changedeal || handpush
                 * @param data          整个巡检处理单对象
                 * @param entryList     只包含处理意见=账户销户或者账户变更的数据
                 * @return              是否自己处理  默认false 返回true 不会执行标品下推等逻辑
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.am.extpoint.inspect;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import java.util.List;
                 *
                 * public boolean isDealMyselfPush(String opKey, DynamicObject data, List<DynamicObject> entryList) {
                 *
                 *   return false;
                 * }</code></pre>
                 */
                isDealMyselfPush(opKey:string,data:$.kd.bos.dataentity.entity.DynamicObject,entryList:$.java.util.List):boolean;
            }
            type IInspectPushMyself_T = IInspectPushMyself_S & IInspectPushMyself$;
            interface IInspectPushMyself extends IInspectPushMyself_T {
            }
        }
        namespace kd.sdk.tmc.am.extpoint.report{
            interface IDormantFormListFilter_S {
            }
            interface IDormantFormListFilter$ {
                /**
                 * 久悬户查询增加过滤条件可”是否包含虚拟户”
                 * @param qFilters 页面的过滤条件
                 * @param filter 传递的参数
                 * @return void
                 *
                 * <p>扩展示例如下
                 *     <pre><code>
                 *     import kd.bos.entity.report.FilterInfo;
                 *     import kd.bos.orm.query.QFilter;
                 *
                 *     import java.util.List;
                 *
                 *     public class DormantFormListFilter implements IDormantFormListFilter {
                 *
                 *        public void setIFilters(List<QFilter> qFilters, FilterInfo filter) {
                 *            qFilters.add(new QFilter("isinclude", QCP.equals, filter.getString("isinclude")));
                 *            qFilters.add(new QFilter("name", QCP.equals, filter.getString("name")));
                 *        }
                 *     }
                 *     </code></pre>
                 */
                setIFilters?(qFilters:$.java.util.List,filter:$.kd.bos.entity.report.FilterInfo):void;
            }
            type IDormantFormListFilter_T = IDormantFormListFilter_S & IDormantFormListFilter$;
            interface IDormantFormListFilter extends IDormantFormListFilter_T {
            }
        }
        namespace kd.sdk.tmc.bei.extpoint.balance{
            interface IFillBankBalance_S {
            }
            interface IFillBankBalance$ {
                /**
                 * 同步余额增加字段支持二开扩展
                 * @param bankBalance         处理的余额数据
                 * @param balanceString       银企云返回的余额数据
                 *
                 * <p>扩展示例如下
                 * <pre><code>
                 *
                 *  package kd.sdk.tmc.bei.extpoint.balance;
                 *
                 * import com.alibaba.fastjson.JSON;
                 * import com.alibaba.fastjson.JSONObject;
                 * import kd.bos.dataentity.entity.DynamicObject;
                 *
                 * public class FillBankBalanceExt implements IFillBankBalance {
                 *
                 *     public void fillExtBankBalance(DynamicObject bankBalance, String balanceString) {
                 *         JSONObject jsonObject = JSON.parseObject(balanceString);
                 *         bankBalance.set("", jsonObject.getString(""));
                 *     }
                 *
                 * }
                 * </code></pre>
                 */
                fillExtBankBalance(bankBalance:$.kd.bos.dataentity.entity.DynamicObject,balanceString:string):void;
            }
            type IFillBankBalance_T = IFillBankBalance_S & IFillBankBalance$;
            interface IFillBankBalance extends IFillBankBalance_T {
            }
            interface IGenHistoryBalanceInterface_S {
            }
            interface IGenHistoryBalanceInterface$ {
                /**
                 *  用于获取二开可以执行自动计算历史余额的银企直连账户的主键ID
                 *  @return  银企直连账户的主键ID
                 *
                 *  <p>扩展示例如下
                 *  <pre><code>
                 *  package kd.sdk.tmc.bei.extpoint.balance;
                 *
                 * import java.util.HashSet;
                 * import java.util.Set;
                 *
                 * public class GenHistoryBalanceInterfaceExt implements IGenHistoryBalanceInterface {
                 *
                 *     public Set<Long> getExtAccountBankIds() {
                 *         HashSet<Long> bankAccountIds = new HashSet<>();
                 *         // 返回需要扩展处理的银企账户ID
                 *         bankAccountIds.add(1L);
                 *         return bankAccountIds;
                 *     }
                 * }
                 * </code></pre>
                 */
                getExtAccountBankIds():$.java.util.Set;
            }
            type IGenHistoryBalanceInterface_T = IGenHistoryBalanceInterface_S & IGenHistoryBalanceInterface$;
            interface IGenHistoryBalanceInterface extends IGenHistoryBalanceInterface_T {
            }
            interface IBalanceReportInterface_S {
            }
            interface IBalanceReportInterface$ {
                /**
                 * 余额报表添加账户字段扩展点
                 * @return 需要扩展的字段
                 * <p>扩展示例如下
                 *
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.balance;
                 *
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 *
                 * public class BalanceReportExt implements IBalanceReportInterface{
                 *
                 *     public String getAccountFields() {
                 *         // 需要查询的字段名，类别扩展增加相同属性名称的列
                 *         return "acctstatus,defaultcurrency";
                 *     }
                 * }</code></pre>
                 */
                getAccountFields():string;
                /**
                 * 余额报表条件过滤扩展点
                 * @param qFilter 查询条件
                 * @return 查询条件
                 *
                 * <p>拓展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.balance;
                 *
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 *
                 * public class BalanceReportExt implements IBalanceReportInterface{
                 *
                 *     public QFilter getAccountFilter(QFilter qFilter) {
                 *
                 *         // 增加账户过滤内容
                 *         qFilter.and("bankaccountnumber", QCP.equals, "FI-00000000000CNY44");
                 *         return qFilter;
                 *     }
                 * }</code></pre>
                 */
                getAccountFilter(qFilter:$.kd.bos.orm.query.QFilter):$.kd.bos.orm.query.QFilter;
            }
            type IBalanceReportInterface_T = IBalanceReportInterface_S & IBalanceReportInterface$;
            interface IBalanceReportInterface extends IBalanceReportInterface_T {
            }
        }
        namespace kd.sdk.tmc.bei.extpoint.bankpay{
            interface IAfterBankPayQueryExt_S {
            }
            interface IAfterBankPayQueryExt$ {
                /**
                 * 获取银企同步付款状态接口备用字段对应银行付款单二开字段标识
                 *
                 * 银企同步付款状态接口备用字段标识
                 * String reversed1;
                 * String reversed2;
                 * String reversed3;
                 * String reversed4;
                 *
                 * @return Map<String, String>   key: 银企同步付款状态接口备用字段标识   value: 备用字段对应的银行付款单二开字段标识
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.bankpay;
                 *
                 * import java.util.HashMap;
                 * import java.util.Map;
                 * import kd.sdk.tmc.bei.extpoint.bankpay.IAfterBankPayQueryExt;
                 *
                 * public class BankPayQueryServiceExtPlugin implements IAfterBankPayQueryExt {
                 *
                 *     public Map<String, String> getExtReversedFields() {
                 *         Map<String, String> extFieldsMap = new HashMap<>(4);
                 *         extFieldsMap.put("reversed1", "kdext_field1");
                 *         extFieldsMap.put("reversed2", "kdext_field2");
                 *         extFieldsMap.put("reversed3", "kdext_field3");
                 *         extFieldsMap.put("reversed4", "kdext_field4");
                 *         return extFieldsMap;
                 *     }
                 *
                 * }</code></pre>
                 */
                getExtReversedFields?():$.java.util.Map;
            }
            type IAfterBankPayQueryExt_T = IAfterBankPayQueryExt_S & IAfterBankPayQueryExt$;
            interface IAfterBankPayQueryExt extends IAfterBankPayQueryExt_T {
            }
            interface IBankPayDetailExt_S {
            }
            interface IBankPayDetailExt$ {
                /**
                 * 获取提交银企付款明细二开扩展字段
                 *
                 * 银企付款明细可扩展字段标识（可持续补充）
                 * 跨境TT付款 汇款人城市 汇款人省份 汇款人地址
                 * String payerCity;
                 * String payerProvince;
                 * String payerAddress;
                 *
                 * @return Map<String, String>   key: 银企付款明细可扩展字段标识   value: 对应的银行付款单二开扩展字段标识
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.bankpay;
                 *
                 * import java.util.HashMap;
                 * import java.util.Map;
                 * import kd.sdk.tmc.bei.extpoint.bankpay.IBankPayDetailExt;
                 *
                 * public class BankPayDetailExtPlugin implements IBankPayDetailExt {
                 *
                 *     public Map<String, String> getPayDetailExtFields() {
                 *         Map<String, String> extFieldsMap = new HashMap<>(4);
                 *         extFieldsMap.put("payerCity", "kdext_payerCity");
                 *         extFieldsMap.put("payerProvince", "kdext_payerProvince");
                 *         extFieldsMap.put("payerAddress", "kdext_payerAddress");
                 *         return extFieldsMap;
                 *     }
                 *
                 * }</code></pre>
                 */
                getPayDetailExtFields?():$.java.util.Map;
            }
            type IBankPayDetailExt_T = IBankPayDetailExt_S & IBankPayDetailExt$;
            interface IBankPayDetailExt extends IBankPayDetailExt_T {
            }
            interface IBankPayExtDataExt_S {
            }
            interface IBankPayExtDataExt$ {
                /**
                 * 获取提交银企付款二开扩展字段
                 *
                 * @return Set<String>   key: 银行付款单二开扩展字段标识
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.bankpay;
                 *
                 * import java.util.HashSet;
                 * import java.util.Set;
                 * import kd.sdk.tmc.bei.extpoint.bankpay.IBankPayExtDataExt;
                 *
                 * public class BankPayExtDataExtPlugin implements IBankPayExtDataExt {
                 *
                 *     public Set<String> getPayExtDataFields() {
                 *         Set<String> extFieldsSet = new HashSet<>(4);
                 *         extFieldsSet.add("kdext_extDataField1");
                 *         extFieldsSet.add("kdext_extDataField2");
                 *         extFieldsSet.add("kdext_extDataField3");
                 *         return extFieldsSet;
                 *     }
                 *
                 * }</code></pre>
                 */
                getPayExtDataFields?():$.java.util.Set;
            }
            type IBankPayExtDataExt_T = IBankPayExtDataExt_S & IBankPayExtDataExt$;
            interface IBankPayExtDataExt extends IBankPayExtDataExt_T {
            }
        }
        namespace kd.sdk.tmc.bei.extpoint.claim{
            interface INoticeClaimSchemeInterface_S {
            }
            interface INoticeClaimSchemeInterface$ {
                /**
                 * 取消通知认领对象拓展
                 * “取消通知认领”操作时触发扩展。
                 *
                 * @param noticeObjectMap "billid"  交易明细ID
                 *                        "ruleentryid"  通知规则ID
                 *                        "isneednotice"  是否发送通知，默认为true
                 * @return Map<String, Object> key:"userids", value:userIdList
                 *
                 * <p>拓展示例如下
                 * <pre><code>package kd.tmc.bei.business;
                 *
                 * import kd.sdk.tmc.bei.extpoint.claim.INoticeClaimSchemeInterface;
                 *
                 * import java.util.ArrayList;
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class NoticeClaimSchemesDefaultExt implements INoticeClaimSchemeInterface {
                 *
                 *     public Map<String, Object> cancelNoticeObjectExt(Map<String, Object> noticeObjectMap) {
                 *         // 获取交易明细ID
                 *         Long billId = (Long) noticeObjectMap.get("billid");
                 *         // 获取通知规则分录ID
                 *         Long ruleEntryId = (Long) noticeObjectMap.get("ruleentryid");
                 *
                 *         // 是否发送通知，默认为true
                 *         noticeObjectMap.put("isneednotice", false);
                 *
                 *         return noticeObjectMap;
                 *     }
                 * }</code></pre>
                 */
                cancelNoticeObjectExt?(noticeObjectMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 通知认领对象拓展
                 * 扩展调用时机：“通知认领”操作匹配到通知规则且在【通知规则】界面选择的是“自定义”时触发扩展
                 * 注：当扩展此场景时会覆盖 kd.sdk.fi.cas.extpoint.noticeclaim.INoticeClaimSchemeInterface.noticeObjectExt 扩展场景
                 *
                 * @param noticeObjectMap "billid"  交易明细ID
                 *                        "ruleentryid"  通知规则ID
                 *                        "isneednotice"  是否发送通知，默认为true
                 * @return Map<String, Object> key:"userids", value:userIdList
                 *
                 * <p>拓展示例如下
                 * <pre><code>package kd.tmc.bei.business;
                 *
                 * import kd.sdk.tmc.bei.extpoint.claim.INoticeClaimSchemeInterface;
                 *
                 * import java.util.ArrayList;
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class NoticeClaimSchemesDefaultExt implements INoticeClaimSchemeInterface {
                 *
                 *     public Map<String, Object> noticeObjectExtByRule(Map<String, Object> noticeObjectMap) {
                 *         // 获取交易明细ID
                 *         Long billId = (Long) noticeObjectMap.get("billid");
                 *         // 获取通知规则分录ID
                 *         Long ruleEntryId = (Long) noticeObjectMap.get("ruleentryid");
                 *
                 *         // 自定义通知对象用户ID
                 *         List<Object> userIds = new ArrayList<>(2);
                 *         userIds.add(1540672005563544576L);
                 *         noticeObjectMap.put("userids", userIds);
                 *
                 *         // 是否发送通知，默认为true
                 *         noticeObjectMap.put("isneednotice", false);
                 *
                 *         return noticeObjectMap;
                 *     }
                 * }</code></pre>
                 */
                noticeObjectExtByRule?(noticeObjectMap:$.java.util.Map):$.java.util.Map;
            }
            type INoticeClaimSchemeInterface_T = INoticeClaimSchemeInterface_S & INoticeClaimSchemeInterface$;
            interface INoticeClaimSchemeInterface extends INoticeClaimSchemeInterface_T {
            }
        }
        namespace kd.sdk.tmc.bei.extpoint.receipt{
            interface IAfterReceiptRecognition_S {
            }
            interface IAfterReceiptRecognition$ {
                /**
                 * 基于OCR识别后的已有信息设置客制化规则
                 * @param recognizeDetailJson JsonString 电子回单ocr识别结果序列化对象 kd.tmc.bei.common.constants.ReceiptRecongnizeDetail
                 * @return JsonString 二开处理后的识别结果序列化对象
                 *
                 * 电子回单识别明细对象 - kd.tmc.bei.common.constants.ReceiptRecongnizeDetail
                 *
                 * 对象属性：
                 *
                 * 交易日期
                 * String ftradeDate;
                 * 收款人&付款人银行账户信息
                 * 户名
                 * String fpayeeName;
                 * String fpaymentName;
                 * 银行账号
                 * String fpayeeAccount;
                 * String fpaymentAccount;
                 * 开户行
                 * String fpayeeBank;
                 * String fpaymentBank;
                 * 金额
                 * String famount;
                 * 币别
                 * String fcurrency;
                 * 借贷标记 贷-收 借-付
                 * String ftradeType;
                 * 交易流水号
                 * String ftradeId;
                 * 业务参考号
                 * String ftradeNumber;
                 * String fabstract;
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.receipt;
                 *
                 * import kd.bos.dataentity.serialization.SerializationUtils;
                 * import kd.bos.logging.Log;
                 * import kd.bos.logging.LogFactory;
                 * import kd.bos.util.ExceptionUtils;
                 * import kd.sdk.tmc.bei.extpoint.receipt.IAfterReceiptRecognition;
                 * import kd.tmc.bei.common.constants.ReceiptRecongnizeDetail;
                 * import kd.tmc.bei.common.enums.LendingDirectionEnum;
                 *
                 * public class ReceiptRecognitionResultExtPlugin implements IAfterReceiptRecognition {
                 * private static final Log logger = LogFactory.getLog(ReceiptRecognitionResultExtPlugin.class);
                 *
                 *     public String fillRecognitionResult(String recognizeDetailJson) {
                 *         try {
                 *             //反序列化对象
                 *             ReceiptRecongnizeDetail recognizeDetail = SerializationUtils.fromJsonString(recognizeDetailJson, ReceiptRecongnizeDetail.class);
                 *             recognizeDetail.setFpaymentAccount("ABC777");
                 *             recognizeDetail.setFcurrency("CNY");
                 *             //借贷方向涉及多语言 建议使用枚举赋值
                 *             recognizeDetail.setFtradeType(LendingDirectionEnum.OUT.getDirect());
                 *             //处理后序列化返回
                 *             recognizeDetailJson = SerializationUtils.toJsonString(recognizeDetail);
                 *         } catch (Exception e) {
                 *             logger.warn("电子回单识别 -- 二开处理识别结果反异常：" + ExceptionUtils.getExceptionStackTraceMessage(e));
                 *         }
                 *         return recognizeDetailJson;
                 *     }
                 * }</code></pre>
                 */
                fillRecognitionResult?(recognizeDetailJson:string):string;
            }
            type IAfterReceiptRecognition_T = IAfterReceiptRecognition_S & IAfterReceiptRecognition$;
            interface IAfterReceiptRecognition extends IAfterReceiptRecognition_T {
            }
            interface IReceiptMatchTransDetail_S {
            }
            interface IReceiptMatchTransDetail$ {
                /**
                 * 电子回单匹配交易明细后，电子回单、交易明细赋值逻辑二开扩展
                 * @param matchRel 电子回单：交易明细关系：one-one，one-many，many-one
                 * @param receipts 电子回单单据信息
                 * @param details  交易明细单据信息
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.receipt;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import java.util.List;
                 *
                 * public class ReceiptMatchTransDetail implements IReceiptMatchTransDetail{
                 *
                 *     public void afterMatchFieldValueCover(String matchRel, List<DynamicObject> receipts, List<DynamicObject> details) {
                 *         switch (matchRel){
                 *             case "one-one"://一对一
                 *                 DynamicObject receipt = receipts.get(0);
                 *                 receipt.set("keyField", "value");
                 *                 DynamicObject detail = details.get(0);
                 *                 detail.set("keyField", "value");
                 *                 break;
                 *             case "one-many"://一对多
                 *                 DynamicObject receipt1 = receipts.get(0);
                 *                 receipt1.set("keyField", "value");
                 *                 for (DynamicObject detail1 : details) {
                 *                     detail1.set("keyField", "value");
                 *                 }
                 *                 break;
                 *             case "many-one"://多对一
                 *                 for (DynamicObject receipt2 : receipts) {
                 *                     receipt2.set("keyField", "value");
                 *                 }
                 *                 DynamicObject detail2 = details.get(0);
                 *                 detail2.set("keyField", "value");
                 *                 break;
                 *             default:
                 *                 break;
                 *         }
                 *     }
                 * }
                 * </code></pre>
                 */
                afterMatchFieldValueCover(matchRel:string,receipts:$.java.util.List,details:$.java.util.List):void;
            }
            type IReceiptMatchTransDetail_T = IReceiptMatchTransDetail_S & IReceiptMatchTransDetail$;
            interface IReceiptMatchTransDetail extends IReceiptMatchTransDetail_T {
            }
        }
        namespace kd.sdk.tmc.bei.extpoint.transdetail{
            interface IDeleteTransDetail_S {
            }
            interface IDeleteTransDetail$ {
                /**
                 * 添加允许删除的条件（针对交易明细实体拥有的属性）
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.transdetail;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.orm.query.QFilter;
                 *
                 * public class DeleteTransDetail implements IDeleteTransDetail{
                 *
                 *     public void getQfilterCanDelete() {
                 *         // 在交易明细上做了二开字段作为了业务控制，可以在此处设置限制交易明细哪些能被删除，避免交易明细被标准流程删除
                 *         return new QFilter("二开属性", QFilter.equals, "允许删除的条件");
                 *     }
                 * }</code></pre>
                 */
                getQfilterCanDelete():$.kd.bos.orm.query.QFilter;
            }
            type IDeleteTransDetail_T = IDeleteTransDetail_S & IDeleteTransDetail$;
            interface IDeleteTransDetail extends IDeleteTransDetail_T {
            }
            interface ITransDetailKDFlagInterface_S {
            }
            interface ITransDetailKDFlagInterface$ {
                /**
                 * 交易明细KD标识扩展点
                 * @param scene 场景名称：
                 *              1.payruleenter: 付款按规则生单
                 *              2.recruleenter: 收款按规则生单
                 *              3.marknoneed: 标记为无需确认
                 *              4.markconfirmed：直接标记已确认
                 *              5.payhand: 付款手工生单
                 *              6.rechand: 收款手工生单
                 *              7.noticeclaim: 通知认领
                 * @param transDetailIds 交易明细id集合
                 * @return key：交易明细id，value：是否跳过KD标识校验
                 *
                 * <p>拓展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.transdetail;
                 *
                 * import java.util.HashMap;
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class TransDetailKDFlagExt implements ITransDetailKDFlagInterface{
                 *
                 *     public Map<Long, Boolean> skipKDFlagCheck(String scene, List<Long> transDetailIds) {
                 *         Map<Long, Boolean> map = new HashMap<>();
                 *         if (transDetailIds != null && !transDetailIds.isEmpty()) {
                 *             for (Long transDetailId : transDetailIds) {
                 *                 map.put(transDetailId, true);
                 *             }
                 *         }
                 *         return map;
                 *     }
                 * }</code></pre>
                 */
                skipKDFlagCheck(scene:string,transDetailIds:$.java.util.List):$.java.util.Map;
            }
            type ITransDetailKDFlagInterface_T = ITransDetailKDFlagInterface_S & ITransDetailKDFlagInterface$;
            interface ITransDetailKDFlagInterface extends ITransDetailKDFlagInterface_T {
            }
            interface IFillTransDetail_S {
            }
            interface IFillTransDetail$ {
                /**
                 * 提交银企，单据生成银行单据，用于二开字段数据填充
                 * @param info 交易明细
                 * @param extData 交易明细扩展字段信息
                 *
                 * <p>扩展示例如下
                 * <pre><code>package kd.sdk.tmc.bei.extpoint.transdetail;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import com.alibaba.fastjson.JSON;
                 * import com.alibaba.fastjson.JSONObject;
                 *
                 * public class FillTransDetail implements IFillTransDetail{
                 *
                 *     public void fillExtData(DynamicObject info,String extData) {
                 *         JSONObject jsonObject = JSON.parseObject(extData);
                 *         info.setString("",jsonObject.getString(""));
                 *     }
                 * }</code></pre>
                 */
                fillExtData(info:$.kd.bos.dataentity.entity.DynamicObject,extData:string):void;
            }
            type IFillTransDetail_T = IFillTransDetail_S & IFillTransDetail$;
            interface IFillTransDetail extends IFillTransDetail_T {
            }
        }
        namespace kd.sdk.tmc.bei.util{
            interface AutoMatchInfoParam_S {
            }
            type AutoMatchInfoParam_ST = $.java.io.Serializable & AutoMatchInfoParam_S;
            interface AutoMatchInfoParam_C extends AutoMatchInfoParam_ST {
                new(sourceEntity:string,transDetailNumber:string,transDetailId:long,recedBillType:string,recedBillNumber:string,recedBillId:long,recedBillEntryId:long,currency:long,traceType:string,amount:$.java.math.BigDecimal,bankCheckFlag:string,bizDate:Date):AutoMatchInfoParam;
                new(sourceEntity:string,transDetailNumber:string,transDetailId:long,recedBillType:string,recedBillNumber:string,recedBillId:long,recedBillEntryId:long,currency:long,traceType:string,amount:$.java.math.BigDecimal,bankCheckFlag:string,bizDate:Date,thisOpnumber:string,direction:string):AutoMatchInfoParam;
            }
            interface AutoMatchInfoParam$ {
                getAmount():$.java.math.BigDecimal;
                getBankCheckFlag():string;
                getBizDate():Date;
                getCurrency():long;
                getDifferMatchSourceEntity():string;
                getDirection():string;
                getRecedBillEntryId():long;
                getRecedBillId():long;
                getRecedBillNumber():string;
                getRecedBillType():string;
                getSourceEntity():string;
                getThisOpnumber():string;
                getTraceType():string;
                getTransDetailId():long;
                getTransDetailNumber():string;
                setAmount(amount:$.java.math.BigDecimal):void;
                setBankCheckFlag(bankCheckFlag:string):void;
                setBizDate(bizDate:Date):void;
                setCurrency(currency:long):void;
                setDifferMatchSourceEntity(differMatchSourceEntity:string):void;
                setDirection(direction:string):void;
                setRecedBillEntryId(recedBillEntryId:long):void;
                setRecedBillId(recedBillId:long):void;
                setRecedBillNumber(recedBillNumber:string):void;
                setRecedBillType(recedBillType:string):void;
                setSourceEntity(sourceEntity:string):void;
                setThisOpnumber(thisOpnumber:string):void;
                setTraceType(traceType:string):void;
                setTransDetailId(transDetailId:long):void;
                setTransDetailNumber(transDetailNumber:string):void;
            }
            type AutoMatchInfoParam_T = $.java.io.Serializable & AutoMatchInfoParam_S & AutoMatchInfoParam$;
            interface AutoMatchInfoParam extends AutoMatchInfoParam_T {
            }
            interface MatchResultBean_S {
            }
            type MatchResultBean_ST = $.java.io.Serializable & MatchResultBean_S;
            interface MatchResultBean_C extends MatchResultBean_ST {
                new():MatchResultBean;
                new(id:any,oldRuleName:string):MatchResultBean;
            }
            interface MatchResultBean$ {
                getEntryRuleId():any;
                getId():any;
                getNewRuleName():string;
                getOldRuleName():string;
                getRuleId():any;
                setEntryRuleId(entryRuleId:any):void;
                setId(id:any):void;
                setNewRuleName(newRuleName:string):void;
                setOldRuleName(oldRuleName:string):void;
                setRuleId(ruleId:any):void;
            }
            type MatchResultBean_T = $.java.io.Serializable & MatchResultBean_S & MatchResultBean$;
            interface MatchResultBean extends MatchResultBean_T {
            }
            interface RecPayRuleMatchUtil_S {
                /**
                 * 交易明细匹配收付入账规则
                 *
                 * @param ids
                 * @return
                 */
                match(ids:any[]):$.java.util.List;
                /**
                 * 交易明细匹配收付入账规则并保存
                 *
                 * @param ids
                 * @return
                 */
                matchAndSave(ids:any[]):$.java.util.List;
                /**
                 * 交易明细匹配收付入账规则-通知认领
                 *
                 * @param ids
                 * @return
                 */
                matchNoticeClaim(ids:any[]):$.java.util.List;
            }
            interface RecPayRuleMatchUtil_C extends RecPayRuleMatchUtil_S {
                new():RecPayRuleMatchUtil;
            }
            interface RecPayRuleMatchUtil$ {
            }
            type RecPayRuleMatchUtil_T = RecPayRuleMatchUtil_S & RecPayRuleMatchUtil$;
            interface RecPayRuleMatchUtil extends RecPayRuleMatchUtil_T {
            }
            interface MatchUtil_S {
                /**
                 * 取消匹配
                 * @param autoMatchInfoParamList
                 */
                cancelMatch(autoMatchInfoParamList:$.java.util.List):void;
                /**
                 * 匹配
                 * @param matchRequestBean
                 */
                match(matchRequestBean:MatchRequestBean):void;
            }
            interface MatchUtil_C extends MatchUtil_S {
                new():MatchUtil;
            }
            interface MatchUtil$ {
            }
            type MatchUtil_T = MatchUtil_S & MatchUtil$;
            interface MatchUtil extends MatchUtil_T {
            }
            interface MatchRequestBean_S {
            }
            type MatchRequestBean_ST = $.java.io.Serializable & MatchRequestBean_S;
            interface MatchRequestBean_C extends MatchRequestBean_ST {
                new():MatchRequestBean;
            }
            interface MatchRequestBean$ {
                getAutoMatchInfoParamList():$.java.util.List;
                getAutoRecPayBizBillIdSet():$.java.util.Set;
                getReceivedWay():string;
                getRuleNameMap():$.java.util.Map;
                setAutoMatchInfoParamList(autoMatchInfoParamList:$.java.util.List):void;
                setAutoRecPayBizBillIdSet(autoRecPayBizBillIdSet:$.java.util.Set):void;
                setReceivedWay(receivedWay:string):void;
                setRuleNameMap(ruleNameMap:$.java.util.Map):void;
            }
            type MatchRequestBean_T = $.java.io.Serializable & MatchRequestBean_S & MatchRequestBean$;
            interface MatchRequestBean extends MatchRequestBean_T {
            }
        }
        namespace kd.sdk.tmc.cdm.extpoint.payablebill{
            interface IPayableCanDrawValidatorInterface_S {
            }
            interface IPayableCanDrawValidatorInterface$ {
                /**
                 * 是否跳过校验  -- 票据“%s”已被出纳付款单关联，不允许“取消出票”。
                 * @param dataEntity 当前校验的应付票据信息
                 * @return 是否跳过校验 true 跳过 false 不跳过
                 *
                 * package kd.sdk.tmc.cdm.extpoint.payablebill;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.entity.ExtendedDataEntity;
                 *
                 * public class PayableCanDrawValidatorDefaultExt implements IPayableCanDrawValidatorInterface {
                 *     @Override
                 *     public Boolean skipValidate(ExtendedDataEntity dataEntity) {
                 *         DynamicObject data = dataEntity.getDataEntity();
                 *         //根据单据信息是否跳过校验或者根据其他二开的配置判断是否跳过校验
                 *         if("extsource".equals(data.getString("source"))){
                 *             return true;
                 *         }
                 *         return false;
                 *     }
                 * }
                 */
                skipValidate(dataEntity:$.kd.bos.entity.ExtendedDataEntity):boolean;
            }
            type IPayableCanDrawValidatorInterface_T = IPayableCanDrawValidatorInterface_S & IPayableCanDrawValidatorInterface$;
            interface IPayableCanDrawValidatorInterface extends IPayableCanDrawValidatorInterface_T {
            }
        }
        namespace kd.sdk.tmc.cdm.util{
            interface ReturnNoteEndorseBean_S {
            }
            type ReturnNoteEndorseBean_ST = $.java.io.Serializable & ReturnNoteEndorseBean_S;
            interface ReturnNoteEndorseBean_C extends ReturnNoteEndorseBean_ST {
                new():ReturnNoteEndorseBean;
            }
            interface ReturnNoteEndorseBean$ {
                getEndorseType():string;
                getEndorsee():string;
                getEndorser():string;
                setEndorseType(endorseType:string):void;
                setEndorsee(endorsee:string):void;
                setEndorser(endorser:string):void;
            }
            type ReturnNoteEndorseBean_T = $.java.io.Serializable & ReturnNoteEndorseBean_S & ReturnNoteEndorseBean$;
            interface ReturnNoteEndorseBean extends ReturnNoteEndorseBean_T {
            }
            interface ReturnNoteBean_S {
            }
            type ReturnNoteBean_ST = $.java.io.Serializable & ReturnNoteBean_S;
            interface ReturnNoteBean_C extends ReturnNoteBean_ST {
                new():ReturnNoteBean;
            }
            interface ReturnNoteBean$ {
                getCompany():$.kd.bos.dataentity.entity.DynamicObject;
                getDrawerName():string;
                getEndorseEntry():$.java.util.List;
                getNoteStatus():string;
                getReceiverName():string;
                getTickStatus():string;
                setCompany(company:$.kd.bos.dataentity.entity.DynamicObject):void;
                setDrawerName(drawerName:string):void;
                setEndorseEntry(endorseEntry:$.java.util.List):void;
                setNoteStatus(noteStatus:string):void;
                setReceiverName(receiverName:string):void;
                setTickStatus(tickStatus:string):void;
            }
            type ReturnNoteBean_T = $.java.io.Serializable & ReturnNoteBean_S & ReturnNoteBean$;
            interface ReturnNoteBean extends ReturnNoteBean_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.common{
            interface IGetExtCfmBillLayoutInfoDev_S {
            }
            interface IGetExtCfmBillLayoutInfoDev$ {
                /**
                 * @Description 获取二开的融资单据布局信息
                 * @param openEntityName 打开单据的实体类型
                 * @param loanType       贷款类型
                 * @return k:布局类型,v:布局实体名称
                 *
                 * <pre>
                 * {@code
                 *  public class GetExtCfmBillLayoutInfoDevImpl implements IGetExtCfmBillLayoutInfoDev {
                 *
                 *     public Map getExtCfmBillLayoutInfoDev(String openEntityName, String loanType) {
                 *         Map result = new HashMap<>(10);
                 *         //贷款,借款
                 *         if ("direct".equals(loanType)) {
                 *             //合同,展期,还款,利息,提款,预提 ...
                 *             switch (openEntityName) {
                 *                 case "cfm_loancontractbill":
                 *                     result.put("wkzb_cfm_loancontrac_ext", "直接融资合同");
                 *                     return result;
                 *                 case "cfm_loanbill":
                 *                     result.put("wkzb_cfm_loanbill_ext", "直接融资提款");
                 *                     return result;
                 *                 case "cfm_repaymentbill":
                 *                     result.put("wkzb_cfm_repaymentbill_ext", "直接融资还款");
                 *                     return result;
                 *                 case "cfm_interestbill":
                 *                     result.put("wkzb_cfm_interestbill_ext", "直接融资利息");
                 *                     return result;
                 *                 case "cfm_preinterestbill":
                 *                     result.put("wkzb_cfm_preinterestbill_ext", "直接融资预提");
                 *                     return result;
                 *             }
                 *         } else if ("other".equals(loanType)) {
                 *             //合同,展期,还款,利息,提款,预提 ...
                 *             switch (openEntityName) {
                 *                 case "cfm_loancontractbill":
                 *                     result.put("wkzb_cfm_loancontrac_ext2", "其他融资合同");
                 *                     return result;
                 *                 case "cfm_loanbill":
                 *                     result.put("wkzb_cfm_loanbill_ext2", "其他融资提款");
                 *                     return result;
                 *             }
                 *         }
                 *         return result;
                 *     }
                 *  }
                 * }
                 * </pre>
                 */
                getExtCfmBillLayoutInfoDev?(openEntityName:string,loanType:string):$.java.util.Map;
            }
            type IGetExtCfmBillLayoutInfoDev_T = IGetExtCfmBillLayoutInfoDev_S & IGetExtCfmBillLayoutInfoDev$;
            interface IGetExtCfmBillLayoutInfoDev extends IGetExtCfmBillLayoutInfoDev_T {
            }
            interface IGetCustomBillFormIdSecondDevService_S {
            }
            interface IGetCustomBillFormIdSecondDevService$ {
                /**
                 * @Description  是否默认自动下推解活单，默认是true，二开可根据自己需求是否生成
                 * @param targetBillFormId 目标单单据formid
                 * <pre>
                 *     {@code
                 *           public class TestGetCustomBillFormIdSecondDevService implements IGetCustomBillFormIdSecondDevService {
                 *              public String getCustomBillFormId(String targetBillFormId) {
                 *                   // 判断是否是目标单的formid
                 *                   if ("目标单的formid".equals(targetBillFormId)) {
                 *                      return "自定义的单据formid";
                 *                   }
                 *                   return false;
                 *               }
                 *           }
                 *     }
                 * </pre>
                 */
                getCustomBillFormId?(targetBillFormId:string):string;
            }
            type IGetCustomBillFormIdSecondDevService_T = IGetCustomBillFormIdSecondDevService_S & IGetCustomBillFormIdSecondDevService$;
            interface IGetCustomBillFormIdSecondDevService extends IGetCustomBillFormIdSecondDevService_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.confirm{
            interface IConfirmListInterface_S {
            }
            interface IConfirmListInterface$ {
                /**
                 * @param dataSource 借款确认=invest, 贷款确认=cfm
                 * @return 二开增加的列名
                 *
                 * <pre>
                 * {@code
                 *
                 *     public String[] columnsName(String dataSource) {
                 *         if ("cfm".equals(dataSource)) {
                 *             return new String[]{"payintdate"};
                 *         }
                 *         return new String[0];
                 *     }
                 *  }
                 * </pre>
                 */
                columnsName?(dataSource:string):string[];
                /**
                 * @param dataSource 借款确认=invest, 贷款确认=cfm
                 * @param row 查询出来的单据数据
                 * @param objectArr 列表结果对象，根据 objectArr[2] 可判断行数据的业务确认类型
                 *
                 * @return 列表结果对象
                 *
                 * <pre>
                 * {@code
                 *
                 *     public Object[] resultObject(String dataSource, DynamicObject row, Object[] objectArr) {
                 *         if (!"cfm".equals(dataSource)) {
                 *             return objectArr;
                 *         }
                 *         Object[] objects = Arrays.copyOf(objectArr, objectArr.length+1);
                 *         if ("interest".equals(objects[2])) {
                 *             objects[objectArr.length] = row.get("bizdate");
                 *         } else {
                 *             objects[objectArr.length] = null;
                 *         }
                 *         return objects;
                 *     }
                 *  }
                 * </pre>
                 */
                resultObject?(dataSource:string,row:$.kd.bos.dataentity.entity.DynamicObject,objectArr:any[]):any[];
            }
            type IConfirmListInterface_T = IConfirmListInterface_S & IConfirmListInterface$;
            interface IConfirmListInterface extends IConfirmListInterface_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.creditm{
            interface IApplyReturnCreditlimit_S {
            }
            interface IApplyReturnCreditlimit$ {
                /**
                 * 融资申请返还授信金额扩展
                 * @param bill          实际占用的单据（合同、提款）
                 * @param applyBill     融资申请单（预占授信）
                 * @return  returnAmount-预占返还金额，isLast-全额返还
                 *
                 * * <pre>
                 *      * {@code
                 *      *   map.put("returnAmount", new BigDecimal("800"));
                 *      *   map.put("isLast", true);
                 *      *  }
                 * * </pre>
                 */
                applyReturnCreditlimit?(bill:$.kd.bos.dataentity.entity.DynamicObject,applyBill:$.kd.bos.dataentity.entity.DynamicObject,map:$.java.util.Map):void;
            }
            type IApplyReturnCreditlimit_T = IApplyReturnCreditlimit_S & IApplyReturnCreditlimit$;
            interface IApplyReturnCreditlimit extends IApplyReturnCreditlimit_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.extapply{
            interface IExtApplyBillSecondDevFields_S {
            }
            interface IExtApplyBillSecondDevFields$ {
                /**
                 * @Description: 展期申请支持下推封装二开字段扩展插件 Map<String, Object> 集合中
                 * @param extApplyBill 展期申请单据
                 * @return java.util.Map<java.lang.String,java.lang.Object> 返回封装好的二开字段集合; key:目标单二开字段标识, value: 对应源单二开字段在源单上绑定的值
                 *
                 * <pre>
                 *     <code>
                 *         public class extApplyBillSecondDevFields implements IExtApplyBillSecondDevFields {
                 *
                 *                  public Map< String, Object> extApplyBillSecondDevFields(DynamicObject extApplyBill) {
                 *                  //通过extApplyBill查询对应的字段属性
                 *                  Map< String, Object> fieldMap = new HashMap<>(16);
                 *                  //基本字段
                 *                  fieldMap.put("tarprop", extApplyBill.get("srcprop"));
                 *                  //基础资料
                 *                  fieldMap.put("tarbanksdk", extApplyBill.getDynamicObject("scrbanksdk").getPkValue());
                 *                  //多选基础资料
                 *                  DynamicObjectCollection scrMulSdk = extApplyBill.getDynamicObjectCollection("scrmulsdk");
                 *                  fieldMap.put("tarmulsdk", scrMulSdk.stream().map(o -> o.getDynamicObject("fbasedataid").getPkValue()).collect(Collectors.toList()));
                 *                  return fieldMap;
                 *                  }
                 *              }
                 *     </code>
                 * </pre>
                 */
                extApplyBillSecondDevFields?(extApplyBill:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            type IExtApplyBillSecondDevFields_T = IExtApplyBillSecondDevFields_S & IExtApplyBillSecondDevFields$;
            interface IExtApplyBillSecondDevFields extends IExtApplyBillSecondDevFields_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.init{
            interface IInitBillSecondDevFields_S {
            }
            interface IInitBillSecondDevFields$ {
                /**
                 * @Description: 贷款初始化单据点击结束初始化操作支持二开字段带到合同单据扩展插件
                 * @param initBill 初始化单据
                 * @param targetBill 目标单--合同/债券发行计划单
                 *
                 * <pre>
                 * {@code
                 *    public class InitBillSecondDevFields implements IInitBillSecondDevFields {
                 *
                 *        public void initBillSecondDevFields(DynamicObject initBill, DynamicObject targetBill){
                 *            // 基本字段
                 *            boolean extIsPay = initBill.getBoolean("ext_ispay");
                 *            targetBill.set("ext_ispay", extIsPay);
                 *            // 基础资料
                 *            DynamicObject extPaycurrency = initBill.getDynamicObject("ext_paycurrency");
                 *            targetBill.set("ext_paycurrency", extPaycurrency);
                 *        }
                 *    }
                 *  }
                 * </pre>
                 */
                initBillSecondDevFields?(initBill:$.kd.bos.dataentity.entity.DynamicObject,targetBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IInitBillSecondDevFields_T = IInitBillSecondDevFields_S & IInitBillSecondDevFields$;
            interface IInitBillSecondDevFields extends IInitBillSecondDevFields_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.interestbill{
            interface ILoanIntBillBatchSecondDevFields_S {
            }
            interface ILoanIntBillBatchSecondDevFields$ {
                /**
                 * @Description: 贷款结息处理批量审核场景下二开单据targetIntBill处理
                 * @param batchIntBill 批量结息处理单 - 主单据
                 * @param loanBillEntry 放款处理单 - 分录中的单据
                 * @param targetIntBill 付息单 - 目标单据
                 *
                 * <pre>
                 * {@code
                 *    public class LoanIntBillBatchSecondDevFields implements ILoanIntBillBatchSecondDevFields {
                 *
                 *        public void loanIntBillBatchSecondDevFields(DynamicObject batchIntBill, DynamicObject loanBill, DynamicObject targetIntBill) {
                 *            // 基本字段
                 *            boolean extIsPay = loanBill.getBoolean("ext_ispay");
                 *            targetIntBill.set("ext_ispay", extIsPay);
                 *
                 *            // 基础资料
                 *            DynamicObject extPaycurrency = loanBill.getDynamicObject("ext_paycurrency");
                 *            targetIntBill.set("ext_paycurrency", extPaycurrency);
                 *        }
                 *    }
                 *  }
                 * </pre>
                 */
                loanIntBillBatchSecondDevFields?(batchIntBill:$.kd.bos.dataentity.entity.DynamicObject,loanBillEntry:$.kd.bos.dataentity.entity.DynamicObject,targetIntBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type ILoanIntBillBatchSecondDevFields_T = ILoanIntBillBatchSecondDevFields_S & ILoanIntBillBatchSecondDevFields$;
            interface ILoanIntBillBatchSecondDevFields extends ILoanIntBillBatchSecondDevFields_T {
            }
            interface IGetOtherIntBillPayAmtExt_S {
            }
            interface IGetOtherIntBillPayAmtExt$ {
                /**
                 *  @description 获取利息单其他的可付款金额扩展插件
                 *  @param intBillId 利息单Id
                 *  @return 额外的可付款金额
                 *
                 *  <pre>
                 *  {@code
                 *       public class GetOtherIntBillPayAmtExtImpl implements IGetOtherIntBillPayAmtExt {
                 *
                 *           public BigDecimal getOtherIntBillPayAmtExt(Long intBillId) {
                 *               //先查询
                 *               DynamicObject bizBill = BusinessDataServiceHelper.loadSingle("cfm_interestbill","ext_feeamt", new QFilter("id", QCP.equals, intBillId).toArray());
                 *               return bizBill.getBigDecimal("feeAmt");//获取其他利息单的可付款金额
                 *           }
                 *       }
                 *  }
                 * </pre>
                 */
                getOtherIntBillPayAmtExt?(intBillId:long):$.java.math.BigDecimal;
            }
            type IGetOtherIntBillPayAmtExt_T = IGetOtherIntBillPayAmtExt_S & IGetOtherIntBillPayAmtExt$;
            interface IGetOtherIntBillPayAmtExt extends IGetOtherIntBillPayAmtExt_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.loan{
            interface IUpdateLoanRateReset2Point_S {
            }
            interface IUpdateLoanRateReset2Point$ {
                /**
                 *  @description 更新提款单利率重置记录二开拓展
                 *
                 *  <pre>
                 *  {@code
                 *      public class UpdateLoanRateReset2PointImpl implements IUpdateLoanRateReset2Point {
                 *
                 *      @param rateAdjustEntry 利率重置分录
                 *      @param loanId 提款单id
                 *      @param interestType 利率类型
                 *      @Override
                 *      public void updateLoanRateReset2Point(DynamicObjectCollection rateAdjustEntry, Long loanId, String interestType) {
                 *          //格式化日期(yyyy-MM-dd)
                 *          Date currentDate = formatDate(new Date());
                 *          //todo  现场实现,可以增加其他的业务逻辑判断,如根据贷款类型,是否是浮动利率,周期性重置方式等具体判断,后续的展期,利率调整逻辑等, 如果需要其他的属性判断,需要通过loanId查询
                 *          if ("float".equals(interestType)) {
                 *              List<DynamicObject> raEffectdates = rateAdjustEntry.stream().filter(o -> formatDate(o.getDate("ra_effectdate")).compareTo(currentDate) > 0).collect(Collectors.toList());
                 *              if (raEffectdates.size() > 0) {
                 *                  rateAdjustEntry.removeAll(raEffectdates);
                 *              }
                 *          }
                 *      }
                 *
                 *      //格式化日期(去掉时分秒)
                 *      public static Date formatDate(Date date) {
                 *          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                 *          try {
                 *              return sdf.parse(sdf.format(date));
                 *          } catch (ParseException e) {
                 *              throw new RuntimeException(e);
                 *          }
                 *      }
                 *  }
                 *  }
                 * </pre>
                 */
                updateLoanRateReset2Point?(rateAdjustEntry:$.kd.bos.dataentity.entity.DynamicObjectCollection,loanId:long,interestType:string):void;
            }
            type IUpdateLoanRateReset2Point_T = IUpdateLoanRateReset2Point_S & IUpdateLoanRateReset2Point$;
            interface IUpdateLoanRateReset2Point extends IUpdateLoanRateReset2Point_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.preinst{
            interface IPreIntBillBatchSecondDevFields_S {
            }
            interface IPreIntBillBatchSecondDevFields$ {
                /**
                 * @Description: 利息预提批量处理审核场景下二开单据targetPreIntBill处理
                 * @param batchPreIntBill 利息预提批量处理 - 主单据
                 * @param loanBillEntry 放款处理单 - 分录中的单据
                 * @param targetPreIntBill 预提单 - 目标单据
                 *
                 * <pre>
                 * {@code
                 *    public class PreIntBillBatchSecondDevFields implements IPreIntBillBatchSecondDevFields {
                 *
                 *        public void preIntBillBatchSecondDevFields(DynamicObject batchPreIntBill, DynamicObject loanBill, DynamicObject targetPreIntBill) {
                 *            // 基本字段
                 *            boolean extIsPay = loanBill.getBoolean("ext_ispay");
                 *            targetPreIntBill.set("ext_ispay", extIsPay);
                 *
                 *            // 基础资料
                 *            DynamicObject extPaycurrency = loanBill.getDynamicObject("ext_paycurrency");
                 *            targetPreIntBill.set("ext_paycurrency", extPaycurrency);
                 *        }
                 *    }
                 *  }
                 * </pre>
                 */
                preIntBillBatchSecondDevFields?(batchPreIntBill:$.kd.bos.dataentity.entity.DynamicObject,loanBillEntry:$.kd.bos.dataentity.entity.DynamicObject,targetPreIntBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IPreIntBillBatchSecondDevFields_T = IPreIntBillBatchSecondDevFields_S & IPreIntBillBatchSecondDevFields$;
            interface IPreIntBillBatchSecondDevFields extends IPreIntBillBatchSecondDevFields_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.repay{
            interface IRepayBillSecondDevFields_S {
            }
            interface IRepayBillSecondDevFields$ {
                /**
                 * Description: 还款处理的还本付息场景下二开字段封装到 Map<String, Object> 集合中
                 * @param repayBill 还款单
                 * @return java.util.Map<java.lang.String,java.lang.Object> 返回封装好的二开字段集合; key:目标单二开字段标识, value: 对应源单二开字段在源单上绑定的值
                 *
                 * <pre>
                 *     <code>
                 *         public class RepayBillSecondDevFields implements IRepayBillSecondDevFields {
                 *
                 *                  public Map< String, Object> repayBillSecondDevFields(DynamicObject repayBill) {
                 *                  //通过repayBill查询对应的字段属性
                 *                  Map< String, Object> fieldMap = new HashMap<>(16);
                 *                  //基本字段
                 *                  fieldMap.put("tarprop", repayBill.get("srcprop"));
                 *                  //基础资料
                 *                  fieldMap.put("tarbanksdk", repayBill.getDynamicObject("scrbanksdk").getPkValue());
                 *                  //多选基础资料
                 *                  DynamicObjectCollection scrMulSdk = repayBill.getDynamicObjectCollection("scrmulsdk");
                 *                  fieldMap.put("tarmulsdk", scrMulSdk.stream().map(o -> o.getDynamicObject("fbasedataid").getPkValue()).collect(Collectors.toList()));
                 *                  return fieldMap;
                 *                  }
                 *              }
                 *     </code>
                 * </pre>
                 */
                repayBillSecondDevFields?(repayBill:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            type IRepayBillSecondDevFields_T = IRepayBillSecondDevFields_S & IRepayBillSecondDevFields$;
            interface IRepayBillSecondDevFields extends IRepayBillSecondDevFields_T {
            }
            interface IGetOtherRepayBillPayAmtExt_S {
            }
            interface IGetOtherRepayBillPayAmtExt$ {
                /**
                 *  @description 获取还款单其他的可付款金额
                 *  @param repayBillId 还款单Id
                 *  @return 额外的可付款金额
                 *
                 *  <pre>
                 *  {@code
                 *       public class GetOtherRepayBillPayAmtExtImpl implements IGetOtherRepayBillPayAmtExt {
                 *           @Override
                 *           public  BigDecimal getOtherRepayBillPayAmtExt(Long repayBillId) {
                 *               //先查询
                 *               DynamicObject bizBill = BusinessDataServiceHelper.loadSingle("cfm_repaymentbill","ext_feeamt", new QFilter("id", QCP.equals, repayBillId).toArray());
                 *               return bizBill.getBigDecimal("feeAmt");//获取还款单其他的可付款金额
                 *           }
                 *       }
                 *  }
                 * </pre>
                 */
                getOtherRepayBillPayAmtExt?(repayBillId:long):$.java.math.BigDecimal;
            }
            type IGetOtherRepayBillPayAmtExt_T = IGetOtherRepayBillPayAmtExt_S & IGetOtherRepayBillPayAmtExt$;
            interface IGetOtherRepayBillPayAmtExt extends IGetOtherRepayBillPayAmtExt_T {
            }
        }
        namespace kd.sdk.tmc.cfm.extpoint.repayapply{
            interface IRepayApplyBillSecondDevFields_S {
            }
            interface IRepayApplyBillSecondDevFields$ {
                /**
                 * Description: 还款申请支持下推封装二开字段扩展插件 Map<String, Object> 集合中
                 * @param repayApplyBill 还款申请单据
                 * @return java.util.Map<java.lang.String,java.lang.Object> 返回封装好的二开字段集合; key:目标单二开字段标识, value: 对应源单二开字段在源单上绑定的值
                 *
                 * <pre>
                 *     <code>
                 *         public class repayApplyBillSecondDevFields implements IRepayApplyBillSecondDevFields {
                 *
                 *                  public Map< String, Object> repayApplyBillSecondDevFields(DynamicObject repayApplyBill) {
                 *                  //通过repayApplyBill查询对应的字段属性
                 *                  Map< String, Object> fieldMap = new HashMap<>(16);
                 *                  //基本字段
                 *                  fieldMap.put("tarprop", repayApplyBill.get("srcprop"));
                 *                  //基础资料
                 *                  fieldMap.put("tarbanksdk", repayApplyBill.getDynamicObject("scrbanksdk").getPkValue());
                 *                  //多选基础资料
                 *                  DynamicObjectCollection scrMulSdk = repayApplyBill.getDynamicObjectCollection("scrmulsdk");
                 *                  fieldMap.put("tarmulsdk", scrMulSdk.stream().map(o -> o.getDynamicObject("fbasedataid").getPkValue()).collect(Collectors.toList()));
                 *                  return fieldMap;
                 *                  }
                 *              }
                 *     </code>
                 * </pre>
                 */
                repayApplyBillSecondDevFields?(repayApplyBill:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            type IRepayApplyBillSecondDevFields_T = IRepayApplyBillSecondDevFields_S & IRepayApplyBillSecondDevFields$;
            interface IRepayApplyBillSecondDevFields extends IRepayApplyBillSecondDevFields_T {
            }
        }
        namespace kd.sdk.tmc.cfm.util{
            interface FeeCostShareInfo_S {
            }
            interface FeeCostShareInfo_C extends FeeCostShareInfo_S {
                new():FeeCostShareInfo;
            }
            interface FeeCostShareInfo$ {
                getAiInterestAmt():$.java.math.BigDecimal;
                getAmAmt():$.java.math.BigDecimal;
                getCcbAmt():$.java.math.BigDecimal;
                getCcbEndAmt():$.java.math.BigDecimal;
                getDayRate():number;
                getDays():number;
                getEiInterestAmt():$.java.math.BigDecimal;
                getEiRate():$.java.math.BigDecimal;
                getEndDate():Date;
                getStartDate():Date;
                getYtm():$.java.math.BigDecimal;
                setAiInterestAmt(aiInterestAmt:$.java.math.BigDecimal):void;
                setAmAmt(amAmt:$.java.math.BigDecimal):void;
                setCcbAmt(ccbAmt:$.java.math.BigDecimal):void;
                setCcbEndAmt(ccbEndAmt:$.java.math.BigDecimal):void;
                setDayRate(dayRate:number):void;
                setDays(days:number):void;
                setEiInterestAmt(eiInterestAmt:$.java.math.BigDecimal):void;
                setEiRate(eiRate:$.java.math.BigDecimal):void;
                setEndDate(endDate:Date):void;
                setStartDate(startDate:Date):void;
                setYtm(ytm:$.java.math.BigDecimal):void;
            }
            type FeeCostShareInfo_T = FeeCostShareInfo_S & FeeCostShareInfo$;
            interface FeeCostShareInfo extends FeeCostShareInfo_T {
            }
            interface FeeCostParam_S {
                getSerialVersionUID():long;
            }
            type FeeCostParam_ST = $.java.io.Serializable & FeeCostParam_S;
            interface FeeCostParam_C extends FeeCostParam_ST {
                new():FeeCostParam;
            }
            interface FeeCostParam$ {
                getAmount():$.java.math.BigDecimal;
                getAmtPrecision():number;
                getBasis():string;
                getEndDate():Date;
                getFeeAmount():$.java.math.BigDecimal;
                getHtRule():string;
                getLoanRate():$.java.math.BigDecimal;
                getShareFrequency():string;
                getShareType():string;
                getStartDate():Date;
                setAmount(amount:$.java.math.BigDecimal):void;
                setAmtPrecision(amtPrecision:number):void;
                setBasis(basis:string):void;
                setEndDate(endDate:Date):void;
                setFeeAmount(feeAmount:$.java.math.BigDecimal):void;
                setHtRule(htRule:string):void;
                setLoanRate(loanRate:$.java.math.BigDecimal):void;
                setShareFrequency(shareFrequency:string):void;
                setShareType(shareType:string):void;
                setStartDate(startDate:Date):void;
            }
            type FeeCostParam_T = $.java.io.Serializable & FeeCostParam_S & FeeCostParam$;
            interface FeeCostParam extends FeeCostParam_T {
            }
            interface CostShareUtil_S {
                /**
                 * 获取摊销明细
                 * @param param 摊销数据对象
                 * @return  摊销明细
                 * @throws KDBizException
                 * <pre>
                 *     <code>
                 *     调用示例:
                 *     FeeCostParam param = new kd.sdk.tmc.cfm.util.FeeCostParam();
                 *     //业务金额
                 *     param.setAmount(amount);
                 *     //业务金额-费用总额（异币别费用，需要按汇率转成业务币别）
                 *     param.setInitCcbAmt(initCcbAmt);
                 *     //息票率
                 *     param.setLoanRate(loanRate);
                 *     //计息基准：默认算头不算尾-headnotail/算尾不算头-noheadtail/算头又算尾-headtail/头尾都不算-noheadnotail
                 *     param.setBasis(basisEnum.getValue());
                 *     //币别精度
                 *     param.setAmtPrecision(amtPrecision);
                 *     //摊销方式：实际利率法-1 直线法-2
                 *     param.setShareType(shareType);
                 *     //头尾规则：默认算头不算尾-headnotail/算尾不算头-noheadtail/算头又算尾-headtail/头尾都不算-noheadnotail
                 *     param.setHtRule("");
                 *     //开始日期
                 *     param.setStartDate(DateUtils.stringToDate("2024-05-29", DateUtils.FORMAT_YMD));
                 *     //结束日期
                 *     param.setEndDate(DateUtils.stringToDate("2026-04-09", DateUtils.FORMAT_YMD));
                 *     //摊销频率：每日-day/每月-month/每季度-quarter/每半年-halfyear/每年-year
                 *     param.setShareFrequency("month");
                 *     List<FeeCostShareInfo> costShareList =  kd.sdk.tmc.cfm.util.CostShareUtil#getCostShareList(param)
                 *     </code>
                 * </pre>
                 */
                getCostShareList(param:FeeCostParam):$.java.util.List;
            }
            interface CostShareUtil_C extends CostShareUtil_S {
                new():CostShareUtil;
            }
            interface CostShareUtil$ {
            }
            type CostShareUtil_T = CostShareUtil_S & CostShareUtil$;
            interface CostShareUtil extends CostShareUtil_T {
            }
        }
        namespace kd.sdk.tmc.cim.extpoint{
            interface IReleaseApplyAutoReleaseSDKService_S {
            }
            interface IReleaseApplyAutoReleaseSDKService$ {
                /**
                 * 是否默认自动下推解活单，默认是true，二开可根据自己需求是否生成
                 * @param applyBill 存款解活申请单
                 * <pre>
                 *     <code>
                 *           public class DealReleaseApplyAutoPush implements IReleaseApplyAutoReleaseSDKService {
                 *               @Override
                 *              public boolean isAutoRelease(DynamicObject applyBill) {
                 *                   // 可以根据applyBill决定是否需要自动下推
                 *                   return false;
                 *               }
                 *           }
                 *     </code>
                 * </pre>
                 */
                isAutoRelease?(applyBill:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type IReleaseApplyAutoReleaseSDKService_T = IReleaseApplyAutoReleaseSDKService_S & IReleaseApplyAutoReleaseSDKService$;
            interface IReleaseApplyAutoReleaseSDKService extends IReleaseApplyAutoReleaseSDKService_T {
            }
            interface IReleasePushDptRevenue_S {
            }
            interface IReleasePushDptRevenue$ {
                /**
                 * 解活单支持下推解活类型的收益单封装二开字段扩展插件 Map<String, Object> 集合中
                 * 在操作中OperateOption option中的key= SecondDevFieldVal，取出后再 Map secondDevFieldVal = JSON.parseObject("SecondDevFieldVal", Map.class)得到此方法返回map
                 * @param releaseBill 解活单
                 * @return 返回封装好的二开字段集合; key:目标单二开字段标识, value: 二开字段在源单上绑定的值
                 *
                 * <pre>
                 *     <code>
                 *           public class DepositReleasePushDptRevenue implements IReleasePushDptRevenue{
                 *               @Override
                 *               public Map<String, Object> getReleaseBillSecondFields(DynamicObject releaseBill) {
                 *                   Map<String, Object> map = new HashMap<>();
                 *                   //基本字段（非基础资料）
                 *                   map.put("ltg_text", releaseBill.get("ltg_text"));
                 *                   //基础资料
                 *                   map.put("ltg_base", releaseBill.getDynamicObject("ltg_base").getPkValue());
                 *                   return map;
                 *               }
                 *           }
                 *     </code>
                 * </pre>
                 */
                getReleaseBillSecondFields?(releaseBill:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            type IReleasePushDptRevenue_T = IReleasePushDptRevenue_S & IReleasePushDptRevenue$;
            interface IReleasePushDptRevenue extends IReleasePushDptRevenue_T {
            }
        }
        namespace kd.sdk.tmc.creditm.extpoint{
            interface ICreditLimitExtInerface_S {
            }
            interface ICreditLimitExtInerface$ {
                /**
                 * @param sourceCurrencyId 原币别ID
                 * @param targetCurrencyId 目标币别ID
                 * @param orgId 组织ID
                 * @param date 日期
                 * @return 汇率值
                 *
                 * <pre>
                 *     <code>
                 *         @Override
                 *         public class CreditLimitExtRate implements ICreditLimitExtInerface {
                 *
                 *              @Override
                 *              public BigDecimal getCredituseRate(Long sourceCurrencyId, Long targetCurrencyId, Long orgId, Date date) {
                 *                  //通过币别和日期，自定义取汇率逻辑
                 *                  return new BigDecimal("2");
                 *              }
                 *          }
                 *     </code>
                 * </pre>
                 */
                getCredituseRate?(sourceCurrencyId:long,targetCurrencyId:long,orgId:long,date:Date):$.java.math.BigDecimal;
            }
            type ICreditLimitExtInerface_T = ICreditLimitExtInerface_S & ICreditLimitExtInerface$;
            interface ICreditLimitExtInerface extends ICreditLimitExtInerface_T {
            }
        }
        namespace kd.sdk.tmc.creditm.util.creditlimit{
            interface CreditLimitServiceUtil_S {
                /**
                 * 取消占用授信
                 *
                 * @param info SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
                 * @return SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
                 * @throws KDBizException 取消占用授信调用异常
                 *
                 *             <pre>
                 * <code>
                 *     调用示例:
                 *     CreditLimitInfo info = new CreditLimitInfo();
                 *     info.setXXX(XXX);
                 *     ...
                 *     kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.cancelCreditLimit(SerializationUtils.toJsonString(info));
                 * </code>
                 *             </pre>
                 */
                cancelCreditLimit(info:string):string;
                /**
                 * 取消返还授信
                 *
                 * @param info SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
                 * @return SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
                 * @throws KDBizException 取消返还授信调用异常
                 *
                 *             <pre>
                 * <code>
                 *     调用示例:
                 *     ReturnCreditLimitInfo info = new ReturnCreditLimitInfo();
                 *     info.setXXX(XXX);
                 *     ...
                 *     kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.cancelReturnCreditLimit(SerializationUtils.toJsonString(info));
                 * </code>
                 *             </pre>
                 */
                cancelReturnCreditLimit(info:string):string;
                /**
                 * 确认占用授信
                 *
                 * @param  info SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
                 * @return SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
                 * @throws KDBizException 确认占用授信调用异常
                 *
                 *             <pre>
                 * <code>
                 *     调用示例:
                 *     CreditLimitInfo info = new CreditLimitInfo();
                 *     info.setXXX(XXX);
                 *     ...
                 *     kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.confirmCreditLimit(SerializationUtils.toJsonString(info));
                 * </code>
                 *             </pre>
                 */
                confirmCreditLimit(info:string):string;
                /**
                 * 返还授信
                 *
                 * @param info SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
                 * @return SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
                 * @throws KDBizException 返还授信调用异常
                 *
                 *             <pre>
                 * <code>
                 *     调用示例:
                 *     ReturnCreditLimitInfo info = new ReturnCreditLimitInfo();
                 *     info.setXXX(XXX);
                 *     ...
                 *     kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.returnCreditLimit(SerializationUtils.toJsonString(info));
                 * </code>
                 *             </pre>
                 */
                returnCreditLimit(info:string):string;
                /**
                 * 释放授信根据指定金额
                 *
                 * @param info SerializationUtils.toJsonString(CreditLimitUseBean.class) 授信对象
                 * @return SerializationUtils.toJsonString(CreditLimitUseBean.class) 授信对象
                 * @throws KDBizException 释放授信根据指定金额调用异常
                 *
                 *             <pre>
                 * <code>
                 *     调用示例:
                 *     CreditLimitUseBean info = new CreditLimitUseBean();
                 *     info.setXXX(XXX);
                 *     ...
                 *     kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.updateCreditLimitUse(SerializationUtils.toJsonString(info));
                 * </code>
                 *             </pre>
                 */
                updateCreditLimitUse(info:string):string;
            }
            interface CreditLimitServiceUtil_C extends CreditLimitServiceUtil_S {
                new():CreditLimitServiceUtil;
            }
            interface CreditLimitServiceUtil$ {
            }
            type CreditLimitServiceUtil_T = CreditLimitServiceUtil_S & CreditLimitServiceUtil$;
            interface CreditLimitServiceUtil extends CreditLimitServiceUtil_T {
            }
        }
        namespace kd.sdk.tmc.ext.extpoint.committobe{
            interface IGenBankBillSDKService_S {
            }
            interface IGenBankBillSDKService$ {
                /**
                 * 提交银企，单据生成银行单据，用于二开字段数据填充
                 * @param entityName 单据实体名
                 * @param billList 单据集合
                 * @return Map< Long, Map< String, Object>>: 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{
                 *
                 *     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 {
            }
        }
        namespace kd.sdk.tmc.fbp.extpoint{
            interface IGetCustomSceneBillStatusSDKService_S {
            }
            interface IGetCustomSceneBillStatusSDKService$ {
                /**
                 * 获取自定义的非在途/非在途的单据状态
                 *
                 * @param entityName 单据的标识
                 * @return
                 * <pre>
                 *     <code>
                 *           public class GetCustomProcessStatus implements IGetCustomSceneBillStatusSDKService {
                 *               @Override
                 *               public List<String> getCustomSceneStatusList(String sceneStr, String entityName) {
                 *                   // 二开增加自定义的单据状态
                 *                   return Arrays.asList("D");
                 *               }
                 *           }
                 *     </code>
                 * </pre>
                 */
                getCustomSceneStatusList(sceneStr:string,entityName:string):$.java.util.List;
            }
            type IGetCustomSceneBillStatusSDKService_T = IGetCustomSceneBillStatusSDKService_S & IGetCustomSceneBillStatusSDKService$;
            interface IGetCustomSceneBillStatusSDKService extends IGetCustomSceneBillStatusSDKService_T {
            }
            interface IFeeDetailSaveAndSubmitAddFields_S {
            }
            interface IFeeDetailSaveAndSubmitAddFields$ {
                /**
                 * 业务单据费用明细页签二开新增字段后，需要在保存和提交操作中携带字段值保存到费用明细单据中
                 * test:新加的字段
                 *
                 * @param feeBill 费用明细单据
                 * @param row 费用明细单据的分录行
                 * @param feeDetailRow 业务单据的费用明细页签的要保存的行
                 *
                 * <p> 扩展示例如下
                 * <pre>
                 *      <code>
                 *            public class FeeDetailSecondDevFields implements IFeeDetailSaveAndSubmitAddFields {
                 *
                 *              public void feeDetailSaveAndSubmitAddFields(DynamicObject feeBill,DynamicObject row, DynamicObject feeDetailRow) {
                 *                   //单头
                 *                   feeBill.set("test",feeDetailRow.get("test"));
                 *                  //分录
                 *                  row.set("test",feeDetailRow.get("test"));
                 *              }
                 *            }
                 *      </code>
                 * </pre>
                 */
                feeDetailSaveAndSubmitAddFields?(feeBill:$.kd.bos.dataentity.entity.DynamicObject,row:$.kd.bos.dataentity.entity.DynamicObject,feeDetailRow:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IFeeDetailSaveAndSubmitAddFields_T = IFeeDetailSaveAndSubmitAddFields_S & IFeeDetailSaveAndSubmitAddFields$;
            interface IFeeDetailSaveAndSubmitAddFields extends IFeeDetailSaveAndSubmitAddFields_T {
            }
        }
        namespace kd.sdk.tmc.fbp.extpoint.orgfilter{
            interface IFunderOrgPermissionExtDev_S {
            }
            interface IFunderOrgPermissionExtDev$ {
                /**
                 * 得到选单有权限的组织集合
                 *
                 * @param srcEntity     源单实体
                 * @param srcAuthOrgIds 有权限的源单的组织集合
                 * @param tagEntity     目标实体
                 * @param tagAuthOrgIds 有权限的目标实体组织结合
                 * @return <pre>
                 *     <code>
                 *
                 *         public class FunderOrgPermissionExtDevImpl implements IFunderOrgPermissionExtDev {
                 *            public List<Long> getDrawBillAuthOrgIdList(List<Long> srcAuthOrgIds, List<Long> tagAuthOrgIds, String srcEntity, String tagEntity) {
                 *             if ("XXX".equals(srcEntity) && "YYY".equals(tagEntity)) {
                 *                 //支持自定义根据不同的源单目标单来判断(特殊情况)
                 *                 return srcAuthOrgIds;
                 *             } else if (srcAuthOrgIds != null && tagAuthOrgIds != null) {
                 *                 //求交集
                 *                 return srcAuthOrgIds.stream().filter(tagAuthOrgIds::contains).collect(Collectors.toList());
                 *                 //直接取目标单集合
                 *                 //return tagAuthOrgIds;
                 *             } else {
                 *                 //直接取源单集合
                 *                 return srcAuthOrgIds;
                 *             }
                 *          }
                 *     }
                 *     </code>
                 * </pre>
                 */
                getDrawBillAuthOrgIdList?(srcAuthOrgIds:$.java.util.List,tagAuthOrgIds:$.java.util.List,srcEntity:string,tagEntity:string):$.java.util.List;
                /**
                 * 资金组织权限范围支持二开
                 *
                 * @param entityName 实体类型
                 * @return true:需要标准的资金权限控制   false:不需要标准的资金组织权限控制
                 *
                 * <pre>
                 *     <code>
                 *           public class FunderOrgPermissionExtDevImpl implements IFunderOrgPermissionExtDev{
                 *                    public Boolean isCtrOrgPermissionExtDev(String entityName){
                 *                      DynamicObjectCollection result = QueryServiceHelper.query("ext_table", "id", new QFilter("entity", QCP.equals, entityName).toArray());
                 *                      return result == null || result.isEmpty();
                 *                   }
                 *           }
                 *     </code>
                 * </pre>
                 */
                isCtrOrgPermissionExtDev?(entityName:string):boolean;
            }
            type IFunderOrgPermissionExtDev_T = IFunderOrgPermissionExtDev_S & IFunderOrgPermissionExtDev$;
            interface IFunderOrgPermissionExtDev extends IFunderOrgPermissionExtDev_T {
            }
        }
        namespace kd.sdk.tmc.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.tmc.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 {
            }
            interface IBalanceService_S {
            }
            interface IBalanceService$ {
                /**
                 * <p>Title: BalanceService.java </p>
                 * <pre>Description: 资金调度计算划拨金额，即时余额二开扩展 </pre>
                 *
                 * @param transferType 划拨类型 UP上划，DOWN 下拨
                 * @param strategyId   划拨策略ID
                 * @param accountId    账户ID
                 * @param currencyId   币别ID
                 * @return 账户余额
                 * <pre>
                 *      <code>
                 *            public class BalanceService implements IBalanceService {
                 *              @Override
                 *              public BigDecimal getBalanceAmount(String transferType, Long strategyId, Long accountId, Long currencyId) {
                 *                   return BigDecimal.ONE
                 *              }
                 *            }
                 *      </code>
                 * </pre>
                 */
                getBalanceAmount(transferType:string,strategyId:long,accountId:long,currencyId:long):$.java.math.BigDecimal;
            }
            type IBalanceService_T = IBalanceService_S & IBalanceService$;
            interface IBalanceService extends IBalanceService_T {
            }
        }
        namespace kd.sdk.tmc.fcs.extpoint.paymonitor{
            interface IRelationShipJob_S {
            }
            interface IRelationShipJob$ {
                /**
                 * @param srcObj 源单查询对象
                 * @param destObj 目标单查询对象：查询自身关系时有值，查询外部关系无值
                 * @param flag 无关联关系结果标签："NotLink"-没有查到searchA的关联数据；"HasLinkButNotFound"-有查到关联数据，但是没有发现searchA与searchB存在关系
                 */
                doExt(srcObj:string,destObj:string,flag:string):void;
            }
            type IRelationShipJob_T = IRelationShipJob_S & IRelationShipJob$;
            interface IRelationShipJob extends IRelationShipJob_T {
            }
            interface IRelationShipNotFind_S {
            }
            interface IRelationShipNotFind$ {
                /**
                 * @param srcObj 源单查询对象
                 * @param tarObj 筛选单查询对象（未与源单在关联关系表中有关系数据）
                 */
                doExt(srcObj:string,tarObj:$.java.util.Set):void;
            }
            type IRelationShipNotFind_T = IRelationShipNotFind_S & IRelationShipNotFind$;
            interface IRelationShipNotFind extends IRelationShipNotFind_T {
            }
        }
        namespace kd.sdk.tmc.ifm.expoint{
            interface IGlAccountBalance_S {
            }
            interface IGlAccountBalance$ {
                /**
                 * 期间凭证明细数据
                 * @param intObject
                 * @param periodStr
                 * @param flexIdStr
                 * * <pre>
                 *      * @code
                 *      *   sqlStr.append("select b.fentryid,b.faccountid,a.fbookeddate vdate,case when b.fentrydc = '1' then b.foriginaldebit else -1*b.foriginalcredit end amount ");
                 * 			if (EmptyUtil.isNoEmpty(flexIdStr)) {
                 * 				sqlStr.append("from t_gl_voucher a inner join t_gl_voucherentry b on a.fid = b.fid inner join t_gl_assist_bd c on c.fid = b.fassgrpid ");
                 * 				sqlStr.append(" where  a.forgid = ? and a.fbooktypeid = ? and a.fperiodid in (%s) and a.Fbookeddate >= ? and a.Fbookeddate <= ? and b.faccountid = ? and b.fcurrencyid = ? ");
                 * 				sqlStr.append(" and b.forgid = ? and b.fperiodid in (%s) and c.fvalue in (").append(flexIdStr).append( ")");
                 * 			} else {
                 * 				sqlStr.append("from t_gl_voucher a inner join t_gl_voucherentry b on a.fid = b.fid ");
                 * 				sqlStr.append(" where a.forgid = ? and a.fbooktypeid = ? and a.fperiodid in (%s) and a.Fbookeddate >= ? and a.Fbookeddate <= ? and b.faccountid = ? and b.fcurrencyid = ? ");
                 * 				sqlStr.append(" and b.forgid = ? and b.fperiodid in (%s)");
                 * 			}
                 *      * </pre>
                 * @return
                 */
                dealDailyGLBalanceSql?(intObject:$.kd.bos.dataentity.entity.DynamicObject,periodStr:string,flexIdStr:string):string;
                /**
                 * 扩展修改期间初始余额和对应日期
                 * @param intObject
                 * * <pre>
                 *      * @code
                 *      Map<String, Object> map = new HashMap<>();
                 *      map.put("startDate", DateUtils.stringToDate("2024-01-01", DateUtils.FORMAT_YMD));
                 *      map.put("startBalance", new BigDecimal("0"));
                 * * </pre>
                 */
                dealPeriodStartDateAndBalance?(intObject:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            type IGlAccountBalance_T = IGlAccountBalance_S & IGlAccountBalance$;
            interface IGlAccountBalance extends IGlAccountBalance_T {
            }
            interface IInstBalanceCalcSecondDev_S {
            }
            interface IInstBalanceCalcSecondDev$ {
                /**
                 * 活期计息利息计算余额封装二开处理
                 * @param innerAcct 余额信息列表
                 * @param currency 币别
                 * @param beginDate 开始日期
                 * @param endDate 结束日期
                 *
                 * <pre>
                 * {@code
                 *   public class InstBalanceCalcSecondDev implements IInstBalanceCalcSecondDev {
                 *       @Override
                 *       public List<ExtPlanCallResult> getExtInstBalance(DynamicObject innerAcct, DynamicObject currency,
                 *                                                          Date beginDate, Date endDate) {
                 *           List<ExtPlanCallResult> results = new ArrayList<>();
                 *           results.add(new ExtPlanCallResult(new Date(), new BigDecimal(100)));
                 *           return results;
                 *       }
                 *   }
                 * </pre>
                 */
                getExtInstBalance?(innerAcct:$.kd.bos.dataentity.entity.DynamicObject,currency:$.kd.bos.dataentity.entity.DynamicObject,beginDate:Date,endDate:Date):$.java.util.List;
            }
            type IInstBalanceCalcSecondDev_T = IInstBalanceCalcSecondDev_S & IInstBalanceCalcSecondDev$;
            interface IInstBalanceCalcSecondDev extends IInstBalanceCalcSecondDev_T {
            }
        }
        namespace kd.sdk.tmc.ifp.expoint.planedit{
            interface IPlanEditBasedataF7Filter2Dev_S {
            }
            interface IPlanEditBasedataF7Filter2Dev$ {
                /**
                 * 计划编制维度基础资料添加二开过滤条件
                 * @param model 页面模型
                 * @param propKey 字段属性
                 * @param baseDataType 基础资料类型
                 *
                 * <pre>
                 * {@code
                 *   public QFilter getExtBasedataQFilter(IDataModel model, String propKey, String baseDataType) {
                 *         QFilter qFilter = null;
                 *         if ("bos_org".equals(baseDataType)) {
                 *             qFilter = new QFilter("id", QCP.in, "1");
                 *         }else if("cfm_financingvarieties".equals(baseDataType)){
                 *             qFilter = new QFilter("isleaf", QCP.equals, "1");
                 *         }
                 *         return qFilter;
                 *     }
                 * </pre>
                 */
                getExtBasedataQFilter?(model:$.kd.bos.entity.datamodel.IDataModel,propKey:string,baseDataType:string):$.kd.bos.orm.query.QFilter;
            }
            type IPlanEditBasedataF7Filter2Dev_T = IPlanEditBasedataF7Filter2Dev_S & IPlanEditBasedataF7Filter2Dev$;
            interface IPlanEditBasedataF7Filter2Dev extends IPlanEditBasedataF7Filter2Dev_T {
            }
        }
        namespace kd.sdk.tmc.mon.extpoint.mobile{
            interface IMobileSecondaryDevCard_S {
            }
            interface IMobileSecondaryDevCard$ {
                /**
                 * 调整 自定义首页卡片信息
                 *
                 * @param cardMap 调整前卡片信息
                 * @return 调整后卡片 key:卡片元数据标识 value:标题
                 *
                 * <p> 扩展示例如下 </p>
                 * <pre>
                 *     <code>
                 *         public class MonMobileSecondaryDevCardTest implements IMobileSecondaryDevCard {
                 *
                 *              @Override
                 *              public Map<String, String> adjustCard(Map<String, String> cardMap) {
                 *                  cardMap.put("ssc_inte_audit_card_m", "智能审单率卡片");
                 *                  return cardMap;
                 *              }
                 *
                 *        }
                 *     </code>
                 * </pre>
                 */
                adjustCard?(cardMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 调整 卡片权限
                 *
                 * @param permMap 调整前 卡片权限信息
                 * @return 调整后卡片权限信息 key:卡片元数据标识 value:权限项
                 *
                 * <p> 扩展示例如下 </p>
                 * <pre>
                 *     <code>
                 *         public class MonMobileSecondaryDevCardTest implements IMobileSecondaryDevCard {
                 *
                 *                  @Override
                 *                  public Map<String, String> adjustCardPerm(Map<String, String> permMap) {
                 *                      permMap.remove("mon_business_monitoring_m");
                 *                      return permMap;
                 *                  }
                 *
                 *        }
                 *     </code>
                 * </pre>
                 */
                adjustCardPerm?(permMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 调整 主题 卡片
                 *
                 * @param subject 主题标识 @see kd.tmc.mon.formplugin.mobile.card.SubjectEnum
                 * @param cards   卡片集合
                 * @return <p> 扩展示例如下 </p>
                 * <pre>
                 *     <code>
                 *         public class MonMobileSecondaryDevCardTest implements IMobileSecondaryDevCard {
                 *
                 *                      @Override
                 *                      public List<String> adjustSubject(String subject, List<String> cards) {
                 *                          if ("STOCKANALYSIS".equals(subject)) {
                 *                              cards.add("mon_incexprank_card");
                 *                           }
                 *                          return cards;
                 *                      }
                 *
                 *        }
                 *     </code>
                 * </pre>
                 */
                adjustSubject?(subject:string,cards:$.java.util.List):$.java.util.List;
            }
            type IMobileSecondaryDevCard_T = IMobileSecondaryDevCard_S & IMobileSecondaryDevCard$;
            interface IMobileSecondaryDevCard extends IMobileSecondaryDevCard_T {
            }
        }
        namespace kd.sdk.tmc.psd.extpoint{
            interface ICheckDefaultAccount_S {
            }
            interface ICheckDefaultAccount$ {
                /**
                 * <p>Title: TestGetDefaultAccount.java </p>
                 * <pre>Description: 自动排程或自动排票时，可以自定义默认账户 </pre>
                 * @param payScheduleInfo 排程信息
                 * @param defaultAccountInfo 默认账户信息
                 *
                 * <pre>
                 *      <code>
                 *          public class TestGetDefaultAccount implements ICheckDefaultAccount {
                 *
                 *              @Override
                 *              public Boolean validate(PayScheduleInfo payScheduleInfo, DynamicObject defaultAccountInfo) {
                 *                  // 资金用途
                 *                  boolean sameFunFlowItem = true;// 没有配置情况，默认是true
                 *                  // 默认账户配置的【资金用途】
                 *                  List<Object> fundFlowItem = defaultAccountInfo.getDynamicObjectCollection("fundflowitem").
                 *                          stream().map(e -> e.get("fbasedataid.id")).collect(Collectors.toList());
                 *                  // 排程单的【资金用途】
                 *                  Object funFlowItem = payScheduleInfo.getCalcPropVal("e_fundflowitem");
                 *
                 *                  if (!CollectionUtils.isEmpty(fundFlowItem)) {
                 *                      // 配置了，以实际值校验为准
                 *                      sameFunFlowItem = fundFlowItem.contains(funFlowItem);
                 *                   }
                 *
                 *                   // 收款人类型
                 *                  boolean samePayeeType = true; // 没有配置情况，默认是true
                 *                  //  默认账户配置的【收款人类型】
                 *                  String defaultPayeeType = defaultAccountInfo.getString("payeetype");
                 *                  //  排程单的【收款人类型】
                 *                  String ePayeeType = payScheduleInfo.getCalcPropVal("e_payeetype");
                 *                  if (StringUtils.isNotEmpty(defaultPayeeType)) {
                 *                      // 配置了，以实际值校验为准
                 *                      samePayeeType = defaultPayeeType.contains(ePayeeType);
                 *                  }
                 *
                 *                  return sameFunFlowItem && samePayeeType;
                 *              }
                 *          }
                 *      </code>
                 * </pre>
                 */
                validate?(payScheduleInfo:kd.sdk.tmc.psd.extpoint.param.PayScheduleInfo,defaultAccountInfo:$.kd.bos.dataentity.entity.DynamicObject):boolean;
            }
            type ICheckDefaultAccount_T = ICheckDefaultAccount_S & ICheckDefaultAccount$;
            interface ICheckDefaultAccount extends ICheckDefaultAccount_T {
            }
            interface IPayScheduleSelectBill_S {
            }
            interface IPayScheduleSelectBill$ {
                /**
                 * 排程选票
                 * 选票时机-背书付款：在标品自动排票规则之间加入自定义选票逻辑
                 * 步骤：
                 * 1，结算方式、金额、币别、票据到期日、是否直联票据过滤；
                 * 2，根据1的结果传入selectBills，获取接口返回的结果
                 * 3，根据2的结果进行最后的选票：金额优先/日期优先排序等
                 * @param selectBillParam 选票入参
                 * @return 票据id集合
                 */
                selectBills?(selectBillParam:kd.sdk.tmc.psd.extpoint.param.SelectBillParam):$.java.util.Set;
            }
            type IPayScheduleSelectBill_T = IPayScheduleSelectBill_S & IPayScheduleSelectBill$;
            interface IPayScheduleSelectBill extends IPayScheduleSelectBill_T {
            }
        }
        namespace kd.sdk.tmc.psd.extpoint.param{
            interface SelectBillParam_S {
            }
            type SelectBillParam_ST = $.java.io.Serializable & SelectBillParam_S;
            interface SelectBillParam_C extends SelectBillParam_ST {
                new(payScheduleInfo:PayScheduleInfo):SelectBillParam;
            }
            interface SelectBillParam$ {
                getMergeScheduleList():$.java.util.List;
                getPayScheduleInfo():PayScheduleInfo;
                getSelectBillIds():$.java.util.Set;
                setMergeScheduleList(mergeScheduleList:$.java.util.List):void;
                setPayScheduleInfo(payScheduleInfo:PayScheduleInfo):void;
                setSelectBillIds(selectBillIds:$.java.util.Set):void;
            }
            type SelectBillParam_T = $.java.io.Serializable & SelectBillParam_S & SelectBillParam$;
            interface SelectBillParam extends SelectBillParam_T {
            }
            interface PayScheduleInfo_S {
            }
            type PayScheduleInfo_ST = $.java.io.Serializable & PayScheduleInfo_S;
            interface PayScheduleInfo_C extends PayScheduleInfo_ST {
                new(dataMap:$.java.util.Map):PayScheduleInfo;
            }
            interface PayScheduleInfo$ {
                getCalcProp(scheduleCalcProp:string):PaySchedulePropVal;
                getCalcPropVal(scheduleCalcProp:string):any;
                getDataMap():$.java.util.Map;
            }
            type PayScheduleInfo_T = $.java.io.Serializable & PayScheduleInfo_S & PayScheduleInfo$;
            interface PayScheduleInfo extends PayScheduleInfo_T {
            }
            interface PaySchedulePropVal_S {
            }
            type PaySchedulePropVal_ST = $.java.io.Serializable & PaySchedulePropVal_S;
            interface PaySchedulePropVal_C extends PaySchedulePropVal_ST {
                new():PaySchedulePropVal;
            }
            interface PaySchedulePropVal$ {
                getData():any;
                getPayScheDataSetting():string;
                getScheCalcProp():string;
                getScheProp():string;
                isCombineUnique():boolean;
                isEditable():boolean;
                isVisible():boolean;
                setCombineUnique(combineUnique:boolean):void;
                setData(arg0:any):void;
                setEditable(editable:boolean):void;
                setPayScheDataSetting(payScheDataSetting:string):void;
                setScheCalcProp(scheCalcProp:string):void;
                setScheProp(scheProp:string):void;
                setVisible(visible:boolean):void;
            }
            type PaySchedulePropVal_T = $.java.io.Serializable & PaySchedulePropVal_S & PaySchedulePropVal$;
            interface PaySchedulePropVal extends PaySchedulePropVal_T {
            }
        }
        namespace kd.sdk.tmc.psd.extpoint.task{
            interface IAssemblySecondaryDevFields_S {
            }
            interface IAssemblySecondaryDevFields$ {
                /**
                 * 排程处理单二开字段封装到 Map<String, Object> 集合中
                 * @param schebill 排程处理单动态对象
                 * @return java.util.Map<java.lang.String,java.lang.Object> 返回封装好的二开字段集合; key:二开字段标识, value: 对应二开字段绑定的值
                 *
                 * <p>扩展示例如下
                 *        <pre><code>
                 *        import kd.bos.dataentity.entity.DynamicObject;
                 *        import java.util.HashMap;
                 *        import java.util.Map;
                 *
                 *        public class AssemblySecondaryDevFields_Demo implements IAssemblySecondaryDevFields {
                 *
                 *            public Map<String, Object> assemblySecondaryDevFields(DynamicObject schebill) {
                 *                Map<String, Object> fieldMap = new HashMap<>(16);
                 *                fieldMap.put("a1", schebill.getString("xxxx1"));
                 *                fieldMap.put("a2", schebill.getString("xxxx2"));
                 *                fieldMap.put("a3", schebill.getString("xxxx3"));
                 *                return fieldMap;
                 *            }
                 *        }
                 *
                 *        </code></pre>
                 */
                assemblySecondaryDevFields?(schebill:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
            }
            type IAssemblySecondaryDevFields_T = IAssemblySecondaryDevFields_S & IAssemblySecondaryDevFields$;
            interface IAssemblySecondaryDevFields extends IAssemblySecondaryDevFields_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.arap{
            interface IArApTopCustSuppInterface_S {
            }
            interface IArApTopCustSuppInterface$ {
                /**
                 * @param propertyName 客户：customername  供应商：suppliername
                 * @return 过滤器
                 * <p>默认拓展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.arap.extpoint;
                 *
                 * import kd.bos.algo.FilterFunction;
                 * import kd.bos.algo.Row;
                 * import kd.bos.dataentity.resource.ResManager;
                 * import kd.sdk.tmc.tda.extpoint.arap.IArApTopCustSuppInterface;
                 *
                 * public class ArApTopCustSuppDefaultExt implements IArApTopCustSuppInterface {
                 *
                 *     // 客户名称字段
                 *     private static final String CUSTOMER_FIELD = "customername";
                 *     // 供应商名称字段
                 *     private static final String SUPPLIER_FIELD = "suppliername";
                 *
                 *     public FilterFunction buildExtendFilter(String propertyName) {
                 *         return new FilterFunction() {
                 *
                 *            public boolean test(Row row) {
                 *                 String customerName = row.getString(propertyName);
                 *                 // 剔除包含特殊字符的客户
                 *                 if (customerName != null && CUSTOMER_FIELD.equals(propertyName)) {
                 *                     return !customerName.contains(getSpecialChar0()) && !customerName.contains(getSpecialChar1()) &&
                 *                             !customerName.contains(getSpecialChar2()) && !customerName.contains(getSpecialChar3()) &&
                 *                             !customerName.contains(getSpecialChar5());
                 *                 } else if (customerName != null && SUPPLIER_FIELD.equals(propertyName)) {   // 剔除包含特殊字符的供应商
                 *                     return !customerName.contains(getSpecialChar0()) && !customerName.contains(getSpecialChar1()) &&
                 *                             !customerName.contains(getSpecialChar2()) && !customerName.contains(getSpecialChar3()) &&
                 *                             !customerName.contains(getSpecialChar4());
                 *                 }
                 *                 return false;
                 *             }
                 *         };
                 *     }
                 *
                 *     private String getSpecialChar0() {
                 *         return ResManager.loadKDString("0万", "ArApTopCustSuppDefaultExt_0", "tmc-tda-report");
                 *     }
                 *
                 *     private String getSpecialChar1() {
                 *         return ResManager.loadKDString("其他", "ArApTopCustSuppDefaultExt_1", "tmc-tda-report");
                 *     }
                 *
                 *     private String getSpecialChar2() {
                 *         return ResManager.loadKDString("外部", "ArApTopCustSuppDefaultExt_2", "tmc-tda-report");
                 *     }
                 *
                 *     private String getSpecialChar3() {
                 *         return ResManager.loadKDString("客户", "ArApTopCustSuppDefaultExt_3", "tmc-tda-report");
                 *     }
                 *
                 *     private String getSpecialChar4() {
                 *         return ResManager.loadKDString("供应商", "ArApTopCustSuppDefaultExt_4", "tmc-tda-report");
                 *     }
                 *
                 *     private String getSpecialChar5() {
                 *         return ResManager.loadKDString("收入", "ArApTopCustSuppDefaultExt_5", "tmc-tda-report");
                 *     }
                 *
                 * }
                 *
                 * </pre></code>
                 * </p>
                 */
                buildExtendFilter(propertyName:string):$.kd.bos.algo.FilterFunction;
            }
            type IArApTopCustSuppInterface_T = IArApTopCustSuppInterface_S & IArApTopCustSuppInterface$;
            interface IArApTopCustSuppInterface extends IArApTopCustSuppInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.bankacct{
            interface IBankAcctByBankInterfaceRPA_S {
            }
            interface IBankAcctByBankInterfaceRPA$ {
                /**
                 * 通过银行账户ID查询对应账户绑定RPA个数
                 *
                 * @param param Map<Sting,Object> key：acctIds，value：需要查询的银行账户ID集合
                 * @return DataSet。共两列，列名依次为：acct_id（银行账户ID）、rpa_count（RPA个数）
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.bos.servicehelper.QueryServiceHelper;
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctByBankInterfaceRPA;
                 *
                 * import java.util.List;
                 * import java.util.Map;
                 *
                 * public class BankInterfaceRPATestExt implements IBankAcctByBankInterfaceRPA {
                 *
                 *     public DataSet queryRPADataSet(Map<String, Object> param) {
                 *         List<Long> acctIds = (List<Long>) param.get("acctIds");
                 *
                 *         // 默认通过网银登录信息维护银行账户RPA数据，则查询元数据标识 bcr_bankudset
                 *         DataSet rpaDataSet = QueryServiceHelper.queryDataSet("BankAcctByBankInterfaceSum", "bcr_bankudset",
                 *                 "entry.acctbank acct_id", new QFilter[]{new QFilter("entry.acctbank", QCP.in, acctIds)}, null);
                 *         DataSet rpaCountSet = rpaDataSet.groupBy(new String[]{"acct_id"}).countDistinct(new String[]{"acct_id"}, "rpa_count").finish();
                 *         return rpaCountSet;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                queryRPADataSet(param:$.java.util.Map):$.kd.bos.algo.DataSet;
            }
            type IBankAcctByBankInterfaceRPA_T = IBankAcctByBankInterfaceRPA_S & IBankAcctByBankInterfaceRPA$;
            interface IBankAcctByBankInterfaceRPA extends IBankAcctByBankInterfaceRPA_T {
            }
            interface IParentAcctInterface_S {
            }
            interface IParentAcctInterface$ {
                /**
                 * 通过组织视图获取所有母账户id
                 *
                 * @param param Map<Sting,Object> key：orgview，value：组织视图对象
                 * @return List<Long>所有的母账户id集合
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import java.util.ArrayList;
                 * import java.util.Arrays;
                 * import java.util.Collections;
                 * import java.util.List;
                 * import java.util.Map;
                 * import java.util.stream.Collectors;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.tmc.fbp.common.helper.TmcDataServiceHelper;
                 * import kd.tmc.fbp.common.helper.TmcOrgDataHelper;
                 * import kd.tmc.fbp.common.util.EmptyUtil;
                 * import kd.tmc.tda.common.propertys.DecisionAnlsVersionProp;
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IParentAcctInterface;
                 *
                 * public class ParentAcctDefaultExt implements IParentAcctInterface {
                 *
                 * 	public List<Long> getParentAcct(Map<String, Object> paramMap) {
                 * 		List<Long> acctIds = new ArrayList<>();
                 * 		Long orgviewId = ((DynamicObject) paramMap.get(DecisionAnlsVersionProp.ORGVIEW)).getLong("id");
                 *         Long orgId = ((DynamicObject) paramMap.get(DecisionAnlsVersionProp.ORG)).getLong("id");
                 *         List<Long> orgIds =  TmcOrgDataHelper.getAllSubordinateOrgs(orgviewId, Collections.singletonList(orgId), true);
                 * 		QFilter filter = new QFilter("company", QCP.in, orgIds);
                 * 		DynamicObject[] accts = TmcDataServiceHelper.load("fca_acctgroup","id",filter.toArray());
                 * 		if(EmptyUtil.isNoEmpty(accts)) {//查出组织视图下的所有母账户
                 *             acctIds = Arrays.stream(accts).map(p->p.getLong("id")).collect(Collectors.toList());
                 *         }
                 * 		return acctIds;
                 * 	}
                 * }
                 * </pre></code>
                 * </p>
                 */
                getParentAcct(param:$.java.util.Map):$.java.util.List;
            }
            type IParentAcctInterface_T = IParentAcctInterface_S & IParentAcctInterface$;
            interface IParentAcctInterface extends IParentAcctInterface_T {
            }
            interface IBankAcctInterface_S {
            }
            interface IBankAcctInterface$ {
                /**
                 * 账户明细表字段列扩展
                 * 扩展报表列，其中fieldKey与明细DataSet中fieldname相对应；列名称为多语言文本；可根据需要设置列数据类型
                 *
                 * @param fieldColumns
                 * @return 扩展后的明细报表列
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.bos.dataentity.entity.LocaleString;
                 * import kd.bos.dataentity.resource.ResManager;
                 * import kd.bos.entity.report.AbstractReportColumn;
                 * import kd.bos.entity.report.ReportColumn;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
                 *
                 * import java.util.List;
                 *
                 * public class BankAcctInterfaceDefaultExt implements IBankAcctInterface {
                 *
                 *     public List<Object[]> detailColumnItemsExt(List<Object[]> fieldColumns) {
                 *         fieldColumns.add(new Object[]{"fieldKey", ResManager.loadKDString("列名称", "AcctDetailDataListPlugin_20", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false,});
                 *         fieldColumns.add(new Object[]{"fieldKey", ResManager.loadKDString("列名称", "AcctDetailDataListPlugin_20", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false,});
                 *         return fieldColumns;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                detailColumnItemsExt?(fieldColumns:$.java.util.List):$.java.util.List;
                /**
                 * 账户运营元数据扩展
                 * 默认查询bd_accountbanks（银行账户），有特殊账户查询场景时需替换元数据标识即可。
                 *
                 * @return 元数据标识字符串
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
                 *
                 * public class BankAcctInterfaceDefaultExt implements IBankAcctInterface {
                 *
                 *      public String metadataSignExt() {
                 *  	    // 账户查询元数据
                 *  	    return am_accountbank;
                 *      }
                 * }
                 * </pre></code>
                 * </p>
                 */
                metadataSignExt?():string;
                /**
                 * 账户查询过滤条件扩展
                 * 在原有QFilter的基础上扩展自定义QFilter
                 *
                 * @param qFilter
                 * @return 扩展后的qFilter
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.bos.dataentity.entity.LocaleString;
                 * import kd.bos.dataentity.resource.ResManager;
                 * import kd.bos.entity.report.AbstractReportColumn;
                 * import kd.bos.entity.report.ReportColumn;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
                 *
                 * import java.util.List;
                 *
                 * public class BankAcctInterfaceDefaultExt implements IBankAcctInterface {
                 *
                 *     public QFilter qFilterExt(QFilter qFilter) {
                 *         return qFilter.and("1", QCP.equals, 1);
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                qFilterExt?(qFilter:$.kd.bos.orm.query.QFilter):$.kd.bos.orm.query.QFilter;
                /**
                 * 报表列扩展
                 * 用于动态创建报表列，列标识fieldKey与报表数据DataSet中fieldname相对应
                 *
                 * @param columns
                 * @return 扩展后的columns
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.bos.dataentity.entity.LocaleString;
                 * import kd.bos.dataentity.resource.ResManager;
                 * import kd.bos.entity.report.AbstractReportColumn;
                 * import kd.bos.entity.report.ReportColumn;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
                 *
                 * import java.util.List;
                 *
                 * public class BankAcctInterfaceDefaultExt implements IBankAcctInterface {
                 *
                 *     public List<AbstractReportColumn> reportColumnsExt(List<AbstractReportColumn> columns) {
                 *         columns.add(createColumn("fieldKey", "动态测试列", false));
                 *         return columns;
                 *     }
                 *
                 * 	private ReportColumn createColumn(String fieldKey, String caption, boolean isHide) {
                 *         ReportColumn reportColumn = new ReportColumn();
                 *         // 列标识
                 *         reportColumn.setFieldKey(fieldKey);
                 *         // 报表列数据类型
                 *         reportColumn.setFieldType(ReportColumn.TYPE_INTEGER);
                 *         // 列值为0是否显示
                 *         reportColumn.setZeroShow(true);
                 *         // 列名称
                 *         reportColumn.setCaption(new LocaleString(caption));
                 *         // 列是否隐藏
                 *         reportColumn.setHide(isHide);
                 *         return reportColumn;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                reportColumnsExt?(columns:$.java.util.List):$.java.util.List;
                /**
                 * @param dataSet
                 * @param queryParam
                 * @return
                 */
                reportDataSetExt?(dataSet:$.kd.bos.algo.DataSet,queryParam:$.kd.bos.entity.report.ReportQueryParam):$.kd.bos.algo.DataSet;
                /**
                 * 账户查询字段扩展
                 * 自定义扩展字段，也可对查询字段重命名，形如：field1 as fd1
                 *
                 * @return 查询字段字符串，以英文逗号分隔
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.bos.dataentity.entity.LocaleString;
                 * import kd.bos.dataentity.resource.ResManager;
                 * import kd.bos.entity.report.AbstractReportColumn;
                 * import kd.bos.entity.report.ReportColumn;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
                 *
                 * import java.util.List;
                 *
                 * public class BankAcctInterfaceDefaultExt implements IBankAcctInterface {
                 *
                 *     public String selectFieldsExt() {
                 *         return "field1 as fd1, field2";
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                selectFieldsExt?():string;
            }
            type IBankAcctInterface_T = IBankAcctInterface_S & IBankAcctInterface$;
            interface IBankAcctInterface extends IBankAcctInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.cash{
            interface ICashDistributionByAreaTopNumInterface_S {
            }
            interface ICashDistributionByAreaTopNumInterface$ {
                /**
                 *  决策分析头寸按区域分布显示前N个国家地区 默认15
                 *  @return topNum
                 *  <p>默认扩展示例如下
                 *  <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.cash;
                 *
                 * import kd.sdk.tmc.tda.extpoint.cash.ICashDistributionByAreaTopNumInterface;
                 *  public class CashDistributionByAreaTopNumExt implements ICashDistributionByAreaTopNumInterface{
                 *
                 *      @Override
                 *      public int getTopCountryNum() {
                 *          //显示前五国家
                 *          return 5;
                 *      }
                 *
                 *  }
                 *  </pre></code>
                 *  </p>
                 */
                getTopCountryNum?():number;
                /**
                 *  决策分析头寸按区域分布显示前N个省份
                 *  @return topNum
                 *  <p>默认扩展示例如下
                 *  <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.cash;
                 *
                 * import kd.sdk.tmc.tda.extpoint.cash.ICashDistributionByAreaTopNumInterface;
                 *  public class CashDistributionByAreaTopNumExt implements ICashDistributionByAreaTopNumInterface{
                 *
                 *      @Override
                 *      public int getTopProvinceNum() {
                 *          //显示前十省份
                 *          return 10;
                 *      }
                 *  }
                 *  </pre></code>
                 *  </p>
                 */
                getTopProvinceNum?():number;
            }
            type ICashDistributionByAreaTopNumInterface_T = ICashDistributionByAreaTopNumInterface_S & ICashDistributionByAreaTopNumInterface$;
            interface ICashDistributionByAreaTopNumInterface extends ICashDistributionByAreaTopNumInterface_T {
            }
            interface ICashCommonSourceReBuildInterface_S {
            }
            interface ICashCommonSourceReBuildInterface$ {
                /**
                 * 决策分析头寸公共取数扩展接口
                 *
                 * @param sources DataSet 标准产品公共取数的结果集
                 *
                 * @return DataSet 二开根据业务重新扩展调整后结果集
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 *
                 * package kd.tmc.tda.report.bankacct.extpoint;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.sdk.tmc.tda.extpoint.cash.ICashCommonSourceReBuildInterface;
                 * import kd.tmc.fbp.common.helper.DataSetHelper;
                 *
                 * import java.util.ArrayList;
                 * import java.util.Collections;
                 * import java.util.List;
                 *
                 * import static kd.tmc.fbp.common.enums.CashTypeEnum.ACCOUNT;
                 * import static kd.tmc.fbp.common.enums.CashTypeEnum.STRUCT;
                 *
                 * public class CashCommonSourceReBuildDefaultExt implements ICashCommonSourceReBuildInterface {
                 *     @Override
                 *     public DataSet rebuildDataSet(DataSet sources) {
                 *         //需要更新的数据，这里是某些账户id
                 *         List<Long> bankAccountIds=new ArrayList<>(10);
                 *         bankAccountIds.add(1924007106009140224L);
                 *         bankAccountIds.add(1938513307971777536L);
                 *         //先将要更新的账户分离
                 *         DataSet[] splitDs = DataSetHelper.splitByFilter(sources,new String[]{"accountbank in accountbankIds"}, Collections.singletonMap("accountbankIds",bankAccountIds),true);
                 *         DataSet updateSet = splitDs[0];
                 *         //按照业务进行更新对应的字段
                 *         updateSet = updateSet.updateFields(new String[]{"fundtypename","fundtype"},new String[]{String.format("'%s'",STRUCT.getText()),""+STRUCT.getNumber()});
                 *         //最后合并再返回
                 *         return splitDs[1].union(updateSet);
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                rebuildDataSet(sources:$.kd.bos.algo.DataSet):$.kd.bos.algo.DataSet;
            }
            type ICashCommonSourceReBuildInterface_T = ICashCommonSourceReBuildInterface_S & ICashCommonSourceReBuildInterface$;
            interface ICashCommonSourceReBuildInterface extends ICashCommonSourceReBuildInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.credit{
            interface ICreditGetDataInterface_S {
            }
            interface ICreditGetDataInterface$ {
                /**
                 * 查询授信额度自定义条件
                 *
                 * @return 自定义条件
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.credit.extpoint;
                 *
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.credit.ICreditGetDataInterface;
                 *
                 * public class CreditGetDataDefaultExt implements ICreditGetDataInterface {
                 *
                 *     public QFilter getTdaCreditExtendFilter(QFilter qFilter) {
                 *     	 // 返回自定义的QFilter
                 *         return qFilter.and("1", QCP.equals, 1);
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                getTdaCreditExtendFilter(qFilter:$.kd.bos.orm.query.QFilter):$.kd.bos.orm.query.QFilter;
            }
            type ICreditGetDataInterface_T = ICreditGetDataInterface_S & ICreditGetDataInterface$;
            interface ICreditGetDataInterface extends ICreditGetDataInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.finance{
            interface IFinanceLeaseSourceInterface_S {
            }
            interface IFinanceLeaseSourceInterface$ {
                /**
                 *  决策分析融资租赁取数源表单标识拓展
                 *
                 *  @return String 融资租赁取数表单标识
                 *
                 *  <p>默认扩展示例如下
                 *  <pre><code>
                 * package kd.tmc.tda.common.extpoint;
                 *
                 * import kd.sdk.tmc.tda.extpoint.finance.IFinanceLeaseSourceInterface;
                 *
                 * public class FinanceLeaseSourceDefaultExt implements IFinanceLeaseSourceInterface {
                 *
                 *    public String getFormId() {
                 *        return "fa_lease_contract";
                 *    }
                 *  }
                 *  </pre></code>
                 *  </p>
                 */
                getFormId():string;
            }
            type IFinanceLeaseSourceInterface_T = IFinanceLeaseSourceInterface_S & IFinanceLeaseSourceInterface$;
            interface IFinanceLeaseSourceInterface extends IFinanceLeaseSourceInterface_T {
            }
            interface IFinanceSourceReBuildInterface_S {
            }
            interface IFinanceSourceReBuildInterface$ {
                /**
                 * 决策分析融资分析集团内财务公司数据和融资租赁数据源重新分组扩展接口
                 *
                 * @param sources DataSet[] 第一个DataSet是财务公司数据源，第二个DataSet是融资租赁分组的数据源
                 *
                 * @return DataSet[] 重新分组后结果，第一个是财务公司数据DataSet和第二个是融资租赁数据DataSet
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 *
                 * package kd.sdk.tmc.tda.extpoint.finance;
                 *
                 * import kd.bos.algo.DataSet;
                 *
                 * public class FinanceSourceReBuildDefaultExt implements IFinanceSourceReBuildInterface {
                 *
                 *     public DataSet[] rebuildDataSet(DataSet[] sources) {
                 *         //财务公司
                 *         DataSet finComDataSet = sources[0];
                 *         //融资租赁
                 *         DataSet leaseDataSet = sources[1];
                 *         //将财务公司中要移到招商租赁的数据分割出来 ("billno = '融资租赁单据标号'")这个条件现场自己根据业务写
                 *         DataSet[] splitDataSet = finComDataSet.splitByFilter(new String[]{"billno = '融资租赁单据标号'"}, true);
                 *         //分割出来的融资租赁数据
                 *         DataSet leaseExtDataSet = splitDataSet[0];
                 *         //分割后剩下的财务公司的数据
                 *         DataSet newFinComDataSet = splitDataSet[1];
                 *         //重新合并融资租赁数据
                 *         DataSet newLeaseDataSet = leaseDataSet.union(leaseExtDataSet);
                 *         return new DataSet[]{newFinComDataSet, newLeaseDataSet};
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                rebuildDataSet(sources:$.kd.bos.algo.DataSet[]):$.kd.bos.algo.DataSet[];
            }
            type IFinanceSourceReBuildInterface_T = IFinanceSourceReBuildInterface_S & IFinanceSourceReBuildInterface$;
            interface IFinanceSourceReBuildInterface extends IFinanceSourceReBuildInterface_T {
            }
            interface IFinanceDataFilter_S {
            }
            interface IFinanceDataFilter$ {
                /**
                 *  决策分析融资统一取数过滤企业借款
                 *
                 *  @return String dataset过滤条件
                 *
                 *  <p>默认扩展示例如下
                 *  <pre><code>
                 * package kd.tmc.tda.common.extpoint;
                 *
                 * import kd.sdk.tmc.tda.extpoint.finance.IFinanceDataFilter;
                 *
                 * public class FinanceDataExcludeCompany implements IFinanceDataFilter {
                 *
                 *    public String getFilter() {
                 *        return "financetype != 2";
                 *    }
                 *  }
                 *  </pre></code>
                 *  </p>
                 */
                getFilter():string;
            }
            type IFinanceDataFilter_T = IFinanceDataFilter_S & IFinanceDataFilter$;
            interface IFinanceDataFilter extends IFinanceDataFilter_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.interloan{
            interface IInterLoanDetailInterface_S {
            }
            interface IInterLoanDetailInterface$ {
                /**
                 * 企业借贷明细报表列扩展
                 * 扩展报表列，其中fieldKey与明细DataSet中fieldname相对应；列名称为多语言文本；可根据需要设置列数据类型
                 *
                 * @param fieldColumns
                 * @return 扩展后的明细报表列
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.interloan;
                 *
                 * import kd.bos.algo.DataSet;
                 * import kd.bos.algo.Row;
                 * import kd.bos.dataentity.resource.ResManager;
                 * import kd.bos.entity.report.ReportColumn;
                 * import kd.bos.orm.query.QCP;
                 * import kd.bos.orm.query.QFilter;
                 * import kd.bos.servicehelper.QueryServiceHelper;
                 *
                 * import java.util.HashSet;
                 * import java.util.List;
                 * import java.util.Map;
                 * import java.util.Set;
                 *
                 * public class InterLoanInterfaceDefaultExt implements IInterLoanDetailInterface {
                 *
                 *     public List<Object[]> detailColumnItemsExt(List<Object[]> fieldColumns) {
                 *         fieldColumns.add(new Object[]{"billno", ResManager.loadKDString("单据编号", "FinanceDetailDataListPlugin_1", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false});
                 *         fieldColumns.add(new Object[]{"contractno", ResManager.loadKDString("合同编号", "FinanceDetailDataListPlugin_2", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false});
                 *         return fieldColumns;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                detailColumnItemsExt?(fieldColumns:$.java.util.List):$.java.util.List;
                /**
                 * @param dataSet
                 * @param paramMap
                 * @return
                 */
                detailDataSetExt?(dataSet:$.kd.bos.algo.DataSet,paramMap:$.java.util.Map):$.kd.bos.algo.DataSet;
            }
            type IInterLoanDetailInterface_T = IInterLoanDetailInterface_S & IInterLoanDetailInterface$;
            interface IInterLoanDetailInterface extends IInterLoanDetailInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.liquidity{
            interface ILiquidityIndicatorDetailInterface_S {
            }
            interface ILiquidityIndicatorDetailInterface$ {
                /**
                 * 增加的指标数据
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *     public List<Object[]> addColumns(List<Object[]> fields) {
                 *         fields.add(new Object[]{"duesixmonthamt", ResManager.loadKDString("6个月内到期有息债务", "LiquidityIndicatorQingDataListPlugin_7", "tmc-tda-report"), QingFieldType.Number.toNumber(), false});
                 *         fields.add(new Object[]{"fundduesixmthratio", ResManager.loadKDString("货币资金对6个月内到期债务覆盖倍数", "LiquidityIndicatorQingDataListPlugin_7", "tmc-tda-report"), QingFieldType.Number.toNumber(), false});
                 *         fields.add(new Object[]{"duesixmonthratio", ResManager.loadKDString("6个月内到期债务占比", "LiquidityIndicatorQingDataListPlugin_7", "tmc-tda-report"), QingFieldType.Number.toNumber(), false});
                 *         return fields;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 * @param fields
                 * @return
                 */
                addColumns?(fields:$.java.util.List):$.java.util.List;
                /**
                 * 流动性分析明细数据扩展-单位换算
                 * 需要切换单位的添加set
                 * @return String[]
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *  public Set<String> resetGetAmountFields(Set<String> set) {
                 *      set.add("intfeeamt");
                 *      return set;
                 *  }
                 *
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetGetAmountFields(set_arg:$.java.util.Set):$.java.util.Set;
                /**
                 * 流动性分析明细数据扩展-预处理防呆
                 * 扩展往set内添加扩展元素
                 * 此处格式化字段名称为resetIndicatorExpansion接口写入的扩展字段及别名
                 * @return set集合
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import java.util.Set;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *      public Set<String> resetIndicatorCountZeroFields(Set<String> set) {
                 *          set.add("intfeeamt");
                 *          set.add("intfeeamtyear");
                 *          set.add("intfeeamtmonth");
                 *          return set;
                 *      }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetIndicatorCountZeroFields(set_arg:$.java.util.Set):$.java.util.Set;
                /**
                 * 流动性分析明细数据扩展-扩展基础字段、同比、环比
                 * 扩展需要添加的位置
                 * 此处扩展字段,同比别名为:xxx+year,环比别名为:xxx+month
                 *
                 * @return String[]
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 * import java.util.ArrayList;
                 * import java.util.Arrays;
                 * import java.util.List;
                 * import java.util.Map;
                 * import java.util.Set;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *     public  Map<String, List<String>> resetIndicatorExpansion(Map<String,List<String>> liquidityMap){
                 *        //扩展字段所需集合 无需更改
                 *        List<String> extFieldList = liquidityMap.get("dataSets1");
                 *        List<String> extFieldYear1List = liquidityMap.get("dataSetsYear1");
                 *        List<String> extFieldYear2List = liquidityMap.get("dataSetsYear2");
                 *        List<String> extFieldMonthList = liquidityMap.get("dataSetsMonth2");
                 *
                 *        //扩展需要添加的位置 基础字段 以利息支出intfeeamt为例
                 *        extFieldList.add("intfeeamt");
                 *        //扩展同比 使用基础字段加别名的方式 别名为基础字段+year 以利息支出intfeeamt为例
                 *        extFieldYear1List.add("intfeeamt intfeeamtyear");
                 *        //扩展同比 基础字段 基础字段别名
                 *        extFieldYear2List.add("intfeeamt");
                 *        extFieldYear2List.add("intfeeamtyear");
                 *        //扩展环比 使用基础字段加别名的方式 别名为基础字段+month
                 *        extFieldMonthList.add("intfeeamt intfeeamtmonth");
                 *
                 *        //扩展后重新赋值 无需更改
                 *        liquidityMap.put("dataSets1",extFieldList);
                 *        liquidityMap.put("dataSetsYear1",extFieldYear1List);
                 *        liquidityMap.put("dataSetsYear2",extFieldYear2List);
                 *        liquidityMap.put("dataSetsMonth2",extFieldMonthList);
                 *
                 *        return liquidityMap;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetIndicatorExpansion(liquidityMap:$.java.util.Map):$.java.util.Map;
                /**
                 * 流动性分析明细数据扩展-数值类型格式化
                 * 扩展往数组内添加扩展元素
                 * @return String[]
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import java.util.ArrayList;
                 * import java.util.Arrays;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *      public String[] resetIndicatorFieldsBigFormat(String[] files) {
                 *          List<String> strList= new ArrayList<>(Arrays.asList(files));
                 *          //格式化基础字段
                 *          strList.add("intfeeamt");
                 *          return strList.toArray(new String[0]);
                 *      }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetIndicatorFieldsBigFormat(files:string[]):string[];
                /**
                 * 流动性分析明细数据扩展-百分比格式化
                 * 扩展往数组内添加扩展元素
                 * 此处格式化字段名称为resetIndicatorExpansion接口写入的扩展字段及别名
                 * @return String[]
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import java.util.ArrayList;
                 * import java.util.Arrays;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *     public String[] resetIndicatorFieldsSrFormat(String[] files) {
                 *         List<String> strList= new ArrayList<>(Arrays.asList(files));
                 *         //格式化同比环比
                 *         strList.add("intfeeamtyear");
                 *         strList.add("intfeeamtmonth");
                 *         return strList.toArray(new String[0]);
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetIndicatorFieldsSrFormat(files:string[]):string[];
                /**
                 * 流动性分析明细数据扩展-扩展字段列
                 * 扩展往数组内添加扩展元素
                 * @return String[]
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import java.util.ArrayList;
                 * import java.util.Arrays;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *     public String[] resetIndicatorFiles(String[] files) {
                 *         List<String> strList = new ArrayList<>(Arrays.asList(files));
                 *         //流动性指标明细扩展数值列
                 *         strList.add("intfeeamt");
                 *         return strList.toArray(new String[0]);
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetIndicatorFiles(files:string[]):string[];
                /**
                 * 流动性分析明细数据扩展-扩展列表查询拼接
                 * 扩展往数组内添加扩展元素
                 * @return String[]
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * public class ILiquidityIndicatorDetailInterfaceExt implements ILiquidityIndicatorDetailInterface {
                 *
                 *     public String resetIndicatorStr(String files) {
                 *         //扩展的基础字段select拼接
                 *         files = files +", intfeeamt";
                 *         return files;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetIndicatorStr(files:string):string;
            }
            type ILiquidityIndicatorDetailInterface_T = ILiquidityIndicatorDetailInterface_S & ILiquidityIndicatorDetailInterface$;
            interface ILiquidityIndicatorDetailInterface extends ILiquidityIndicatorDetailInterface_T {
            }
            interface ILiquidityCalculateInterface_S {
            }
            interface ILiquidityCalculateInterface$ {
                /**
                 * 增加的字段
                 *
                 * @return
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface;
                 *
                 * import java.math.BigDecimal;
                 * import java.math.RoundingMode;
                 *
                 * public class LiquidityCalculateDefaultExt implements ILiquidityCalculateInterface {
                 *
                 *     public List<String> addSelectorFields(List<String> fields) {
                 *         fields.add("duesixmonthamt");
                 *         fields.add("fundduesixmthratio");
                 *         fields.add("duesixmonthratio");
                 *         return null;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                addSelectorFields?(fields:$.java.util.List):$.java.util.List;
                /**
                 * 扩展的n个月内有息债务指标
                 * key：月份
                 * value：字段名（n个月内到期有息债务、n个月内到期债务占比、货币资金对n个月内到期债务覆盖倍数）
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface;
                 *
                 * import java.math.BigDecimal;
                 * import java.math.RoundingMode;
                 *
                 * public class LiquidityCalculateDefaultExt implements ILiquidityCalculateInterface {
                 *
                 *     public Map<Integer, Map<String, String>> monthDebtExt() {
                 *         Map<Integer, Map<String, String>> map = new HashMap<>();
                 *         Map<String, String> monthMap = new HashMap<>();
                 *         monthMap.put(LiquidityExtProp.MONTHDEBTAMT, "duesixmonthamt");
                 *         monthMap.put(LiquidityExtProp.FUNDDUEMTHRATIO, "fundduesixmthratio");
                 *         monthMap.put(LiquidityExtProp.DUEMONTHRATIO, "duesixmonthratio");
                 *         map.put(6, monthMap);
                 *         return map;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                monthDebtExt?():$.java.util.Map;
                /**
                 * 重新设置流动性指标计算公式
                 *
                 * @return 流动性对象
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.sdk.tmc.tda.extpoint.liquidity;
                 *
                 * import kd.bos.dataentity.entity.DynamicObject;
                 * import kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface;
                 *
                 * import java.math.BigDecimal;
                 * import java.math.RoundingMode;
                 *
                 * public class LiquidityCalculateDefaultExt implements ILiquidityCalculateInterface {
                 *     private final int DEFAULT_SCALE = 10;
                 *
                 *     public DynamicObject resetCalculationFormula(DynamicObject liquidityBill) {
                 *         // 资产
                 *         BigDecimal assetsAmt = liquidityBill.getBigDecimal(LiquidityBillProp.ASSETSAMT);
                 *         // 负债
                 *         BigDecimal debtAmt = liquidityBill.getBigDecimal(LiquidityBillProp.DEBTAMT);
                 *     	   // 有息负债率 = 有息负债/负债
                 *         BigDecimal intDebtRate = EmptyUtil.isEmpty(debtAmt) ? BigDecimal.ZERO : intDebtAmt.divide(debtAmt, DEFAULT_SCALE, RoundingMode.HALF_UP);
                 *         liquidityBill.set(LiquidityBillProp.INTDEBTRATE, intDebtRate);
                 *         return liquidityBill;
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                resetCalculationFormula(liquidityBill:$.kd.bos.dataentity.entity.DynamicObject):$.kd.bos.dataentity.entity.DynamicObject;
            }
            type ILiquidityCalculateInterface_T = ILiquidityCalculateInterface_S & ILiquidityCalculateInterface$;
            interface ILiquidityCalculateInterface extends ILiquidityCalculateInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.note{
            interface IDraftBillDecisionRptInterface_S {
            }
            interface IDraftBillDecisionRptInterface$ {
                /**
                 * 决策分析票据管理替换标准产品的票据实体
                 *
                 * @param entityName：源票据名称 应收票据：cdm_receivablebill； 应付票据：cdm_payablebill； 业务处理单据：cdm_drafttradebill
                 * @return 二开票据实体名称
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.report.note.extpoint;
                 *
                 * import kd.sdk.tmc.tda.extpoint.note.IDraftBillDecisionRptInterface;
                 * import kd.tmc.fbp.common.constant.TmcEntityConst;
                 *
                 * public class DraftBillDecisionRptDefaultExt implements IDraftBillDecisionRptInterface {
                 *
                 *      public String getDraftBillEntityName(String entityName) {
                 *          String draftBillEntityName = entityName == null ? "" : entityName;
                 *          switch (draftBillEntityName) {
                 *          case TmcEntityConst.CDM_RECEIVABLEBILL:
                 *               // 收票登记
                 *               draftBillEntityName = TmcEntityConst.CDM_RECEIVABLEBILL;
                 *               break;
                 *          case TmcEntityConst.CDM_PAYABLEBILL:
                 *               // 开票登记
                 *               draftBillEntityName = TmcEntityConst.CDM_PAYABLEBILL;
                 *               break;
                 *          case TmcEntityConst.CDM_DRAFTTRADEBILL:
                 *               // 业务处理
                 *               draftBillEntityName = TmcEntityConst.CDM_DRAFTTRADEBILL;
                 *               break;
                 *           default:
                 *         }
                 *         return draftBillEntityName;
                 *      }
                 * }
                 *
                 * </pre></code>
                 * </p>
                 */
                getDraftBillEntityName(entityName:string):string;
            }
            type IDraftBillDecisionRptInterface_T = IDraftBillDecisionRptInterface_S & IDraftBillDecisionRptInterface$;
            interface IDraftBillDecisionRptInterface extends IDraftBillDecisionRptInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.settle{
            interface IBigAmountDataInterface_S {
            }
            interface IBigAmountDataInterface$ {
                /**
                 * 取交易明细数据自定义条件
                 *
                 * @return 自定义条件
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.mservice.settle.extpoint;
                 *
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.settle.IBigAmountDataInterface;
                 *
                 * public class BigAmountDataDefaultExt implements IBigAmountDataInterface {
                 *
                 *     public QFilter getExtendFilter() {
                 *     	   // 返回自定义的QFilter
                 *         return QFilter.of("1=1");
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                getExtendFilter():$.kd.bos.orm.query.QFilter;
            }
            type IBigAmountDataInterface_T = IBigAmountDataInterface_S & IBigAmountDataInterface$;
            interface IBigAmountDataInterface extends IBigAmountDataInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.synthesis{
            interface ISynthesisLoadDataInterface_S {
            }
            interface ISynthesisLoadDataInterface$ {
                /**
                 * 综合分析项目名称二开扩展
                 *
                 * @param projectValue
                 * @return 修改后的项目名称
                 *      FD: 货币资金
                 *      PR: 收益率（年化）
                 *      IDA: 对外有息负债
                 *      FC: 融资成本（年化）
                 *      NA: 净资产
                 *      EA: 其中：权益工具
                 *      ADR: 资产负债率
                 *      IDR: 有息负债率
                 *      IDER: 有息负债率（含权益工具）
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.mservice.synthesis.extpoint;
                 *
                 * import kd.sdk.tmc.tda.extpoint.synthesis.ISynthesisLoadDataInterface;
                 *
                 * public class SynthesisLoadDataDefaultExt implements ISynthesisLoadDataInterface {
                 *
                 *     public String getExtendProjectName(String projectValue) {
                 *     	   // 修改后的名称，ProjectNameEnum需自己实现
                 *         return ProjectNameEnum.getName(projectValue);
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                getExtendProjectName(projectValue:string):string;
            }
            type ISynthesisLoadDataInterface_T = ISynthesisLoadDataInterface_S & ISynthesisLoadDataInterface$;
            interface ISynthesisLoadDataInterface extends ISynthesisLoadDataInterface_T {
            }
        }
        namespace kd.sdk.tmc.tda.extpoint.transdetail{
            interface ITransDetailGetDataInterface_S {
            }
            interface ITransDetailGetDataInterface$ {
                /**
                 * 查询交易明细自定义条件
                 *
                 * @return 自定义条件
                 *
                 * <p>默认扩展示例如下
                 * <pre><code>
                 * package kd.tmc.tda.mservice.detail.extpoint;
                 *
                 * import kd.bos.orm.query.QFilter;
                 * import kd.sdk.tmc.tda.extpoint.transdetail.ITransDetailGetDataInterface;
                 *
                 * public class TransDetailGetDataDefaultExt implements ITransDetailGetDataInterface {
                 *
                 *     public QFilter getExtendFilter() {
                 *     	// 返回自定义的QFilter
                 *         return QFilter.of("1=1");
                 *     }
                 * }
                 * </pre></code>
                 * </p>
                 */
                getExtendFilter():$.kd.bos.orm.query.QFilter;
            }
            type ITransDetailGetDataInterface_T = ITransDetailGetDataInterface_S & ITransDetailGetDataInterface$;
            interface ITransDetailGetDataInterface extends ITransDetailGetDataInterface_T {
            }
        }
        namespace kd.sdk.tmc.tm.businessbill.extpoint{
            interface IBizBillPayAmtValidateExtService_S {
            }
            interface IBizBillPayAmtValidateExtService$ {
                /**
                 * 返回生命周期的属性二开增加的字段，标品拉到这些字段后会询到生命周期对象里以便于后续使用
                 *
                 * @return
                 */
                getSourceBillExtProps?():$.java.util.List;
                /**
                 * 扩展点校验, 若校验不通过，可以直接抛出KDBizException异常提示相关错误　或　ValidateResult.failure("失败原因")
                 * 若正常返回后需要继续按标品的校验逻辑进行校验则设置ValidateResult.continueStandardCheck = true 直接用 ValidateResult.success(true)
                 * 否则设置ValidateResult.continueStandardCheck=false直接用ValidateResult.success(false)
                 *
                 * @param sourceBill  生命周期单,注意该参数没有保护所有属性，需要的属性找不到可以通过id从查或是 实现 getSourceBillExtProps()返回需要的属性标配会将返回属性加到此参数
                 * @param payBillWbParam 由标品传递给扩展接口付款单信息参数，通过它可获取付款单传递过来的基本信息，注意此时可能付款单尚未保存到数据库中-即通过付款单id查库可能查不到(这种情况通常是付款单第一次保存之前的校验)
                 */
                validate(sourceBill:$.kd.bos.dataentity.entity.DynamicObject,payBillWbParam:kd.sdk.tmc.tm.businessbill.extpoint.bean.PayBillWbParam):kd.sdk.tmc.tm.businessbill.extpoint.bean.ValidateResult;
            }
            type IBizBillPayAmtValidateExtService_T = IBizBillPayAmtValidateExtService_S & IBizBillPayAmtValidateExtService$;
            interface IBizBillPayAmtValidateExtService extends IBizBillPayAmtValidateExtService_T {
            }
        }
        namespace kd.sdk.tmc.tm.businessbill.extpoint.bean{
            interface ValidateResult_S {
                /**
                 * 校验不通过，给出原因/错误信息，该错误信息将会抛到付款单的失败提示给用户
                 * @param errorMsg
                 * @return
                 */
                failure(errorMsg:string):ValidateResult;
                /**
                 * @param continueCheck 是否需要继续走标品的校验逻辑，为true即继续走标品的完整校验逻辑
                 * @return
                 */
                success(continueCheck:boolean):ValidateResult;
            }
            type ValidateResult_ST = $.java.io.Serializable & ValidateResult_S;
            interface ValidateResult_C extends ValidateResult_ST {
                new(valid:boolean,continueCheck:boolean,errorMsg:string):ValidateResult;
            }
            interface ValidateResult$ {
                getErrorMsg():string;
                isContinueStandardCheck():boolean;
                isValid():boolean;
            }
            type ValidateResult_T = $.java.io.Serializable & ValidateResult_S & ValidateResult$;
            interface ValidateResult extends ValidateResult_T {
            }
            interface PayBillWbParam_S {
            }
            interface PayBillWbParam_C extends PayBillWbParam_S {
                new():PayBillWbParam;
            }
            interface PayBillWbParam$ {
                getActPayAmt():$.java.math.BigDecimal;
                getCurrencyId():long;
                getOperate():string;
                getPayBillId():long;
                getSettleTag():string;
                isDiffCur():boolean;
                setActPayAmt(actPayAmt:$.java.math.BigDecimal):void;
                setCurrencyId(currencyId:long):void;
                setDiffCur(diffCur:boolean):void;
                setOperate(operate:string):void;
                setPayBillId(payBillId:long):void;
                setSettleTag(settleTag:string):void;
            }
            type PayBillWbParam_T = PayBillWbParam_S & PayBillWbParam$;
            interface PayBillWbParam extends PayBillWbParam_T {
            }
        }
        namespace kd.sdk.tmc.tm.forex.extpoint{
            interface IAutoSetExchangeRateDevService_S {
            }
            interface IAutoSetExchangeRateDevService$ {
                /**
                 * 是否需要程序自动获取汇率（外汇即期、外汇远期、外汇掉期交易执行单）
                 *
                 * <p>扩展示例如下<p/>
                 * <pre>
                 *     <code>
                 *     public class AutoSetExchangeRateDevServiceImpl implements IAutoSetExchangeRateDevService {
                 *         @Override
                 *         public void isAutoSetExchangeRate() {
                 *              // 如果不需要程序自动获取汇率而是用户手录汇率，则返回false
                 *              return false;
                 *         }
                 *     }
                 *     </code>
                 * </pre>
                 */
                isAutoSetExchangeRate?():boolean;
            }
            type IAutoSetExchangeRateDevService_T = IAutoSetExchangeRateDevService_S & IAutoSetExchangeRateDevService$;
            interface IAutoSetExchangeRateDevService extends IAutoSetExchangeRateDevService_T {
            }
            interface IForexWbExcludeStatusExtService_S {
            }
            interface IForexWbExcludeStatusExtService$ {
                /**
                 * 外汇单据的废弃状态的集合
                 *
                 * <p>扩展示例如下<p/>
                 * <pre>
                 *     <code>
                 *     public class ForexWbExcludeStatusExtServiceImpl implements IForexWbExcludeStatusExtService {
                 *         @Override
                 *         public List<String> getExcludeStatus() {
                 *              List<String> list = new ArrayList<>(1);
                 *              list.add("abandoned");// 废弃的（现场二开billstatus增加了状态：已废弃/abandoned）
                 *              return list;
                 *         }
                 *     }
                 *     </code>
                 * </pre>
                 */
                getExcludeStatus?():$.java.util.List;
            }
            type IForexWbExcludeStatusExtService_T = IForexWbExcludeStatusExtService_S & IForexWbExcludeStatusExtService$;
            interface IForexWbExcludeStatusExtService extends IForexWbExcludeStatusExtService_T {
            }
        }
        namespace kd.sdk.tmc.tm.init.forexfwd{
            interface IForexFwdInit2TradeSecondDevService_S {
            }
            interface IForexFwdInit2TradeSecondDevService$ {
                /**
                 * 外汇远期初始化单据的二开字段=>外汇远期单据
                 *
                 * @param initBill     初始化单据
                 * @param forexFwdBill 外汇远期单据
                 */
                process?(initBill:$.kd.bos.dataentity.entity.DynamicObject,forexFwdBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IForexFwdInit2TradeSecondDevService_T = IForexFwdInit2TradeSecondDevService_S & IForexFwdInit2TradeSecondDevService$;
            interface IForexFwdInit2TradeSecondDevService extends IForexFwdInit2TradeSecondDevService_T {
            }
            interface IForexFwdInit2BizBillSecondDevService_S {
            }
            interface IForexFwdInit2BizBillSecondDevService$ {
                /**
                 * 外汇远期初始化单据的二开字段=>生命周期操作单
                 *
                 * @param initBill 初始化单据
                 * @param entryRow 初始化单据.生命周期信息.分录行
                 * @param BizBill  生命周期操作单据
                 */
                process?(initBill:$.kd.bos.dataentity.entity.DynamicObject,entryRow:$.kd.bos.dataentity.entity.DynamicObject,BizBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IForexFwdInit2BizBillSecondDevService_T = IForexFwdInit2BizBillSecondDevService_S & IForexFwdInit2BizBillSecondDevService$;
            interface IForexFwdInit2BizBillSecondDevService extends IForexFwdInit2BizBillSecondDevService_T {
            }
        }
        namespace kd.sdk.tmc.tm.plinfo.extpoint{
            interface IPlInfoDevService_S {
            }
            interface IPlInfoDevService$ {
                /**
                 * （外汇类交易/利率类交易/结构化产品）“交易确认”操作或货币互换“买入结算”操作生成损益时支持二开字段带到损益信息单的扩展插件
                 *
                 * @param plInfo     损益信息单据
                 * @param tradeBill 交易单据
                 * <p>扩展示例如下<p/>
                 * <pre>
                 *     <code>
                 *     public class PlInfoDevServiceImpl implements IPlInfoDevService {
                 *         @Override
                 *         public void process(DynamicObject plInfo, DynamicObject tradeBill) {
                 *                 ...
                 *         }
                 *     }
                 *     </code>
                 * </pre>
                 */
                process?(plInfo:$.kd.bos.dataentity.entity.DynamicObject,tradeBill:$.kd.bos.dataentity.entity.DynamicObject):void;
            }
            type IPlInfoDevService_T = IPlInfoDevService_S & IPlInfoDevService$;
            interface IPlInfoDevService extends IPlInfoDevService_T {
            }
        }
        namespace kd.sdk.tmc.tm.swaps.extpoint{
            interface IFixedInterestRateAllowZeroDevService_S {
            }
            interface IFixedInterestRateAllowZeroDevService$ {
                /**
                 * 互换交易的支付方和收取方的固定利率是否允许为0
                 *
                 * <p>扩展示例如下<p/>
                 * <pre>
                 *     <code>
                 *     public class FixedInterestRateAllowZeroDevServiceImpl implements IFixedInterestRateAllowZeroDevService {
                 *         @Override
                 *         public void isFixedInterestRateAllowZero() {
                 *              return true;// 支付方和收取方的固定利率允许为0，返回true
                 *         }
                 *     }
                 *     </code>
                 * </pre>
                 */
                isFixedInterestRateAllowZero?():boolean;
            }
            type IFixedInterestRateAllowZeroDevService_T = IFixedInterestRateAllowZeroDevService_S & IFixedInterestRateAllowZeroDevService$;
            interface IFixedInterestRateAllowZeroDevService extends IFixedInterestRateAllowZeroDevService_T {
            }
        }
        namespace kd.sdk.tmc.tmbrm.extpoint{
            interface IFinOrgArchivesAssociatedBillInterface_S {
            }
            interface IFinOrgArchivesAssociatedBillInterface$ {
                /**
                 * 关联业务单据过滤条件拓展
                 * @param associatedOrg 关联组织
                 * @return key-关联业务单据实体标识，value-单据过滤条件
                 */
                getBillQFilter(associatedOrg:$.kd.bos.dataentity.entity.DynamicObject):$.java.util.Map;
                /**
                 * 关联业务单据类型拓展
                 * @return 关联业务单据实体标识集合
                 */
                getBillType():$.java.util.List;
            }
            type IFinOrgArchivesAssociatedBillInterface_T = IFinOrgArchivesAssociatedBillInterface_S & IFinOrgArchivesAssociatedBillInterface$;
            interface IFinOrgArchivesAssociatedBillInterface extends IFinOrgArchivesAssociatedBillInterface_T {
            }
        }
    }
}
export {};