lakutata/decorator/orm.d.ts

An IoC-based universal application framework.

import '../vendor/TypeDef.2.js';
import { C as ColumnOptions, l as SimpleColumnType, m as ColumnCommonOptions, n as SpatialColumnType, o as SpatialColumnOptions, W as WithLengthColumnType, p as WithWidthColumnType, q as WithPrecisionColumnType, P as PrimaryGeneratedColumnType, r as ColumnType, V as ValueTransformer, J as JoinColumnOptions, s as JoinTableOptions, t as JoinTableMultipleColumnsOptions, u as ObjectType, v as RelationOptions, S as SelectQueryBuilder, a as DataSource, w as OnDeleteType, x as TreeType, y as ClosureTreeOptions, z as DeferrableType } from '../vendor/TypeDef.4.js';
import { E as EntityOptions, I as IndexOptions } from '../vendor/TypeDef.13.js';
import 'fs';
import 'tls';
import 'net';
import 'dns';
import 'events';
import 'stream';

/**
 * Options for columns that can define a length of the column type.
 */
interface ColumnWithLengthOptions {
    /**
     * Column type's length.
     * For example type = "varchar" and length = "100" means ORM will create a column with type varchar(100).
     */
    length?: string | number;
}

/**
 * Options for numeric column types where user can specify scale and precision.
 */
interface ColumnNumericOptions {
    /**
     * The precision for a decimal (exact numeric) column (applies only for decimal column), which is the maximum
     * number of digits that are stored for the values.
     */
    precision?: number;
    /**
     * The scale for a decimal (exact numeric) column (applies only for decimal column), which represents the number
     * of digits to the right of the decimal point and must not be greater than precision.
     */
    scale?: number;
    /**
     * Puts ZEROFILL attribute on to numeric column. Works only for MySQL.
     * If you specify ZEROFILL for a numeric column, MySQL automatically adds the UNSIGNED attribute to the column
     */
    zerofill?: boolean;
    /**
     * Puts UNSIGNED attribute on to numeric column. Works only for MySQL.
     */
    unsigned?: boolean;
}

/**
 * Column options for enum-typed columns.
 */
interface ColumnEnumOptions {
    /**
     * Array of possible enumerated values.
     */
    enum?: any[] | Object;
    /**
     * Exact name of enum
     */
    enumName?: string;
}

/**
 * Column options specific to embedded column.
 */
interface ColumnEmbeddedOptions {
    /**
     * Embedded column prefix.
     * If set to empty string or false, then prefix is not set at all.
     */
    prefix?: string | boolean;
    /**
     * Indicates if this embedded is in array mode.
     *
     * This option works only in mongodb.
     */
    array?: boolean;
}

/**
 * Column options for enum-typed columns.
 */
interface ColumnHstoreOptions {
    /**
     * Return type of HSTORE column.
     * Returns value as string or as object.
     */
    hstoreType?: string;
}

/**
 * Options for columns that can define a length of the column type.
 */
interface ColumnWithWidthOptions {
    /**
     * Column type's display width. Used only on some column types in MySQL.
     * For example, INT(4) specifies an INT with a display width of four digits.
     */
    width?: number;
    /**
     * Puts ZEROFILL attribute on to numeric column. Works only for MySQL.
     * If you specify ZEROFILL for a numeric column, MySQL automatically adds the UNSIGNED attribute to this column
     */
    zerofill?: boolean;
    /**
     * Puts UNSIGNED attribute on to numeric column. Works only for MySQL.
     */
    unsigned?: boolean;
}

/**
 * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this
 * decorator will be persisted to the database when entity be saved.
 */
declare function Column(): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(options: ColumnOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: SimpleColumnType, options?: ColumnCommonOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: SpatialColumnType, options?: ColumnCommonOptions & SpatialColumnOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: WithLengthColumnType, options?: ColumnCommonOptions & ColumnWithLengthOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: WithWidthColumnType, options?: ColumnCommonOptions & ColumnWithWidthOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: WithPrecisionColumnType, options?: ColumnCommonOptions & ColumnNumericOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: "enum", options?: ColumnCommonOptions & ColumnEnumOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: "simple-enum", options?: ColumnCommonOptions & ColumnEnumOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: "set", options?: ColumnCommonOptions & ColumnEnumOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 */
declare function Column(type: "hstore", options?: ColumnCommonOptions & ColumnHstoreOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 *
 * Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the
 * single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the
 * embedded will be mapped to it from the single table.
 */
declare function Column(type: (type?: any) => Function, options?: ColumnEmbeddedOptions): PropertyDecorator;

/**
 * This column will store a creation date of the inserted object.
 * Creation date is generated and inserted only once,
 * at the first time when you create an object, the value is inserted into the table, and is never touched again.
 */
declare function CreateDateColumn(options?: ColumnOptions): PropertyDecorator;

/**
 * This column will store a delete date of the soft-deleted object.
 * This date is being updated each time you soft-delete the object.
 */
declare function DeleteDateColumn(options?: ColumnOptions): PropertyDecorator;

/**
 * Describes all options for PrimaryGeneratedColumn decorator with numeric generation strategy.
 */
interface PrimaryGeneratedColumnNumericOptions {
    /**
     * Column type. Must be one of the value from the ColumnTypes class.
     */
    type?: PrimaryGeneratedColumnType;
    /**
     * Column name in the database.
     */
    name?: string;
    /**
     * Column comment. Not supported by all database types.
     */
    comment?: string;
    /**
     * Puts ZEROFILL attribute on to numeric column. Works only for MySQL.
     * If you specify ZEROFILL for a numeric column, MySQL automatically adds the UNSIGNED attribute to the column
     */
    zerofill?: boolean;
    /**
     * Puts UNSIGNED attribute on to numeric column. Works only for MySQL.
     */
    unsigned?: boolean;
    /**
     * Name of the primary key constraint.
     */
    primaryKeyConstraintName?: string;
}

/**
 * Describes all options for PrimaryGeneratedColumn decorator with numeric uuid strategy.
 */
interface PrimaryGeneratedColumnUUIDOptions {
    /**
     * Column name in the database.
     */
    name?: string;
    /**
     * Column comment. Not supported by all database types.
     */
    comment?: string;
    /**
     * Name of the primary key constraint.
     */
    primaryKeyConstraintName?: string;
}

/**
 * Describes all options for PrimaryGeneratedColumn decorator with identity generation strategy.
 */
interface PrimaryGeneratedColumnIdentityOptions {
    /**
     * Column type. Must be one of the value from the ColumnTypes class.
     */
    type?: PrimaryGeneratedColumnType;
    /**
     * Column name in the database.
     */
    name?: string;
    /**
     * Column comment. Not supported by all database types.
     */
    comment?: string;
    /**
     * Identity column type. Supports only in Postgres 10+.
     */
    generatedIdentity?: "ALWAYS" | "BY DEFAULT";
    /**
     * Name of the primary key constraint.
     */
    primaryKeyConstraintName?: string;
}

/**
 * Column decorator is used to mark a specific class property as a table column.
 */
declare function PrimaryGeneratedColumn(): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 */
declare function PrimaryGeneratedColumn(options: PrimaryGeneratedColumnNumericOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 */
declare function PrimaryGeneratedColumn(strategy: "increment", options?: PrimaryGeneratedColumnNumericOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 */
declare function PrimaryGeneratedColumn(strategy: "uuid", options?: PrimaryGeneratedColumnUUIDOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 */
declare function PrimaryGeneratedColumn(strategy: "rowid", options?: PrimaryGeneratedColumnUUIDOptions): PropertyDecorator;
declare function PrimaryGeneratedColumn(strategy: "identity", options?: PrimaryGeneratedColumnIdentityOptions): PropertyDecorator;

/**
 * Describes all primary key column's options.
 * If specified, the nullable field must be set to false.
 */
type PrimaryColumnOptions = ColumnOptions & {
    nullable?: false;
};
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 * Primary columns also creates a PRIMARY KEY for this column in a db.
 */
declare function PrimaryColumn(options?: PrimaryColumnOptions): PropertyDecorator;
/**
 * Column decorator is used to mark a specific class property as a table column.
 * Only properties decorated with this decorator will be persisted to the database when entity be saved.
 * Primary columns also creates a PRIMARY KEY for this column in a db.
 */
declare function PrimaryColumn(type?: ColumnType, options?: PrimaryColumnOptions): PropertyDecorator;

/**
 * This column will store an update date of the updated object.
 * This date is being updated each time you persist the object.
 */
declare function UpdateDateColumn(options?: ColumnOptions): PropertyDecorator;

/**
 * This column will store a number - version of the entity.
 * Every time your entity will be persisted, this number will be increased by one -
 * so you can organize visioning and update strategies of your entity.
 */
declare function VersionColumn(options?: ColumnOptions): PropertyDecorator;

/**
 * Describes all calculated column's options.
 */
interface VirtualColumnOptions {
    /**
     * Column type. Must be one of the value from the ColumnTypes class.
     */
    type?: ColumnType;
    /**
     * Return type of HSTORE column.
     * Returns value as string or as object.
     */
    hstoreType?: "object" | "string";
    /**
     * Query to be used to populate the column data. This query is used when generating the relational db script.
     * The query function is called with the current entities alias either defined by the Entity Decorator or automatically
     * @See https://typeorm.io/decorator-reference#virtualcolumn for more details.
     */
    query: (alias: string) => string;
    /**
     * Specifies a value transformer(s) that is to be used to unmarshal
     * this column when reading from the database.
     */
    transformer?: ValueTransformer | ValueTransformer[];
}

/**
 * VirtualColumn decorator is used to mark a specific class property as a Virtual column.
 */
declare function VirtualColumn(options: VirtualColumnOptions): PropertyDecorator;
/**
 * VirtualColumn decorator is used to mark a specific class property as a Virtual column.
 */
declare function VirtualColumn(typeOrOptions: ColumnType, options: VirtualColumnOptions): PropertyDecorator;

/**
 * Describes all view column's options.
 */
interface ViewColumnOptions {
    /**
     * Column name in the database.
     */
    name?: string;
    /**
     * Specifies a value transformer(s) that is to be used to unmarshal
     * this column when reading from the database.
     */
    transformer?: ValueTransformer | ValueTransformer[];
}

/**
 * ViewColumn decorator is used to mark a specific class property as a view column.
 */
declare function ViewColumn(options?: ViewColumnOptions): PropertyDecorator;

/**
 * Special type of column that is available only for MongoDB database.
 * Marks your entity's column to be an object id.
 */
declare function ObjectIdColumn(options?: ColumnOptions): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied after this entity insertion.
 */
declare function AfterInsert(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied after entity is loaded.
 */
declare function AfterLoad(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied after this entity removal.
 */
declare function AfterRemove(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity soft removal.
 */
declare function AfterSoftRemove(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity soft removal.
 */
declare function AfterRecover(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied after this entity update.
 */
declare function AfterUpdate(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity insertion.
 */
declare function BeforeInsert(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity removal.
 */
declare function BeforeRemove(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity soft removal.
 */
declare function BeforeSoftRemove(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity soft removal.
 */
declare function BeforeRecover(): PropertyDecorator;

/**
 * Calls a method on which this decorator is applied before this entity update.
 */
declare function BeforeUpdate(): PropertyDecorator;

/**
 * Classes decorated with this decorator will listen to ORM events and their methods will be triggered when event
 * occurs. Those classes must implement EventSubscriberInterface interface.
 */
declare function EventSubscriber(): ClassDecorator;

/**
 * JoinColumn decorator used on one-to-one relations to specify owner side of relationship.
 * It also can be used on both one-to-one and many-to-one relations to specify custom column name
 * or custom referenced column.
 */
declare function JoinColumn(): PropertyDecorator;
/**
 * JoinColumn decorator used on one-to-one relations to specify owner side of relationship.
 * It also can be used on both one-to-one and many-to-one relations to specify custom column name
 * or custom referenced column.
 */
declare function JoinColumn(options: JoinColumnOptions): PropertyDecorator;
/**
 * JoinColumn decorator used on one-to-one relations to specify owner side of relationship.
 * It also can be used on both one-to-one and many-to-one relations to specify custom column name
 * or custom referenced column.
 */
declare function JoinColumn(options: JoinColumnOptions[]): PropertyDecorator;

/**
 * JoinTable decorator is used in many-to-many relationship to specify owner side of relationship.
 * Its also used to set a custom junction table's name, column names and referenced columns.
 */
declare function JoinTable(): PropertyDecorator;
/**
 * JoinTable decorator is used in many-to-many relationship to specify owner side of relationship.
 * Its also used to set a custom junction table's name, column names and referenced columns.
 */
declare function JoinTable(options: JoinTableOptions): PropertyDecorator;
/**
 * JoinTable decorator is used in many-to-many relationship to specify owner side of relationship.
 * Its also used to set a custom junction table's name, column names and referenced columns.
 */
declare function JoinTable(options: JoinTableMultipleColumnsOptions): PropertyDecorator;

/**
 * Many-to-many is a type of relationship when Entity1 can have multiple instances of Entity2, and Entity2 can have
 * multiple instances of Entity1. To achieve it, this type of relation creates a junction table, where it storage
 * entity1 and entity2 ids. This is owner side of the relationship.
 */
declare function ManyToMany<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), options?: RelationOptions): PropertyDecorator;
/**
 * Many-to-many is a type of relationship when Entity1 can have multiple instances of Entity2, and Entity2 can have
 * multiple instances of Entity1. To achieve it, this type of relation creates a junction table, where it storage
 * entity1 and entity2 ids. This is owner side of the relationship.
 */
declare function ManyToMany<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide?: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

/**
 * A many-to-one relation allows creating the type of relation where Entity1 can have a single instance of Entity2, but
 * Entity2 can have multiple instances of Entity1. Entity1 is the owner of the relationship, and stores the id of
 * Entity2 on its side of the relation.
 */
declare function ManyToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), options?: RelationOptions): PropertyDecorator;
/**
 * A many-to-one relation allows creating the type of relation where Entity1 can have a single instance of Entity2, but
 * Entity2 can have multiple instances of Entity1. Entity1 is the owner of the relationship, and stores the id of
 * Entity2 on its side of the relation.
 */
declare function ManyToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide?: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

/**
 * A one-to-many relation allows creating the type of relation where Entity1 can have multiple instances of Entity2,
 * but Entity2 has only one Entity1. Entity2 is the owner of the relationship, and stores the id of Entity1 on its
 * side of the relation.
 */
declare function OneToMany<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

/**
 * One-to-one relation allows the creation of a direct relation between two entities. Entity1 has only one Entity2.
 * Entity1 is the owner of the relationship, and stores Entity2 id on its own side.
 */
declare function OneToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), options?: RelationOptions): PropertyDecorator;
/**
 * One-to-one relation allows the creation of a direct relation between two entities. Entity1 has only one Entity2.
 * Entity1 is the owner of the relationship, and stores Entity2 id on its own side.
 */
declare function OneToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide?: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

/**
 * Special decorator used to extract relation id into separate entity property.
 *
 * @experimental
 */
declare function RelationId<T>(relation: string | ((object: T) => any), alias?: string, queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>): PropertyDecorator;

/**
 * This decorator is used to mark classes that will be an entity (table or document depend on database type).
 * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
 */
declare function Entity(options?: EntityOptions): ClassDecorator;
/**
 * This decorator is used to mark classes that will be an entity (table or document depend on database type).
 * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
 */
declare function Entity(name?: string, options?: EntityOptions): ClassDecorator;

/**
 * Special type of the table used in the single-table inherited tables.
 */
declare function ChildEntity(discriminatorValue?: any): ClassDecorator;

/**
 * Sets for entity to use table inheritance pattern.
 */
declare function TableInheritance(options?: {
    pattern?: "STI";
    column?: string | ColumnOptions;
}): ClassDecorator;

/**
 * Describes all entity view's options.
 */

interface ViewEntityOptions {
    /**
     * View name.
     * If not specified then naming strategy will generate view name from class name.
     */
    name?: string;
    /**
     * View expression.
     */
    expression?: string | ((connection: DataSource) => SelectQueryBuilder<any>);
    /**
     * Database name. Used in Mysql and Sql Server.
     */
    database?: string;
    /**
     * Schema name. Used in Postgres and Sql Server.
     */
    schema?: string;
    /**
     * Indicates if schema synchronization is enabled or disabled for this entity.
     * If it will be set to false then schema sync will and migrations ignore this entity.
     * By default schema synchronization is enabled for all entities.
     */
    synchronize?: boolean;
    /**
     * Indicates if view should be materialized view.
     * It's supported by Postgres and Oracle.
     */
    materialized?: boolean;
    /**
     * View dependencies. In case the view depends on another view it can be listed here
     * to ensure correct order of view migrations.
     */
    dependsOn?: (Function | string)[];
}

/**
 * This decorator is used to mark classes that will be an entity view.
 * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
 */
declare function ViewEntity(options?: ViewEntityOptions): ClassDecorator;
/**
 * This decorator is used to mark classes that will be an entity view.
 * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
 */
declare function ViewEntity(name?: string, options?: ViewEntityOptions): ClassDecorator;

/**
 * Creates a "level"/"length" column to the table that holds a closure table.
 */
declare function TreeLevelColumn(): PropertyDecorator;

/**
 * Marks a entity property as a parent of the tree.
 * "Tree parent" indicates who owns (is a parent) of this entity in tree structure.
 */
declare function TreeParent(options?: {
    onDelete?: OnDeleteType;
}): PropertyDecorator;

/**
 * Marks a entity property as a children of the tree.
 * "Tree children" will contain all children (bind) of this entity.
 */
declare function TreeChildren(options?: {
    cascade?: boolean | ("insert" | "update" | "remove" | "soft-remove" | "recover")[];
}): PropertyDecorator;

/**
 * Marks entity to work like a tree.
 * Tree pattern that will be used for the tree entity should be specified.
 * @TreeParent decorator must be used in tree entities.
 * TreeRepository can be used to manipulate with tree entities.
 */
declare function Tree(type: TreeType, options?: ClosureTreeOptions): ClassDecorator;

/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(options?: IndexOptions): ClassDecorator & PropertyDecorator;
/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(name: string, options?: IndexOptions): ClassDecorator & PropertyDecorator;
/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(name: string, options: {
    synchronize: false;
}): ClassDecorator & PropertyDecorator;
/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(name: string, fields: string[], options?: IndexOptions): ClassDecorator & PropertyDecorator;
/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(fields: string[], options?: IndexOptions): ClassDecorator & PropertyDecorator;
/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(fields: (object?: any) => any[] | {
    [key: string]: number;
}, options?: IndexOptions): ClassDecorator & PropertyDecorator;
/**
 * Creates a database index.
 * Can be used on entity property or on entity.
 * Can create indices with composite columns when used on entity.
 */
declare function Index(name: string, fields: (object?: any) => any[] | {
    [key: string]: number;
}, options?: IndexOptions): ClassDecorator & PropertyDecorator;

/**
 * Describes all unique options.
 */
interface UniqueOptions {
    /**
     * Indicate if unique constraints can be deferred.
     */
    deferrable?: DeferrableType;
}

/**
 * Composite unique constraint must be set on entity classes and must specify entity's fields to be unique.
 */
declare function Unique(name: string, fields: string[], options?: UniqueOptions): ClassDecorator & PropertyDecorator;
/**
 * Composite unique constraint must be set on entity classes and must specify entity's fields to be unique.
 */
declare function Unique(fields: string[], options?: UniqueOptions): ClassDecorator & PropertyDecorator;
/**
 * Composite unique constraint must be set on entity classes and must specify entity's fields to be unique.
 */
declare function Unique(fields: (object?: any) => any[] | {
    [key: string]: number;
}, options?: UniqueOptions): ClassDecorator & PropertyDecorator;
/**
 * Composite unique constraint must be set on entity classes and must specify entity's fields to be unique.
 */
declare function Unique(name: string, fields: (object?: any) => any[] | {
    [key: string]: number;
}, options?: UniqueOptions): ClassDecorator & PropertyDecorator;

/**
 * Creates a database check.
 * Can be used on entity property or on entity.
 * Can create checks with composite columns when used on entity.
 */
declare function Check(expression: string): ClassDecorator & PropertyDecorator;
/**
 * Creates a database check.
 * Can be used on entity property or on entity.
 * Can create checks with composite columns when used on entity.
 */
declare function Check(name: string, expression: string): ClassDecorator & PropertyDecorator;

/**
 * Creates a database exclusion.
 * Can be used on entity.
 * Can create exclusions with composite columns when used on entity.
 */
declare function Exclusion(expression: string): ClassDecorator & PropertyDecorator;
/**
 * Creates a database exclusion.
 * Can be used on entity.
 * Can create exclusions with composite columns when used on entity.
 */
declare function Exclusion(name: string, expression: string): ClassDecorator & PropertyDecorator;

/**
 * Marks a column to generate a value on entity insertion.
 * There are three types of generation strategy - increment, uuid and rowid (cockroachdb only).
 * Increment uses a number which increases by one on each insertion.
 * Uuid generates a special UUID token.
 * Rowid supports only in CockroachDB and uses `unique_rowid()` function
 *
 * Note, some databases do not support non-primary generation columns.
 */
declare function Generated(strategy?: "increment" | "uuid" | "rowid"): PropertyDecorator;

export { AfterInsert, AfterLoad, AfterRecover, AfterRemove, AfterSoftRemove, AfterUpdate, BeforeInsert, BeforeRecover, BeforeRemove, BeforeSoftRemove, BeforeUpdate, Check, ChildEntity, Column, CreateDateColumn, DeleteDateColumn, Entity, EventSubscriber, Exclusion, Generated, Index, JoinColumn, JoinTable, ManyToMany, ManyToOne, ObjectIdColumn, OneToMany, OneToOne, PrimaryColumn, PrimaryGeneratedColumn, RelationId, TableInheritance, Tree, TreeChildren, TreeLevelColumn, TreeParent, Unique, UpdateDateColumn, VersionColumn, ViewColumn, ViewEntity, VirtualColumn };