@tachybase/database 0.23.8

package/lib/fields/field.js

@@ -0,0 +1,156 @@
+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 field_exports = {};
+__export(field_exports, {
+  Field: () => Field
+});
+module.exports = __toCommonJS(field_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("../utils");
+const _Field = class _Field {
+  options;
+  context;
+  database;
+  collection;
+  constructor(options, context) {
+    this.context = context;
+    this.database = this.context.database;
+    this.collection = this.context.collection;
+    this.options = options || {};
+    this.init();
+  }
+  get name() {
+    return this.options.name;
+  }
+  get type() {
+    return this.options.type;
+  }
+  async sync(syncOptions) {
+    await this.collection.sync({
+      ...syncOptions,
+      force: false,
+      alter: {
+        drop: false
+      }
+    });
+  }
+  init() {
+  }
+  on(eventName, listener) {
+    this.database.on(`${this.collection.name}.${eventName}`, listener);
+    return this;
+  }
+  off(eventName, listener) {
+    this.database.off(`${this.collection.name}.${eventName}`, listener);
+    return this;
+  }
+  get(name) {
+    return this.options[name];
+  }
+  remove() {
+    this.collection.removeIndex([this.name]);
+    return this.collection.removeField(this.name);
+  }
+  columnName() {
+    if (this.options.field) {
+      return this.options.field;
+    }
+    if (this.database.options.underscored) {
+      return (0, import_utils.snakeCase)(this.name);
+    }
+    return this.name;
+  }
+  async existsInDb(options) {
+    const opts = {
+      transaction: options == null ? void 0 : options.transaction
+    };
+    let sql;
+    if (this.database.sequelize.getDialect() === "sqlite") {
+      sql = `SELECT *
+             from pragma_table_info('${this.collection.model.tableName}')
+             WHERE name = '${this.columnName()}'`;
+    } else if (this.database.inDialect("mysql", "mariadb")) {
+      sql = `
+        select column_name
+        from INFORMATION_SCHEMA.COLUMNS
+        where TABLE_SCHEMA = '${this.database.options.database}'
+          AND TABLE_NAME = '${this.collection.model.tableName}'
+          AND column_name = '${this.columnName()}'
+      `;
+    } else {
+      sql = `
+        select column_name
+        from INFORMATION_SCHEMA.COLUMNS
+        where TABLE_NAME = '${this.collection.model.tableName}'
+          AND column_name = '${this.columnName()}'
+          AND table_schema = '${this.collection.collectionSchema() || "public"}'
+      `;
+    }
+    const [rows] = await this.database.sequelize.query(sql, opts);
+    return rows.length > 0;
+  }
+  merge(obj) {
+    Object.assign(this.options, obj);
+  }
+  bind() {
+    const { model } = this.context.collection;
+    model.rawAttributes[this.name] = this.toSequelize();
+    model.refreshAttributes();
+    if (this.options.index) {
+      this.context.collection.addIndex([this.name]);
+    }
+  }
+  unbind() {
+    const { model } = this.context.collection;
+    delete model.prototype[this.name];
+    model.removeAttribute(this.name);
+    if (this.options.index || this.options.unique) {
+      this.context.collection.removeIndex([this.name]);
+    }
+  }
+  toSequelize() {
+    const opts = import_lodash.default.omit(this.options, ["name"]);
+    if (this.dataType) {
+      Object.assign(opts, { type: this.database.sequelize.normalizeDataType(this.dataType) });
+    }
+    return opts;
+  }
+  isSqlite() {
+    return this.database.sequelize.getDialect() === "sqlite";
+  }
+  typeToString() {
+    return this.dataType.toString();
+  }
+};
+__name(_Field, "Field");
+let Field = _Field;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field
+});

package/lib/fields/has-inverse-field.d.ts

@@ -0,0 +1,4 @@
+import { Field } from './field';
+export interface HasInverseField {
+    inverseField: () => Field;
+}

package/lib/fields/has-inverse-field.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 has_inverse_field_exports = {};
+module.exports = __toCommonJS(has_inverse_field_exports);

package/lib/fields/has-many-field.d.ts

@@ -0,0 +1,68 @@
+import { AssociationScope, DataType, ForeignKeyOptions, HasManyOptions, HasManyOptions as SequelizeHasManyOptions } from 'sequelize';
+import { Reference } from '../features/references-map';
+import { MultipleRelationFieldOptions, RelationField } from './relation-field';
+export interface HasManyFieldOptions extends HasManyOptions {
+    /**
+     * The name of the field to use as the key for the association in the source table. Defaults to the primary
+     * key of the source table
+     */
+    sourceKey?: string;
+    /**
+     * A string or a data type to represent the identifier in the table
+     */
+    keyType?: DataType;
+    scope?: AssociationScope;
+    /**
+     * The alias of this model, in singular form. See also the `name` option passed to `sequelize.define`. If
+     * you create multiple associations between the same tables, you should provide an alias to be able to
+     * distinguish between them. If you provide an alias when creating the assocition, you should provide the
+     * same alias when eager loading and when getting associated models. Defaults to the singularized name of
+     * target
+     */
+    as?: string | {
+        singular: string;
+        plural: string;
+    };
+    /**
+     * The name of the foreign key in the target table or an object representing the type definition for the
+     * foreign column (see `Sequelize.define` for syntax). When using an object, you can add a `name` property
+     * to set the name of the column. Defaults to the name of source + primary key of source
+     */
+    foreignKey?: string | ForeignKeyOptions;
+    /**
+     * What happens when delete occurs.
+     *
+     * Cascade if this is a n:m, and set null if it is a 1:m
+     *
+     * @default 'SET NULL' or 'CASCADE'
+     */
+    onDelete?: string;
+    /**
+     * What happens when update occurs
+     *
+     * @default 'CASCADE'
+     */
+    onUpdate?: string;
+    /**
+     * Should on update and on delete constraints be enabled on the foreign key.
+     */
+    constraints?: boolean;
+    foreignKeyConstraint?: boolean;
+    /**
+     * If `false` the applicable hooks will not be called.
+     * The default value depends on the context.
+     */
+    hooks?: boolean;
+}
+export declare class HasManyField extends RelationField {
+    get dataType(): any;
+    get foreignKey(): any;
+    reference(association: any): Reference;
+    checkAssociationKeys(): void;
+    bind(): boolean;
+    unbind(): void;
+}
+export interface HasManyFieldOptions extends MultipleRelationFieldOptions, SequelizeHasManyOptions {
+    type: 'hasMany';
+    target?: string;
+}

package/lib/fields/has-many-field.js

@@ -0,0 +1,156 @@
+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 has_many_field_exports = {};
+__export(has_many_field_exports, {
+  HasManyField: () => HasManyField
+});
+module.exports = __toCommonJS(has_many_field_exports);
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var import_references_map = require("../features/references-map");
+var import_utils = require("../utils");
+var import_relation_field = require("./relation-field");
+const _HasManyField = class _HasManyField extends import_relation_field.RelationField {
+  get dataType() {
+    return "HasMany";
+  }
+  get foreignKey() {
+    if (this.options.foreignKey) {
+      return this.options.foreignKey;
+    }
+    const { model } = this.context.collection;
+    return import_sequelize.Utils.camelize([model.options.name.singular, this.sourceKey || model.primaryKeyAttribute].join("_"));
+  }
+  reference(association) {
+    const sourceKey = association.sourceKey;
+    return (0, import_references_map.buildReference)({
+      sourceCollectionName: this.database.modelCollection.get(association.target).name,
+      sourceField: association.foreignKey,
+      targetField: sourceKey,
+      targetCollectionName: this.database.modelCollection.get(association.source).name,
+      onDelete: this.options.onDelete
+    });
+  }
+  checkAssociationKeys() {
+    let { foreignKey, sourceKey } = this.options;
+    if (!sourceKey) {
+      sourceKey = this.collection.model.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.name), this.collection.model.primaryKeyAttribute].join("_"));
+    }
+    const foreignKeyAttribute = this.TargetModel.rawAttributes[foreignKey];
+    const sourceKeyAttribute = this.collection.model.rawAttributes[sourceKey];
+    if (!foreignKeyAttribute || !sourceKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const sourceKeyType = sourceKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, sourceKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match source key "${sourceKey}" type "${sourceKeyType}" in has many relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+  }
+  bind() {
+    const { database, collection } = this.context;
+    const Target = this.TargetModel;
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+    this.checkAssociationKeys();
+    if (collection.model.associations[this.name]) {
+      delete collection.model.associations[this.name];
+    }
+    const association = collection.model.hasMany(Target, {
+      constraints: false,
+      ...(0, import_lodash.omit)(this.options, ["name", "type", "target", "onDelete"]),
+      as: this.name,
+      foreignKey: this.foreignKey
+    });
+    database.removePendingField(this);
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
+    try {
+      (0, import_utils.checkIdentifier)(this.options.foreignKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
+    let tcoll;
+    if (this.target === collection.name) {
+      tcoll = collection;
+    } else {
+      tcoll = database.getCollection(this.target);
+    }
+    if (tcoll) {
+      tcoll.addIndex([this.options.foreignKey]);
+    }
+    this.database.referenceMap.addReference(this.reference(association));
+    if (this.options.sortable) {
+      const targetCollection = database.modelCollection.get(this.TargetModel);
+      const sortFieldName = `${this.options.foreignKey}Sort`;
+      targetCollection.setField(sortFieldName, {
+        type: "sort",
+        hidden: true,
+        scopeKey: this.options.foreignKey
+      });
+      this.options.sortBy = sortFieldName;
+    }
+    return true;
+  }
+  unbind() {
+    const { database, collection } = this.context;
+    database.removePendingField(this);
+    const tcoll = database.getCollection(this.target);
+    if (tcoll) {
+      const foreignKey = this.options.foreignKey;
+      const field = tcoll.findField((field2) => {
+        if (field2.name === foreignKey) {
+          return true;
+        }
+        return field2.type === "belongsTo" && field2.foreignKey === foreignKey;
+      });
+      if (!field) {
+        tcoll.model.removeAttribute(foreignKey);
+      }
+    }
+    const association = collection.model.associations[this.name];
+    if (association && !this.options.inherit) {
+      this.database.referenceMap.removeReference(this.reference(association));
+    }
+    this.clearAccessors();
+    delete collection.model.associations[this.name];
+    collection.model.refreshAttributes();
+  }
+};
+__name(_HasManyField, "HasManyField");
+let HasManyField = _HasManyField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HasManyField
+});

package/lib/fields/has-one-field.d.ts

@@ -0,0 +1,68 @@
+import { AssociationScope, DataType, ForeignKeyOptions, HasOneOptions, HasOneOptions as SequelizeHasOneOptions } from 'sequelize';
+import { Reference } from '../features/references-map';
+import { BaseRelationFieldOptions, RelationField } from './relation-field';
+export interface HasOneFieldOptions extends HasOneOptions {
+    /**
+     * The name of the field to use as the key for the association in the source table. Defaults to the primary
+     * key of the source table
+     */
+    sourceKey?: string;
+    /**
+     * A string or a data type to represent the identifier in the table
+     */
+    keyType?: DataType;
+    scope?: AssociationScope;
+    /**
+     * The alias of this model, in singular form. See also the `name` option passed to `sequelize.define`. If
+     * you create multiple associations between the same tables, you should provide an alias to be able to
+     * distinguish between them. If you provide an alias when creating the assocition, you should provide the
+     * same alias when eager loading and when getting associated models. Defaults to the singularized name of
+     * target
+     */
+    as?: string | {
+        singular: string;
+        plural: string;
+    };
+    /**
+     * The name of the foreign key in the target table or an object representing the type definition for the
+     * foreign column (see `Sequelize.define` for syntax). When using an object, you can add a `name` property
+     * to set the name of the column. Defaults to the name of source + primary key of source
+     */
+    foreignKey?: string | ForeignKeyOptions;
+    /**
+     * What happens when delete occurs.
+     *
+     * Cascade if this is a n:m, and set null if it is a 1:m
+     *
+     * @default 'SET NULL' or 'CASCADE'
+     */
+    onDelete?: string;
+    /**
+     * What happens when update occurs
+     *
+     * @default 'CASCADE'
+     */
+    onUpdate?: string;
+    /**
+     * Should on update and on delete constraints be enabled on the foreign key.
+     */
+    constraints?: boolean;
+    foreignKeyConstraint?: boolean;
+    /**
+     * If `false` the applicable hooks will not be called.
+     * The default value depends on the context.
+     */
+    hooks?: boolean;
+}
+export declare class HasOneField extends RelationField {
+    get dataType(): any;
+    get target(): any;
+    get foreignKey(): any;
+    reference(association: any): Reference;
+    checkAssociationKeys(): void;
+    bind(): boolean;
+    unbind(): void;
+}
+export interface HasOneFieldOptions extends BaseRelationFieldOptions, SequelizeHasOneOptions {
+    type: 'hasOne';
+}

package/lib/fields/has-one-field.js

@@ -0,0 +1,150 @@
+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 has_one_field_exports = {};
+__export(has_one_field_exports, {
+  HasOneField: () => HasOneField
+});
+module.exports = __toCommonJS(has_one_field_exports);
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var import_references_map = require("../features/references-map");
+var import_utils = require("../utils");
+var import_relation_field = require("./relation-field");
+const _HasOneField = class _HasOneField extends import_relation_field.RelationField {
+  get dataType() {
+    return "HasOne";
+  }
+  get target() {
+    const { target, name } = this.options;
+    return target || import_sequelize.Utils.pluralize(name);
+  }
+  get foreignKey() {
+    const foreignKey = (() => {
+      if (this.options.foreignKey) {
+        return this.options.foreignKey;
+      }
+      const { model } = this.context.collection;
+      return import_sequelize.Utils.camelize([model.options.name.singular, model.primaryKeyAttribute].join("_"));
+    })();
+    return foreignKey;
+  }
+  reference(association) {
+    const sourceKey = association.sourceKey;
+    return (0, import_references_map.buildReference)({
+      sourceCollectionName: this.database.modelCollection.get(association.target).name,
+      sourceField: association.foreignKey,
+      targetField: sourceKey,
+      targetCollectionName: this.database.modelCollection.get(association.source).name,
+      onDelete: this.options.onDelete
+    });
+  }
+  checkAssociationKeys() {
+    let { foreignKey, sourceKey } = this.options;
+    if (!sourceKey) {
+      sourceKey = this.collection.model.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.name), this.collection.model.primaryKeyAttribute].join("_"));
+    }
+    const foreignKeyAttribute = this.TargetModel.rawAttributes[foreignKey];
+    const sourceKeyAttribute = this.collection.model.rawAttributes[sourceKey];
+    if (!foreignKeyAttribute || !sourceKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const sourceKeyType = sourceKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, sourceKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match source key "${sourceKey}" type "${sourceKeyType}" in has one relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+  }
+  bind() {
+    const { database, collection } = this.context;
+    const Target = this.TargetModel;
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+    this.checkAssociationKeys();
+    const association = collection.model.hasOne(Target, {
+      constraints: false,
+      ...(0, import_lodash.omit)(this.options, ["name", "type", "target", "onDelete"]),
+      as: this.name,
+      foreignKey: this.foreignKey
+    });
+    database.removePendingField(this);
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
+    try {
+      (0, import_utils.checkIdentifier)(this.options.foreignKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
+    let tcoll;
+    if (this.target === collection.name) {
+      tcoll = collection;
+    } else {
+      tcoll = database.getCollection(this.target);
+    }
+    if (tcoll) {
+      tcoll.addIndex([this.options.foreignKey]);
+    }
+    this.database.referenceMap.addReference(this.reference(association));
+    return true;
+  }
+  unbind() {
+    const { database, collection } = this.context;
+    database.removePendingField(this);
+    const tcoll = database.collections.get(this.target);
+    if (tcoll && !this.options.inherit) {
+      const foreignKey = this.options.foreignKey;
+      const field = tcoll.findField((field2) => {
+        if (field2.name === foreignKey) {
+          return true;
+        }
+        return field2.type === "belongsTo" && field2.foreignKey === foreignKey;
+      });
+      if (!field) {
+        tcoll.model.removeAttribute(foreignKey);
+      }
+    }
+    const association = collection.model.associations[this.name];
+    if (association && !this.options.inherit) {
+      this.database.referenceMap.removeReference(this.reference(association));
+    }
+    this.clearAccessors();
+    delete collection.model.associations[this.name];
+    collection.model.refreshAttributes();
+  }
+};
+__name(_HasOneField, "HasOneField");
+let HasOneField = _HasOneField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HasOneField
+});

package/lib/fields/index.d.ts

@@ -0,0 +1,46 @@
+import { ArrayFieldOptions } from './array-field';
+import { BelongsToFieldOptions } from './belongs-to-field';
+import { BelongsToManyFieldOptions } from './belongs-to-many-field';
+import { BooleanFieldOptions } from './boolean-field';
+import { ContextFieldOptions } from './context-field';
+import { DateFieldOptions } from './date-field';
+import { BaseFieldOptions } from './field';
+import { HasManyFieldOptions } from './has-many-field';
+import { HasOneFieldOptions } from './has-one-field';
+import { JsonbFieldOptions, JsonFieldOptions } from './json-field';
+import { NanoidFieldOptions } from './nanoid-field';
+import { DecimalFieldOptions, DoubleFieldOptions, FloatFieldOptions, IntegerFieldOptions, RealFieldOptions } from './number-field';
+import { PasswordFieldOptions } from './password-field';
+import { RadioFieldOptions } from './radio-field';
+import { SetFieldOptions } from './set-field';
+import { SortFieldOptions } from './sort-field';
+import { StringFieldOptions } from './string-field';
+import { TextFieldOptions } from './text-field';
+import { TimeFieldOptions } from './time-field';
+import { UidFieldOptions } from './uid-field';
+import { UUIDFieldOptions } from './uuid-field';
+import { VirtualFieldOptions } from './virtual-field';
+export * from './array-field';
+export * from './belongs-to-field';
+export * from './belongs-to-many-field';
+export * from './boolean-field';
+export * from './context-field';
+export * from './date-field';
+export * from './field';
+export * from './has-many-field';
+export * from './has-one-field';
+export * from './json-field';
+export * from './number-field';
+export * from './password-field';
+export * from './radio-field';
+export * from './relation-field';
+export * from './set-field';
+export * from './sort-field';
+export * from './string-field';
+export * from './text-field';
+export * from './time-field';
+export * from './uid-field';
+export * from './uuid-field';
+export * from './virtual-field';
+export * from './nanoid-field';
+export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | SortFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | UidFieldOptions | UUIDFieldOptions | NanoidFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions;