@tachybase/schema 0.23.40 → 0.23.47

package/lib/core/models/LifeCycle.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LifeCycle_exports = {};
+__export(LifeCycle_exports, {
+  LifeCycle: () => LifeCycle
+});
+module.exports = __toCommonJS(LifeCycle_exports);
+var import_shared = require("../../shared");
+const _LifeCycle = class _LifeCycle {
+  constructor(...params) {
+    this.buildListener = /* @__PURE__ */ __name((params) => {
+      return function(payload, ctx) {
+        for (let index = 0; index < params.length; index++) {
+          let item = params[index];
+          if ((0, import_shared.isFn)(item)) {
+            item.call(this, payload, ctx);
+          } else if ((0, import_shared.isStr)(item) && (0, import_shared.isFn)(params[index + 1])) {
+            if (item === payload.type) {
+              params[index + 1].call(this, payload.payload, ctx);
+            }
+            index++;
+          } else {
+            (0, import_shared.each)(item, (handler, type) => {
+              if ((0, import_shared.isFn)(handler) && (0, import_shared.isStr)(type)) {
+                if (type === payload.type) {
+                  handler.call(this, payload.payload, ctx);
+                  return false;
+                }
+              }
+            });
+          }
+        }
+      };
+    }, "buildListener");
+    this.notify = /* @__PURE__ */ __name((type, payload, ctx) => {
+      if ((0, import_shared.isStr)(type)) {
+        this.listener.call(ctx, { type, payload }, ctx);
+      }
+    }, "notify");
+    this.listener = this.buildListener(params);
+  }
+};
+__name(_LifeCycle, "LifeCycle");
+let LifeCycle = _LifeCycle;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LifeCycle
+});

package/lib/core/models/ObjectField.d.ts

@@ -0,0 +1,12 @@
+import { FormPathPattern, IFieldProps, JSXComponent } from '../types';
+import { Field } from './Field';
+import { Form } from './Form';
+export declare class ObjectField<Decorator extends JSXComponent = any, Component extends JSXComponent = any> extends Field<Decorator, Component, any, Record<string, any>> {
+    displayName: string;
+    private additionalProperties;
+    constructor(address: FormPathPattern, props: IFieldProps<Decorator, Component>, form: Form, designable: boolean);
+    protected makeAutoCleanable(): void;
+    addProperty: (key: string, value: any) => Promise<void>;
+    removeProperty: (key: string) => Promise<void>;
+    existProperty: (key: string) => any;
+}

package/lib/core/models/ObjectField.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ObjectField_exports = {};
+__export(ObjectField_exports, {
+  ObjectField: () => ObjectField
+});
+module.exports = __toCommonJS(ObjectField_exports);
+var import_reactive = require("../../reactive");
+var import_internals = require("../shared/internals");
+var import_Field = require("./Field");
+const _ObjectField = class _ObjectField extends import_Field.Field {
+  constructor(address, props, form, designable) {
+    super(address, props, form, designable);
+    this.displayName = "ObjectField";
+    this.additionalProperties = [];
+    this.addProperty = /* @__PURE__ */ __name((key, value) => {
+      this.form.setValuesIn(this.path.concat(key), value);
+      this.additionalProperties.push(key);
+      return this.onInput(this.value);
+    }, "addProperty");
+    this.removeProperty = /* @__PURE__ */ __name((key) => {
+      this.form.deleteValuesIn(this.path.concat(key));
+      this.additionalProperties.splice(this.additionalProperties.indexOf(key), 1);
+      return this.onInput(this.value);
+    }, "removeProperty");
+    this.existProperty = /* @__PURE__ */ __name((key) => {
+      return this.form.existValuesIn(this.path.concat(key));
+    }, "existProperty");
+    this.makeAutoCleanable();
+  }
+  makeAutoCleanable() {
+    this.disposers.push(
+      (0, import_reactive.reaction)(
+        () => Object.keys(this.value || {}),
+        (newKeys) => {
+          const filterKeys = this.additionalProperties.filter((key) => !newKeys.includes(key));
+          (0, import_internals.cleanupObjectChildren)(this, filterKeys);
+        }
+      )
+    );
+  }
+};
+__name(_ObjectField, "ObjectField");
+let ObjectField = _ObjectField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObjectField
+});

package/lib/core/models/Query.d.ts

@@ -0,0 +1,18 @@
+import { FormPath, FormPathPattern } from '../../shared';
+import { GeneralField, IGeneralFieldState, IQueryProps } from '../types';
+export declare class Query {
+    private pattern;
+    private addresses;
+    private form;
+    constructor(props: IQueryProps);
+    take(): GeneralField | undefined;
+    take<Result>(getter: (field: GeneralField, address: FormPath) => Result): Result;
+    map(): GeneralField[];
+    map<Result>(iterator?: (field: GeneralField, address: FormPath) => Result): Result[];
+    forEach<Result>(iterator: (field: GeneralField, address: FormPath) => Result): void;
+    reduce<Result>(reducer: (value: Result, field: GeneralField, address: FormPath) => Result, initial?: Result): Result;
+    get<K extends keyof IGeneralFieldState>(key: K): IGeneralFieldState[K];
+    getIn(pattern?: FormPathPattern): any;
+    value(): any;
+    initialValue(): any;
+}

package/lib/core/models/Query.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Query_exports = {};
+__export(Query_exports, {
+  Query: () => Query
+});
+module.exports = __toCommonJS(Query_exports);
+var import_shared = require("../../shared");
+var import_internals = require("../shared/internals");
+const output = /* @__PURE__ */ __name((field, taker) => {
+  if (!field) return;
+  if ((0, import_shared.isFn)(taker)) {
+    return taker(field, field.address);
+  }
+  return field;
+}, "output");
+const takeMatchPattern = /* @__PURE__ */ __name((form, pattern) => {
+  const identifier = pattern.toString();
+  const indexIdentifier = form.indexes[identifier];
+  const absoluteField = form.fields[identifier];
+  const indexField = form.fields[indexIdentifier];
+  if (absoluteField) {
+    return identifier;
+  } else if (indexField) {
+    return indexIdentifier;
+  }
+}, "takeMatchPattern");
+const _Query = class _Query {
+  constructor(props) {
+    this.addresses = [];
+    this.pattern = import_shared.FormPath.parse(props.pattern, props.base);
+    this.form = props.form;
+    if (!this.pattern.isMatchPattern) {
+      const matched = takeMatchPattern(
+        this.form,
+        this.pattern.haveRelativePattern ? (0, import_internals.buildDataPath)(props.form.fields, this.pattern) : this.pattern
+      );
+      if (matched) {
+        this.addresses = [matched];
+      }
+    } else {
+      (0, import_shared.each)(this.form.fields, (field, address) => {
+        if (!field) {
+          delete this.form.fields[address];
+          return;
+        }
+        if (field.match(this.pattern)) {
+          this.addresses.push(address);
+        }
+      });
+    }
+  }
+  take(taker) {
+    return output(this.form.fields[this.addresses[0]], taker);
+  }
+  map(iterator) {
+    return this.addresses.map((address) => output(this.form.fields[address], iterator));
+  }
+  forEach(iterator) {
+    return this.addresses.forEach((address) => output(this.form.fields[address], iterator));
+  }
+  reduce(reducer, initial) {
+    return this.addresses.reduce(
+      (value, address) => output(this.form.fields[address], (field, address2) => reducer(value, field, address2)),
+      initial
+    );
+  }
+  get(key) {
+    const results = this.take();
+    if (results) {
+      return results[key];
+    }
+  }
+  getIn(pattern) {
+    return import_shared.FormPath.getIn(this.take(), pattern);
+  }
+  value() {
+    return this.get("value");
+  }
+  initialValue() {
+    return this.get("initialValue");
+  }
+};
+__name(_Query, "Query");
+let Query = _Query;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Query
+});

package/lib/core/models/VoidField.d.ts

@@ -0,0 +1,14 @@
+import { FormPathPattern } from '../../shared';
+import { IModelGetter, IModelSetter, IVoidFieldProps, IVoidFieldState } from '../types';
+import { BaseField } from './BaseField';
+import { Form } from './Form';
+export declare class VoidField<Decorator = any, Component = any, TextType = any> extends BaseField<Decorator, Component, TextType> {
+    displayName: 'VoidField';
+    props: IVoidFieldProps<Decorator, Component>;
+    constructor(address: FormPathPattern, props: IVoidFieldProps<Decorator, Component>, form: Form, designable: boolean);
+    protected initialize(): void;
+    protected makeObservable(): void;
+    protected makeReactive(): void;
+    setState: IModelSetter<IVoidFieldState>;
+    getState: IModelGetter<IVoidFieldState>;
+}

package/lib/core/models/VoidField.js

@@ -0,0 +1,117 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var VoidField_exports = {};
+__export(VoidField_exports, {
+  VoidField: () => VoidField
+});
+module.exports = __toCommonJS(VoidField_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_internals = require("../shared/internals");
+var import_BaseField = require("./BaseField");
+const _VoidField = class _VoidField extends import_BaseField.BaseField {
+  constructor(address, props, form, designable) {
+    super();
+    this.displayName = "VoidField";
+    this.setState = (0, import_internals.createStateSetter)(this);
+    this.getState = (0, import_internals.createStateGetter)(this);
+    this.form = form;
+    this.props = props;
+    this.designable = designable;
+    (0, import_internals.initializeStart)();
+    this.locate(address);
+    this.initialize();
+    this.makeObservable();
+    this.makeReactive();
+    this.onInit();
+    (0, import_internals.initializeEnd)();
+  }
+  initialize() {
+    this.mounted = false;
+    this.unmounted = false;
+    this.initialized = false;
+    this.title = this.props.title;
+    this.description = this.props.description;
+    this.pattern = this.props.pattern;
+    this.display = this.props.display;
+    this.hidden = this.props.hidden;
+    this.editable = this.props.editable;
+    this.disabled = this.props.disabled;
+    this.readOnly = this.props.readOnly;
+    this.readPretty = this.props.readPretty;
+    this.visible = this.props.visible;
+    this.content = this.props.content;
+    this.data = this.props.data;
+    this.decorator = (0, import_shared.toArr)(this.props.decorator);
+    this.component = (0, import_shared.toArr)(this.props.component);
+  }
+  makeObservable() {
+    if (this.designable) return;
+    (0, import_reactive.define)(this, {
+      path: import_reactive.observable.ref,
+      title: import_reactive.observable.ref,
+      description: import_reactive.observable.ref,
+      selfDisplay: import_reactive.observable.ref,
+      selfPattern: import_reactive.observable.ref,
+      initialized: import_reactive.observable.ref,
+      mounted: import_reactive.observable.ref,
+      unmounted: import_reactive.observable.ref,
+      decoratorType: import_reactive.observable.ref,
+      componentType: import_reactive.observable.ref,
+      content: import_reactive.observable.ref,
+      data: import_reactive.observable.shallow,
+      decoratorProps: import_reactive.observable,
+      componentProps: import_reactive.observable,
+      display: import_reactive.observable.computed,
+      pattern: import_reactive.observable.computed,
+      hidden: import_reactive.observable.computed,
+      visible: import_reactive.observable.computed,
+      disabled: import_reactive.observable.computed,
+      readOnly: import_reactive.observable.computed,
+      readPretty: import_reactive.observable.computed,
+      editable: import_reactive.observable.computed,
+      component: import_reactive.observable.computed,
+      decorator: import_reactive.observable.computed,
+      indexes: import_reactive.observable.computed,
+      setTitle: import_reactive.action,
+      setDescription: import_reactive.action,
+      setDisplay: import_reactive.action,
+      setPattern: import_reactive.action,
+      setComponent: import_reactive.action,
+      setComponentProps: import_reactive.action,
+      setDecorator: import_reactive.action,
+      setDecoratorProps: import_reactive.action,
+      setData: import_reactive.action,
+      setContent: import_reactive.action,
+      onInit: import_reactive.batch,
+      onMount: import_reactive.batch,
+      onUnmount: import_reactive.batch
+    });
+  }
+  makeReactive() {
+    if (this.designable) return;
+    (0, import_internals.createReactions)(this);
+  }
+};
+__name(_VoidField, "VoidField");
+let VoidField = _VoidField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VoidField
+});

package/lib/core/models/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Heart';
+export * from './LifeCycle';
+export * from './Graph';
+export * from './Query';
+export * from './Form';
+export * from './Field';
+export * from './ArrayField';
+export * from './ObjectField';
+export * from './VoidField';

package/lib/core/models/index.js

@@ -0,0 +1,37 @@
+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("./Heart"), module.exports);
+__reExport(models_exports, require("./LifeCycle"), module.exports);
+__reExport(models_exports, require("./Graph"), module.exports);
+__reExport(models_exports, require("./Query"), module.exports);
+__reExport(models_exports, require("./Form"), module.exports);
+__reExport(models_exports, require("./Field"), module.exports);
+__reExport(models_exports, require("./ArrayField"), module.exports);
+__reExport(models_exports, require("./ObjectField"), module.exports);
+__reExport(models_exports, require("./VoidField"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Heart"),
+  ...require("./LifeCycle"),
+  ...require("./Graph"),
+  ...require("./Query"),
+  ...require("./Form"),
+  ...require("./Field"),
+  ...require("./ArrayField"),
+  ...require("./ObjectField"),
+  ...require("./VoidField")
+});

package/lib/core/models/types.d.ts

@@ -0,0 +1,9 @@
+export type { Form } from './Form';
+export type { Field } from './Field';
+export type { Query } from './Query';
+export type { Heart } from './Heart';
+export type { Graph } from './Graph';
+export type { LifeCycle } from './LifeCycle';
+export type { ArrayField } from './ArrayField';
+export type { ObjectField } from './ObjectField';
+export type { VoidField } from './VoidField';

package/lib/core/models/types.js

@@ -0,0 +1,15 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/core/shared/checkers.d.ts

@@ -0,0 +1,117 @@
+import { DataField, JSXComponent } from '..';
+import { ArrayField, Field, Form, ObjectField, Query, VoidField } from '../models';
+import { GeneralField, IFieldState, IFormState, IGeneralFieldState, IVoidFieldState } from '../types';
+export declare const isForm: (node: any) => node is Form;
+export declare const isGeneralField: (node: any) => node is GeneralField;
+export declare const isField: <Decorator extends unknown = any, Component extends unknown = any, TextType = any, ValueType = any>(node: any) => node is Field<Decorator, Component, TextType, ValueType>;
+export declare const isArrayField: <Decorator extends unknown = any, Component extends unknown = any>(node: any) => node is ArrayField<Decorator, Component>;
+export declare const isObjectField: <Decorator extends unknown = any, Component extends unknown = any>(node: any) => node is ObjectField<Decorator, Component>;
+export declare const isVoidField: <Decorator = any, Component = any, TextType = any>(node: any) => node is VoidField<Decorator, Component, TextType>;
+export declare const isFormState: <T extends Record<any, any> = any>(state: any) => state is IFormState<T>;
+export declare const isFieldState: (state: any) => state is IFieldState;
+export declare const isGeneralFieldState: (node: any) => node is IGeneralFieldState;
+export declare const isArrayFieldState: (state: any) => state is IFieldState;
+export declare const isDataField: (node: any) => node is DataField;
+export declare const isDataFieldState: (node: any) => node is Partial<Pick<Field<any, any, any, any>, import("..").NonFunctionPropertyNames<{
+    value: ValueType;
+    match: (pattern: import("../../path").Pattern) => boolean;
+    readonly index: number;
+    onInput: (...args: any[]) => Promise<void>;
+    onFocus: (...args: any[]) => Promise<void>;
+    onBlur: (...args: any[]) => Promise<void>;
+    validator: import("..").FieldValidator;
+    required: boolean;
+    pattern: import("..").FieldPatternTypes;
+    readonly invalid: boolean;
+    editable: boolean;
+    readOnly: boolean;
+    disabled: boolean;
+    readPretty: boolean;
+    hidden: boolean;
+    visible: boolean;
+    loading: boolean;
+    validating: boolean;
+    submitting: boolean;
+    active: boolean;
+    visited: boolean;
+    selfModified: boolean;
+    modified: boolean;
+    inputValue: string;
+    inputValues: any[];
+    dataSource: import("..").FieldDataSource;
+    feedbacks: import("..").IFieldFeedback[];
+    caches: import("..").IFieldCaches;
+    selfErrors: import("..").FeedbackMessage;
+    readonly errors: import("..").IFormFeedback[];
+    selfWarnings: import("..").FeedbackMessage;
+    readonly warnings: import("..").IFormFeedback[];
+    selfSuccesses: import("..").FeedbackMessage;
+    readonly successes: import("..").IFormFeedback[];
+    readonly selfValid: boolean;
+    readonly valid: boolean;
+    readonly selfInvalid: boolean;
+    initialValue: ValueType;
+    readonly validateStatus: "error" | "warning" | "success" | "validating";
+    setDataSource: (dataSource?: import("..").FieldDataSource) => void;
+    setFeedback: (feedback?: import("..").IFieldFeedback) => void;
+    setSelfErrors: (messages?: import("..").FeedbackMessage) => void;
+    setSelfWarnings: (messages?: import("..").FeedbackMessage) => void;
+    setSelfSuccesses: (messages?: import("..").FeedbackMessage) => void;
+    setValidator: (validator?: import("..").FieldValidator) => void;
+    setValidatorRule: (name: string, value: any) => void;
+    setRequired: (required?: boolean) => void;
+    setValue: (value?: string) => void;
+    setInitialValue: (initialValue?: string) => void;
+    setLoading: (loading?: boolean) => void;
+    setValidating: (validating?: boolean) => void;
+    setSubmitting: (submitting?: boolean) => void;
+    validate: (triggerType?: import("../..").ValidatorTriggerType) => Promise<void>;
+    submit: <T>(onSubmit?: (values: any) => void | Promise<T>) => Promise<T>;
+    reset: (options?: import("..").IFieldResetOptions) => Promise<void>;
+    queryFeedbacks: (search?: import("..").ISearchFeedback) => import("..").IFieldFeedback[];
+    modify: () => void;
+    title: string;
+    description: string;
+    initialized: boolean;
+    mounted: boolean;
+    unmounted: boolean;
+    content: any;
+    data: any;
+    decoratorType: any;
+    decoratorProps: Record<string, any>;
+    componentType: any;
+    componentProps: Record<string, any>;
+    designable: boolean;
+    form: Form;
+    actions: import("..").IFieldActions;
+    locate: (address: import("../../path").Pattern) => void;
+    readonly records: any[];
+    readonly record: any;
+    component: import("..").FieldComponent<Component>;
+    decorator: import("..").FieldDecorator<Decorator>;
+    readonly parent: GeneralField;
+    display: import("..").FieldDisplayTypes;
+    readonly destroyed: boolean;
+    setTitle: (title?: string) => void;
+    setDescription: (description?: string) => void;
+    setDisplay: (type?: import("..").FieldDisplayTypes) => void;
+    setPattern: (type?: import("..").FieldPatternTypes) => void;
+    setComponent: <C extends unknown, ComponentProps extends object = {}>(component?: C, props?: ComponentProps) => void;
+    setComponentProps: <ComponentProps extends object = {}>(props?: ComponentProps) => void;
+    setDecorator: <D extends unknown, ComponentProps extends object = {}>(component?: D, props?: ComponentProps) => void;
+    setDecoratorProps: <ComponentProps extends object = {}>(props?: ComponentProps) => void;
+    setData: (data: any) => void;
+    setContent: (content: any) => void;
+    onInit: () => void;
+    onMount: () => void;
+    onUnmount: () => void;
+    query: (pattern: import("../../path").Pattern | RegExp) => Query;
+    notify: (type: import("..").LifeCycleTypes, payload?: any) => void;
+    dispose: () => void;
+    destroy: (forceClear?: boolean) => void;
+    inject: (actions: import("..").IFieldActions) => void;
+    invoke: (name: string, ...args: any[]) => any;
+}>>>;
+export declare const isObjectFieldState: (state: any) => state is IFieldState;
+export declare const isVoidFieldState: (state: any) => state is IVoidFieldState;
+export declare const isQuery: (query: any) => query is Query;