@tachybase/database 0.23.8

package/lib/fields/belongs-to-field.js

@@ -0,0 +1,154 @@
+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 __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 __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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var belongs_to_field_exports = {};
+__export(belongs_to_field_exports, {
+  BelongsToField: () => BelongsToField
+});
+module.exports = __toCommonJS(belongs_to_field_exports);
+var import_lodash = __toESM(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 _BelongsToField = class _BelongsToField extends import_relation_field.RelationField {
+  get dataType() {
+    return "BelongsTo";
+  }
+  get target() {
+    const { target, name } = this.options;
+    return target || import_sequelize.Utils.pluralize(name);
+  }
+  static toReference(db, association, onDelete, priority = "default") {
+    const targetKey = association.targetKey;
+    return (0, import_references_map.buildReference)({
+      sourceCollectionName: db.modelCollection.get(association.source).name,
+      sourceField: association.foreignKey,
+      targetField: targetKey,
+      targetCollectionName: db.modelCollection.get(association.target).name,
+      onDelete,
+      priority
+    });
+  }
+  reference(association) {
+    return _BelongsToField.toReference(
+      this.database,
+      association,
+      this.options.onDelete,
+      this.options.onDelete ? "user" : "default"
+    );
+  }
+  checkAssociationKeys() {
+    let { foreignKey, targetKey } = this.options;
+    if (!targetKey) {
+      targetKey = this.TargetModel.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_lodash.default.camelCase(`${this.name}_${targetKey}`);
+    }
+    const targetKeyAttribute = this.TargetModel.rawAttributes[targetKey];
+    const foreignKeyAttribute = this.collection.model.rawAttributes[foreignKey];
+    if (!foreignKeyAttribute || !targetKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const targetKeyType = targetKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, targetKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match target key "${targetKey}" type "${targetKeyType}" in belongs to 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.belongsTo(Target, {
+      as: this.name,
+      constraints: false,
+      ...(0, import_lodash.omit)(this.options, ["name", "type", "target", "onDelete"])
+    });
+    database.removePendingField(this);
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+    if (!this.options.targetKey) {
+      this.options.targetKey = association.targetKey;
+    }
+    try {
+      (0, import_utils.checkIdentifier)(this.options.foreignKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
+    this.collection.addIndex([this.options.foreignKey]);
+    const reference = this.reference(association);
+    this.database.referenceMap.addReference(reference);
+    return true;
+  }
+  unbind() {
+    const { database, collection } = this.context;
+    database.removePendingField(this);
+    const tcoll = database.collections.get(this.target);
+    const foreignKey = this.options.foreignKey;
+    const field1 = collection.getField(foreignKey);
+    const field2 = tcoll ? tcoll.findField((field) => {
+      return field.type === "hasMany" && field.foreignKey === foreignKey;
+    }) : null;
+    if (!field1 && !field2) {
+      collection.model.removeAttribute(foreignKey);
+    }
+    const association = collection.model.associations[this.name];
+    if (association && !this.options.inherit) {
+      const reference = this.reference(association);
+      this.database.referenceMap.removeReference(reference);
+    }
+    this.clearAccessors();
+    delete collection.model.associations[this.name];
+    collection.model.refreshAttributes();
+  }
+};
+__name(_BelongsToField, "BelongsToField");
+__publicField(_BelongsToField, "type", "belongsTo");
+let BelongsToField = _BelongsToField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BelongsToField
+});

package/lib/fields/belongs-to-many-field.d.ts

@@ -0,0 +1,20 @@
+import { AssociationScope, BelongsToManyOptions as SequelizeBelongsToManyOptions } from 'sequelize';
+import { Reference } from '../features/references-map';
+import { MultipleRelationFieldOptions, RelationField } from './relation-field';
+export declare class BelongsToManyField extends RelationField {
+    get dataType(): string;
+    get through(): any;
+    get otherKey(): any;
+    references(association: any): Reference[];
+    checkAssociationKeys(database: any): void;
+    bind(): boolean;
+    unbind(): void;
+}
+export interface BelongsToManyFieldOptions extends MultipleRelationFieldOptions, Omit<SequelizeBelongsToManyOptions, 'through'> {
+    type: 'belongsToMany';
+    target?: string;
+    through?: string;
+    throughScope?: AssociationScope;
+    throughUnique?: boolean;
+    throughParanoid?: boolean;
+}

package/lib/fields/belongs-to-many-field.js

@@ -0,0 +1,187 @@
+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 belongs_to_many_field_exports = {};
+__export(belongs_to_many_field_exports, {
+  BelongsToManyField: () => BelongsToManyField
+});
+module.exports = __toCommonJS(belongs_to_many_field_exports);
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var import_utils = require("../utils");
+var import_belongs_to_field = require("./belongs-to-field");
+var import_relation_field = require("./relation-field");
+const _BelongsToManyField = class _BelongsToManyField extends import_relation_field.RelationField {
+  get dataType() {
+    return "BelongsToMany";
+  }
+  get through() {
+    return this.options.through || import_sequelize.Utils.camelize(
+      [this.context.collection.model.name, this.target].map((name) => name.toLowerCase()).sort().join("_")
+    );
+  }
+  get otherKey() {
+    return this.options.otherKey;
+  }
+  references(association) {
+    const db = this.context.database;
+    const onDelete = this.options.onDelete || "CASCADE";
+    const priority = this.options.onDelete ? "user" : "default";
+    const targetAssociation = association.toTarget;
+    if (association.targetKey) {
+      targetAssociation.targetKey = association.targetKey;
+    }
+    const sourceAssociation = association.toSource;
+    if (association.sourceKey) {
+      sourceAssociation.targetKey = association.sourceKey;
+    }
+    return [
+      import_belongs_to_field.BelongsToField.toReference(db, targetAssociation, onDelete, priority),
+      import_belongs_to_field.BelongsToField.toReference(db, sourceAssociation, onDelete, priority)
+    ];
+  }
+  checkAssociationKeys(database) {
+    let { foreignKey, sourceKey, otherKey, targetKey } = this.options;
+    const through = this.through;
+    const throughCollection = database.getCollection(through);
+    if (!throughCollection) {
+      return;
+    }
+    if (!sourceKey) {
+      sourceKey = this.collection.model.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.collection.model.name), sourceKey].join("_"));
+    }
+    if (!targetKey) {
+      targetKey = this.TargetModel.primaryKeyAttribute;
+    }
+    if (!otherKey) {
+      otherKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.TargetModel.name), targetKey].join("_"));
+    }
+    const foreignKeyAttribute = throughCollection.model.rawAttributes[foreignKey];
+    const otherKeyAttribute = throughCollection.model.rawAttributes[otherKey];
+    const sourceKeyAttribute = this.collection.model.rawAttributes[sourceKey];
+    const targetKeyAttribute = this.TargetModel.rawAttributes[targetKey];
+    if (!foreignKeyAttribute || !otherKeyAttribute || !sourceKeyAttribute || !targetKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const otherKeyType = otherKeyAttribute.type.constructor.toString();
+    const sourceKeyType = sourceKeyAttribute.type.constructor.toString();
+    const targetKeyType = targetKeyAttribute.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 belongs to many relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+    if (!this.keyPairsTypeMatched(otherKeyType, targetKeyType)) {
+      throw new Error(
+        `Other key "${otherKey}" type "${otherKeyType}" does not match target key "${targetKey}" type "${targetKeyType}" in belongs to 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;
+    }
+    if (!this.collection.model.primaryKeyAttribute) {
+      throw new Error(`Collection model ${this.collection.model.name} has no primary key attribute`);
+    }
+    if (!Target.primaryKeyAttribute) {
+      throw new Error(`Target model ${Target.name} has no primary key attribute`);
+    }
+    this.checkAssociationKeys(database);
+    const through = this.through;
+    let Through;
+    if (database.hasCollection(through)) {
+      Through = database.getCollection(through);
+    } else {
+      const throughCollectionOptions = {
+        name: through
+      };
+      if (this.collection.options.dumpRules) {
+        throughCollectionOptions["dumpRules"] = this.collection.options.dumpRules;
+      }
+      if (this.collection.collectionSchema()) {
+        throughCollectionOptions["schema"] = this.collection.collectionSchema();
+      }
+      Through = database.collection(throughCollectionOptions);
+      Object.defineProperty(Through.model, "isThrough", { value: true });
+    }
+    const belongsToManyOptions = {
+      constraints: false,
+      ...(0, import_lodash.omit)(this.options, ["name", "type", "target"]),
+      as: this.name,
+      through: {
+        model: Through.model,
+        scope: this.options.throughScope,
+        paranoid: this.options.throughParanoid,
+        unique: this.options.throughUnique
+      }
+    };
+    const association = collection.model.belongsToMany(Target, belongsToManyOptions);
+    database.removePendingField(this);
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
+    if (!this.options.otherKey) {
+      this.options.otherKey = association.otherKey;
+    }
+    if (!this.options.targetKey) {
+      this.options.targetKey = association.targetKey;
+    }
+    try {
+      (0, import_utils.checkIdentifier)(this.options.foreignKey);
+      (0, import_utils.checkIdentifier)(this.options.otherKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+    if (!this.options.through) {
+      this.options.through = this.through;
+    }
+    Through.addIndex([this.options.foreignKey]);
+    Through.addIndex([this.options.otherKey]);
+    this.references(association).forEach((reference) => this.database.referenceMap.addReference(reference));
+    return true;
+  }
+  unbind() {
+    const { database, collection } = this.context;
+    const Through = database.getCollection(this.through);
+    database.removePendingField(this);
+    const association = collection.model.associations[this.name];
+    if (association && !this.options.inherit) {
+      this.references(association).forEach((reference) => this.database.referenceMap.removeReference(reference));
+    }
+    this.clearAccessors();
+    delete collection.model.associations[this.name];
+  }
+};
+__name(_BelongsToManyField, "BelongsToManyField");
+let BelongsToManyField = _BelongsToManyField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BelongsToManyField
+});

package/lib/fields/boolean-field.d.ts

@@ -0,0 +1,8 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class BooleanField extends Field {
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+}
+export interface BooleanFieldOptions extends BaseColumnFieldOptions {
+    type: 'boolean';
+}

package/lib/fields/boolean-field.js

@@ -0,0 +1,36 @@
+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 boolean_field_exports = {};
+__export(boolean_field_exports, {
+  BooleanField: () => BooleanField
+});
+module.exports = __toCommonJS(boolean_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _BooleanField = class _BooleanField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.BOOLEAN;
+  }
+};
+__name(_BooleanField, "BooleanField");
+let BooleanField = _BooleanField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanField
+});

package/lib/fields/context-field.d.ts

@@ -0,0 +1,14 @@
+import { Model } from '../model';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class ContextField extends Field {
+    get dataType(): any;
+    listener: (model: Model, options: any) => Promise<void>;
+    bind(): void;
+    unbind(): void;
+}
+export interface ContextFieldOptions extends BaseColumnFieldOptions {
+    type: 'context';
+    dataIndex: string;
+    dataType?: string;
+    createOnly?: boolean;
+}

package/lib/fields/context-field.js

@@ -0,0 +1,70 @@
+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 context_field_exports = {};
+__export(context_field_exports, {
+  ContextField: () => ContextField
+});
+module.exports = __toCommonJS(context_field_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _ContextField = class _ContextField extends import_field.Field {
+  get dataType() {
+    const type = this.options.dataType || "string";
+    return import_sequelize.DataTypes[type.toUpperCase()] || import_sequelize.DataTypes.STRING;
+  }
+  listener = /* @__PURE__ */ __name(async (model, options) => {
+    const { name, dataIndex } = this.options;
+    const { context } = options;
+    model.set(name, import_lodash.default.get(context, dataIndex));
+    model.changed(name, true);
+  }, "listener");
+  bind() {
+    super.bind();
+    const { createOnly } = this.options;
+    this.on("beforeCreate", this.listener);
+    if (!createOnly) {
+      this.on("beforeUpdate", this.listener);
+    }
+  }
+  unbind() {
+    super.unbind();
+    const { createOnly } = this.options;
+    this.off("beforeCreate", this.listener);
+    if (!createOnly) {
+      this.off("beforeUpdate", this.listener);
+    }
+  }
+};
+__name(_ContextField, "ContextField");
+let ContextField = _ContextField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextField
+});

package/lib/fields/date-field.d.ts

@@ -0,0 +1,13 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class DateField extends Field {
+    get dataType(): DataTypes.DateDataType;
+    get timezone(): string;
+    getProps(): any;
+    isDateOnly(): boolean;
+    isGMT(): any;
+    bind(): void;
+}
+export interface DateFieldOptions extends BaseColumnFieldOptions {
+    type: 'date';
+}

package/lib/fields/date-field.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 date_field_exports = {};
+__export(date_field_exports, {
+  DateField: () => DateField
+});
+module.exports = __toCommonJS(date_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _DateField = class _DateField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.DATE(3);
+  }
+  get timezone() {
+    return this.isGMT() ? "+00:00" : null;
+  }
+  getProps() {
+    var _a, _b;
+    return ((_b = (_a = this.options) == null ? void 0 : _a.uiSchema) == null ? void 0 : _b["x-component-props"]) || {};
+  }
+  isDateOnly() {
+    const props = this.getProps();
+    return !props.showTime;
+  }
+  isGMT() {
+    const props = this.getProps();
+    return props.gmt;
+  }
+  bind() {
+    super.bind();
+    if (this.options.interface === "createdAt") {
+      const { model } = this.context.collection;
+      model._timestampAttributes.createdAt = this.name;
+      model.refreshAttributes();
+    }
+    if (this.options.interface === "updatedAt") {
+      const { model } = this.context.collection;
+      model._timestampAttributes.updatedAt = this.name;
+      model.refreshAttributes();
+    }
+  }
+};
+__name(_DateField, "DateField");
+let DateField = _DateField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DateField
+});

package/lib/fields/field.d.ts

@@ -0,0 +1,43 @@
+import { DataType, ModelAttributeColumnOptions, ModelIndexesOptions, SyncOptions, Transactionable } from 'sequelize';
+import { Collection } from '../collection';
+import { Database } from '../database';
+import { ModelEventTypes } from '../types';
+export interface FieldContext {
+    database: Database;
+    collection: Collection;
+}
+export interface BaseFieldOptions {
+    name?: string;
+    hidden?: boolean;
+    translation?: boolean;
+    [key: string]: any;
+}
+export interface BaseColumnFieldOptions extends BaseFieldOptions, Omit<ModelAttributeColumnOptions, 'type'> {
+    dataType?: DataType;
+    index?: boolean | ModelIndexesOptions;
+}
+export declare abstract class Field {
+    options: any;
+    context: FieldContext;
+    database: Database;
+    collection: Collection;
+    [key: string]: any;
+    constructor(options?: any, context?: FieldContext);
+    get name(): any;
+    get type(): any;
+    abstract get dataType(): any;
+    sync(syncOptions: SyncOptions): Promise<void>;
+    init(): void;
+    on(eventName: ModelEventTypes, listener: (...args: any[]) => void): this;
+    off(eventName: string, listener: (...args: any[]) => void): this;
+    get(name: string): any;
+    remove(): void | Field;
+    columnName(): any;
+    existsInDb(options?: Transactionable): Promise<boolean>;
+    merge(obj: any): void;
+    bind(): void;
+    unbind(): void;
+    toSequelize(): any;
+    isSqlite(): boolean;
+    typeToString(): any;
+}