@nocobase/flow-engine 2.0.0-alpha.10

package/lib/models/forkFlowModel.d.ts

@@ -0,0 +1,83 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { FlowModelContext } from '../flowContext';
+import type { IModelComponentProps } from '../types';
+import { FlowModel } from './flowModel';
+/**
+ * ForkFlowModel 作为 FlowModel 的独立实例：
+ *  - 大部分属性在 fork 本地存储，实现真正的实例隔离
+ *  - 只有特定的共享属性（如 stepParams、sortIndex）会同步到 master
+ *  - 透传的函数中 this 指向 fork 实例，而非 master，确保正确的上下文
+ *  - 使用 Object.create 创建临时上下文，确保 this.constructor 指向正确的类（避免异步竞态条件）
+ *  - setter 方法中的 this 也指向 fork 实例，保持一致的上下文行为
+ *  - 不会被注册到 FlowEngine.modelInstances 中，保持 uid → master 唯一性假设
+ */
+export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
+    #private;
+    /** 与 master 相同的 UID，用于日志调试 */
+    readonly uid: string;
+    /** 调试标识，便于在日志或断言中快速识别 */
+    readonly isFork = true;
+    /** 本地覆盖的 props，fork 层面的 UI/状态 */
+    localProps: IModelComponentProps;
+    /** master 引用 */
+    private master;
+    /** 是否已被释放 */
+    private disposed;
+    /** fork 在 master.forks 中的索引 */
+    readonly forkId: number;
+    /** 需要与 master 共享的属性列表 */
+    private static readonly SHARED_PROPERTIES;
+    /**
+     * 配置需要与 master 共享的属性列表
+     * @param properties 共享属性名称数组
+     */
+    static setSharedProperties(properties: string[]): void;
+    /**
+     * 获取当前配置的共享属性列表
+     */
+    static getSharedProperties(): string[];
+    /**
+     * fork 本地存储的属性，除了共享属性外的所有属性都存储在这里
+     * 注意：此属性通过 Proxy 在 get/set 陷阱中被动态访问，IDE 可能无法检测到使用, 切勿删除！
+     */
+    private localProperties;
+    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: number);
+    get context(): FlowModelContext;
+    /**
+     * 获取对象及其原型链上的属性描述符
+     */
+    private getPropertyDescriptor;
+    /**
+     * 修改局部 props，仅影响当前 fork
+     */
+    setProps(key: string | IModelComponentProps, value?: any): void;
+    /**
+     * render 依旧使用 master 的方法，但合并后的 props 需要透传
+     */
+    render(): any;
+    /**
+     * 事件缓存的作用域标识（fork 专用）。
+     */
+    getFlowCacheScope(eventName: string): string;
+    /**
+     * 释放 fork：从 master.forks 中移除自身并断开引用
+     */
+    dispose(): void;
+    /**
+     * 获取合并后的 props（master + localProps，local 优先）
+     */
+    getProps(): IModelComponentProps;
+    /**
+     * 检查属性是否为共享属性
+     */
+    private isSharedProperty;
+}
+export interface ForkFlowModel<TMaster extends FlowModel = FlowModel> extends FlowModel {
+}

package/lib/models/forkFlowModel.js

@@ -0,0 +1,280 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var forkFlowModel_exports = {};
+__export(forkFlowModel_exports, {
+  ForkFlowModel: () => ForkFlowModel
+});
+module.exports = __toCommonJS(forkFlowModel_exports);
+var import_reactive = require("@formily/reactive");
+var import_flowContext = require("../flowContext");
+var _flowContext;
+const _ForkFlowModel = class _ForkFlowModel {
+  constructor(master, initialProps = {}, forkId = 0) {
+    /** 与 master 相同的 UID，用于日志调试 */
+    __publicField(this, "uid");
+    /** 调试标识，便于在日志或断言中快速识别 */
+    __publicField(this, "isFork", true);
+    /** 本地覆盖的 props，fork 层面的 UI/状态 */
+    __publicField(this, "localProps");
+    /** master 引用 */
+    __publicField(this, "master");
+    /** 是否已被释放 */
+    __publicField(this, "disposed", false);
+    /** fork 在 master.forks 中的索引 */
+    __publicField(this, "forkId");
+    /**
+     * fork 本地存储的属性，除了共享属性外的所有属性都存储在这里
+     * 注意：此属性通过 Proxy 在 get/set 陷阱中被动态访问，IDE 可能无法检测到使用, 切勿删除！
+     */
+    __publicField(this, "localProperties", {});
+    // 不需要定义自己的属性了，现在是SHARED_PROPERTIES中指定的少数几个属性，所有属性设置时会自动添加自己的fork内的独有属性
+    __privateAdd(this, _flowContext);
+    void this.localProperties;
+    this.master = master;
+    this.uid = master.uid;
+    this.localProps = { ...initialProps };
+    this.forkId = forkId;
+    this.hidden = this.master.hidden;
+    (0, import_reactive.define)(this, {
+      localProps: import_reactive.observable,
+      hidden: import_reactive.observable,
+      setProps: import_reactive.action
+    });
+    return new Proxy(this, {
+      get: /* @__PURE__ */ __name((target, prop, receiver) => {
+        var _a;
+        if (prop === "disposed") return target.disposed;
+        if (prop === "constructor") {
+          return target.master.constructor;
+        }
+        if (prop === "props") {
+          return { ...target.master.getProps(), ...target.localProps };
+        }
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        if (Object.prototype.hasOwnProperty.call(target.localProperties, prop)) {
+          return target.localProperties[prop];
+        }
+        const value = (_a = target.master) == null ? void 0 : _a[prop];
+        if (typeof value === "function") {
+          const masterConstructor = target.master.constructor;
+          return function(...args) {
+            const contextThis = Object.create(this);
+            Object.defineProperty(contextThis, "constructor", {
+              value: masterConstructor,
+              configurable: true,
+              enumerable: false,
+              writable: false
+            });
+            return value.apply(contextThis, args);
+          }.bind(receiver);
+        }
+        return value;
+      }, "get"),
+      set: /* @__PURE__ */ __name((target, prop, value, receiver) => {
+        if (prop === "props") {
+          return true;
+        }
+        if (prop in target) {
+          return Reflect.set(target, prop, value, receiver);
+        }
+        const propString = String(prop);
+        const isSharedProperty = _ForkFlowModel.SHARED_PROPERTIES.includes(propString);
+        if (isSharedProperty) {
+          const descriptor = this.getPropertyDescriptor(target.master, prop);
+          if (descriptor && descriptor.set) {
+            descriptor.set.call(receiver, value);
+            return true;
+          } else {
+            target.master[prop] = value;
+            return true;
+          }
+        } else {
+          const descriptor = this.getPropertyDescriptor(target.master, prop);
+          if (descriptor && descriptor.set) {
+            descriptor.set.call(receiver, value);
+            return true;
+          } else {
+            target.localProperties[prop] = value;
+            return true;
+          }
+        }
+      }, "set")
+    });
+  }
+  /**
+   * 配置需要与 master 共享的属性列表
+   * @param properties 共享属性名称数组
+   */
+  static setSharedProperties(properties) {
+    this.SHARED_PROPERTIES = [...properties];
+  }
+  /**
+   * 获取当前配置的共享属性列表
+   */
+  static getSharedProperties() {
+    return [...this.SHARED_PROPERTIES];
+  }
+  get context() {
+    if (!this["#flowContext"]) {
+      this["#flowContext"] = new import_flowContext.FlowForkModelContext(this.master, this);
+    }
+    return this["#flowContext"];
+  }
+  /**
+   * 获取对象及其原型链上的属性描述符
+   */
+  getPropertyDescriptor(obj, prop) {
+    let current = obj;
+    while (current) {
+      const descriptor = Object.getOwnPropertyDescriptor(current, prop);
+      if (descriptor) {
+        return descriptor;
+      }
+      current = Object.getPrototypeOf(current);
+    }
+    return void 0;
+  }
+  /**
+   * 修改局部 props，仅影响当前 fork
+   */
+  setProps(key, value) {
+    if (this.disposed) return;
+    if (typeof key === "string") {
+      this.localProps[key] = value;
+    } else {
+      this.localProps = { ...this.localProps, ...key };
+    }
+  }
+  /**
+   * render 依旧使用 master 的方法，但合并后的 props 需要透传
+   */
+  render() {
+    if (this.disposed) return null;
+    const mergedProps = { ...this.master.getProps(), ...this.localProps };
+    const originalProps = this.props;
+    this.props = mergedProps;
+    try {
+      return this.master.render.call(this);
+    } finally {
+      this.props = originalProps;
+    }
+  }
+  /**
+   * 事件缓存的作用域标识（fork 专用）。
+   */
+  getFlowCacheScope(eventName) {
+    return `${String(eventName)}:${String(this.forkId)}`;
+  }
+  // onUnmount() {
+  //   // 不在此处自动 dispose（避免破坏外部 fork 管理），但应透传到 master 的 onUnmount 钩子，
+  //   // 以便用户在子类覆盖 onUnmount 时依然能在 cleanRun 场景下收到回调。
+  //   try {
+  //     const masterOnUnmount = (this.master as any)?.onUnmount;
+  //     if (typeof masterOnUnmount === 'function') {
+  //       // 使用 fork 作为 this，保持与运行/渲染一致的上下文
+  //       return masterOnUnmount.call(this);
+  //     }
+  //   } catch {
+  //     // 忽略钩子中的异常，保持卸载流程健壮
+  //   }
+  // }
+  /**
+   * 释放 fork：从 master.forks 中移除自身并断开引用
+   */
+  dispose() {
+    var _a;
+    if (this.disposed) return;
+    this.disposed = true;
+    try {
+      const cache = (_a = this.flowEngine) == null ? void 0 : _a.applyFlowCache;
+      if (cache && cache.size > 0) {
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        const forkIdColon = `:${this.forkId}:`;
+        const forkIdHyphen = `-${this.forkId}-`;
+        for (const key of cache.keys()) {
+          const isEventCache = key.startsWith("event:") || key.startsWith("event-");
+          if (!isEventCache) continue;
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          if (!endMatches) continue;
+          let trimmed = key;
+          for (const suf of uidSuffixes) {
+            if (trimmed.endsWith(suf)) {
+              trimmed = trimmed.slice(0, -suf.length);
+              break;
+            }
+          }
+          if (trimmed.includes(forkIdColon) || trimmed.includes(forkIdHyphen)) {
+            cache.delete(key);
+          }
+        }
+      }
+    } catch {
+    }
+    if (this.master && this.master.forks) {
+      this.master.forks.delete(this);
+    }
+    if (this.master && this.master.forkCache) {
+      const forkCache = this.master.forkCache;
+      for (const [key, fork] of forkCache.entries()) {
+        if (fork === this) {
+          forkCache.delete(key);
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * 获取合并后的 props（master + localProps，local 优先）
+   */
+  getProps() {
+    return { ...this.master.getProps(), ...this.localProps };
+  }
+  /**
+   * 检查属性是否为共享属性
+   */
+  isSharedProperty(prop) {
+    return _ForkFlowModel.SHARED_PROPERTIES.includes(prop);
+  }
+};
+_flowContext = new WeakMap();
+__name(_ForkFlowModel, "ForkFlowModel");
+/** 需要与 master 共享的属性列表 */
+__publicField(_ForkFlowModel, "SHARED_PROPERTIES", ["stepParams", "sortIndex"]);
+let ForkFlowModel = _ForkFlowModel;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForkFlowModel
+});

package/lib/models/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export * from './flowModel';
+export * from './forkFlowModel';
+export * from './CollectionFieldModel';
+export * from './DisplayItemModel';
+export * from './EditableItemModel';
+export * from './FilterableItemModel';

package/lib/models/index.js

@@ -0,0 +1,40 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var models_exports = {};
+module.exports = __toCommonJS(models_exports);
+__reExport(models_exports, require("./flowModel"), module.exports);
+__reExport(models_exports, require("./forkFlowModel"), module.exports);
+__reExport(models_exports, require("./CollectionFieldModel"), module.exports);
+__reExport(models_exports, require("./DisplayItemModel"), module.exports);
+__reExport(models_exports, require("./EditableItemModel"), module.exports);
+__reExport(models_exports, require("./FilterableItemModel"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./flowModel"),
+  ...require("./forkFlowModel"),
+  ...require("./CollectionFieldModel"),
+  ...require("./DisplayItemModel"),
+  ...require("./EditableItemModel"),
+  ...require("./FilterableItemModel")
+});

package/lib/provider.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import React from 'react';
+import { FlowEngineContext } from './flowContext';
+import { FlowEngine } from './flowEngine';
+interface FlowEngineProviderProps {
+    engine: FlowEngine;
+    children: React.ReactNode;
+}
+export declare const FlowEngineProvider: React.FC<FlowEngineProviderProps>;
+export declare const FlowEngineGlobalsContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useFlowEngine: () => FlowEngine;
+export declare const useFlowEngineContext: () => FlowEngineContext;
+export {};

package/lib/provider.js

@@ -0,0 +1,115 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var provider_exports = {};
+__export(provider_exports, {
+  FlowEngineGlobalsContextProvider: () => FlowEngineGlobalsContextProvider,
+  FlowEngineProvider: () => FlowEngineProvider,
+  useFlowEngine: () => useFlowEngine,
+  useFlowEngineContext: () => useFlowEngineContext
+});
+module.exports = __toCommonJS(provider_exports);
+var import_antd = require("antd");
+var import_react = __toESM(require("react"));
+var import_FlowContextProvider = require("./FlowContextProvider");
+var import_views = require("./views");
+var import_FlowView = require("./views/FlowView");
+const FlowEngineReactContext = (0, import_react.createContext)(null);
+const FlowEngineProvider = import_react.default.memo((props) => {
+  const { engine, children } = props;
+  if (!engine) {
+    throw new Error("FlowEngineProvider must be supplied with an engine.");
+  }
+  return /* @__PURE__ */ import_react.default.createElement(FlowEngineReactContext.Provider, { value: engine }, /* @__PURE__ */ import_react.default.createElement(import_FlowContextProvider.FlowContextProvider, { context: engine.context }, children));
+});
+FlowEngineProvider.displayName = "FlowEngineProvider";
+const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) => {
+  const { modal, message, notification } = import_antd.App.useApp();
+  const [drawer, contextHolder] = (0, import_views.useDrawer)();
+  const [embed, pageContextHolder] = (0, import_views.usePage)();
+  const [popover, popoverContextHolder] = (0, import_views.usePopover)();
+  const [dialog, dialogContextHolder] = (0, import_views.useDialog)();
+  const engine = useFlowEngine();
+  const config = (0, import_react.useContext)(import_antd.ConfigProvider.ConfigContext);
+  const { token } = import_antd.theme.useToken();
+  (0, import_react.useEffect)(() => {
+    const context = {
+      antdConfig: config,
+      // themeToken 改为可观察的 getter，在下方单独 define
+      modal,
+      message,
+      notification
+    };
+    engine.context.defineProperty("viewer", {
+      cache: false,
+      get: /* @__PURE__ */ __name((ctx) => new import_FlowView.FlowViewer(ctx, { drawer, embed, popover, dialog }), "get")
+    });
+    engine.context.defineProperty("themeToken", {
+      get: /* @__PURE__ */ __name(() => token, "get"),
+      observable: true,
+      cache: true
+    });
+    for (const item of Object.entries(context)) {
+      const [key, value] = item;
+      if (value) {
+        engine.context.defineProperty(key, { value });
+      }
+    }
+    engine.reactView.refresh();
+  }, [engine, drawer, modal, message, notification, config, popover, token, dialog, embed]);
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children, contextHolder, popoverContextHolder, pageContextHolder, dialogContextHolder);
+}, "FlowEngineGlobalsContextProvider");
+const useFlowEngine = /* @__PURE__ */ __name(() => {
+  const context = (0, import_react.useContext)(FlowEngineReactContext);
+  if (!context) {
+    throw new Error(
+      "useFlowEngine must be used within a FlowEngineProvider, and FlowEngineProvider must be supplied with an engine."
+    );
+  }
+  return context;
+}, "useFlowEngine");
+const useFlowEngineContext = /* @__PURE__ */ __name(() => {
+  const engine = useFlowEngine();
+  return engine.context;
+}, "useFlowEngineContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowEngineGlobalsContextProvider,
+  FlowEngineProvider,
+  useFlowEngine,
+  useFlowEngineContext
+});

package/lib/resources/apiResource.d.ts

@@ -0,0 +1,34 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { APIClient } from '@nocobase/sdk';
+import { FlowContext } from '../flowContext';
+import { FlowResource } from './flowResource';
+export declare class APIResource<TData = any> extends FlowResource<TData> {
+    protected request: any;
+    protected api: APIClient;
+    constructor(context?: FlowContext);
+    setAPIClient(api: APIClient): this;
+    getURL(): string;
+    setURL(value: string): this;
+    get loading(): boolean;
+    set loading(value: boolean);
+    clearRequestParameters(): this;
+    setRequestParameters(params: Record<string, any>): this;
+    setRequestMethod(method: string): this;
+    addRequestHeader(key: string, value: string): this;
+    removeRequestHeader(key: string): this;
+    addRequestParameter(key: string, value: any): this;
+    getRequestParameter(key: string): any;
+    removeRequestParameter(key: string): this;
+    setRequestBody(data: any): this;
+    setRequestOptions(key: string, value: any): this;
+    getRequestOptions(): any;
+    refresh(): Promise<void>;
+    protected getRefreshRequestOptions(): any;
+}