taon-typeorm 21.0.2 → 21.0.4

package/websql/lib/typeorm/connection/ConnectionManager.d.ts

@@ -1,34 +0,0 @@
-// @ts-nocheck
-import { DataSource } from "../data-source/DataSource";
-import { DataSourceOptions } from "../data-source/DataSourceOptions";
-/**
- * ConnectionManager is used to store and manage multiple orm connections.
- * It also provides useful factory methods to simplify connection creation.
- *
- * @deprecated
- */
-export declare class ConnectionManager {
-    /**
-     * List of connections registered in this connection manager.
-     */
-    get connections(): DataSource[];
-    /**
-     * Internal lookup to quickly get from a connection name to the Connection object.
-     */
-    private readonly connectionMap;
-    /**
-     * Checks if connection with the given name exist in the manager.
-     */
-    has(name: string): boolean;
-    /**
-     * Gets registered connection with the given name.
-     * If connection name is not given then it will get a default connection.
-     * Throws error if connection with the given name was not found.
-     */
-    get(name?: string): DataSource;
-    /**
-     * Creates a new connection based on the given connection options and registers it in the manager.
-     * Connection won't be established, you'll need to manually call connect method to establish connection.
-     */
-    create(options: DataSourceOptions): DataSource;
-}

package/websql/lib/typeorm/connection/ConnectionMetadataBuilder.d.ts

@@ -1,25 +0,0 @@
-// @ts-nocheck
-import { MigrationInterface } from "../migration/MigrationInterface";
-import { DataSource } from "../data-source/DataSource";
-import { EntitySchema } from "../entity-schema/EntitySchema";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { EntitySubscriberInterface } from "../subscriber/EntitySubscriberInterface";
-/**
- * Builds migration instances, subscriber instances and entity metadatas for the given classes.
- */
-export declare class ConnectionMetadataBuilder {
-    protected connection: DataSource;
-    constructor(connection: DataSource);
-    /**
-     * Builds migration instances for the given classes or directories.
-     */
-    buildMigrations(migrations: (Function | string)[]): Promise<MigrationInterface[]>;
-    /**
-     * Builds subscriber instances for the given classes or directories.
-     */
-    buildSubscribers(subscribers: (Function | string)[]): Promise<EntitySubscriberInterface<any>[]>;
-    /**
-     * Builds entity metadatas for the given classes or directories.
-     */
-    buildEntityMetadatas(entities: (Function | EntitySchema<any> | string)[]): Promise<EntityMetadata[]>;
-}

package/websql/lib/typeorm/connection/ConnectionOptions.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-import { DataSourceOptions } from "../data-source/DataSourceOptions";
-/**
- * ConnectionOptions is an interface with settings and options for specific connection.
- * Options contain database and other connection-related settings.
- * Consumer must provide connection options for each of your connections.
- *
- * @deprecated use DataSourceOptions instead
- */
-export type ConnectionOptions = DataSourceOptions;

package/websql/lib/typeorm/connection/ConnectionOptionsReader.d.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-import { DataSourceOptions } from "../data-source/DataSourceOptions";
-/**
- * Reads connection options from the ormconfig.
- * Can read from multiple file extensions including env, json, js, xml and yml.
- */
-export declare class ConnectionOptionsReader {
-    protected options?: {
-        /**
-         * Directory where ormconfig should be read from.
-         * By default its your application root (where your app package.json is located).
-         */
-        root?: string;
-        /**
-         * Filename of the ormconfig configuration. By default its equal to "ormconfig".
-         */
-        configName?: string;
-    };
-    constructor(options?: {
-        /**
-         * Directory where ormconfig should be read from.
-         * By default its your application root (where your app package.json is located).
-         */
-        root?: string;
-        /**
-         * Filename of the ormconfig configuration. By default its equal to "ormconfig".
-         */
-        configName?: string;
-    });
-    /**
-     * Returns all connection options read from the ormconfig.
-     */
-    all(): Promise<DataSourceOptions[]>;
-    /**
-     * Gets a connection with a given name read from ormconfig.
-     * If connection with such name would not be found then it throw error.
-     */
-    get(name: string): Promise<DataSourceOptions>;
-    /**
-     * Checks if there is a TypeORM configuration file.
-     */
-    has(name: string): Promise<boolean>;
-    /**
-     * Loads all connection options from a configuration file.
-     *
-     * todo: get in count NODE_ENV somehow
-     */
-    protected load(): Promise<DataSourceOptions[] | undefined>;
-    /**
-     * Normalize connection options.
-     */
-    protected normalizeConnectionOptions(connectionOptions: DataSourceOptions | DataSourceOptions[]): DataSourceOptions[];
-    /**
-     * Gets directory where configuration file should be located and configuration file name.
-     */
-    protected get baseFilePath(): string;
-    /**
-     * Gets directory where configuration file should be located.
-     */
-    protected get baseDirectory(): string;
-    /**
-     * Gets configuration file name.
-     */
-    protected get baseConfigName(): string;
-}

package/websql/lib/typeorm/constants.d.ts

@@ -1,2 +0,0 @@
-// @ts-nocheck
-export declare const OrignalClassKey = "$$originalClass$$";

package/websql/lib/typeorm/container.d.ts

@@ -1,40 +0,0 @@
-// @ts-nocheck
-/**
- * Container options.
- *
- * @deprecated
- */
-export interface UseContainerOptions {
-    /**
-     * If set to true, then default container will be used in the case if given container haven't returned anything.
-     */
-    fallback?: boolean;
-    /**
-     * If set to true, then default container will be used in the case if given container thrown an exception.
-     */
-    fallbackOnErrors?: boolean;
-}
-/**
- * @deprecated
- */
-export type ContainedType<T> = {
-    new (...args: any[]): T;
-} | Function;
-/**
- * @deprecated
- */
-export interface ContainerInterface {
-    get<T>(someClass: ContainedType<T>): T;
-}
-/**
- * Sets container to be used by this library.
- *
- * @deprecated
- */
-export declare function useContainer(iocContainer: ContainerInterface, options?: UseContainerOptions): void;
-/**
- * Gets the IOC container used by this library.
- *
- * @deprecated
- */
-export declare function getFromContainer<T>(someClass: ContainedType<T>): T;

package/websql/lib/typeorm/data-source/BaseDataSourceOptions.d.ts

@@ -1,172 +0,0 @@
-// @ts-nocheck
-import { EntitySchema } from "../entity-schema/EntitySchema";
-import { LoggerOptions } from "../logger/LoggerOptions";
-import { NamingStrategyInterface } from "../naming-strategy/NamingStrategyInterface";
-import { DatabaseType } from "../driver/types/DatabaseType";
-import { Logger } from "../logger/Logger";
-import { DataSource } from "../data-source/DataSource";
-import { QueryResultCache } from "../cache/QueryResultCache";
-import { MixedList } from "../common/MixedList";
-/**
- * BaseDataSourceOptions is set of DataSourceOptions shared by all database types.
- */
-export interface BaseDataSourceOptions {
-    /**
-     * Database type. This value is required.
-     */
-    readonly type: DatabaseType;
-    /**
-     * Connection name. If connection name is not given then it will be called "default".
-     * Different connections must have different names.
-     *
-     * @deprecated
-     */
-    readonly name?: string;
-    /**
-     * Entities to be loaded for this connection.
-     * Accepts both entity classes and directories where from entities need to be loaded.
-     * Directories support glob patterns.
-     */
-    readonly entities?: MixedList<Function | string | EntitySchema>;
-    /**
-     * Subscribers to be loaded for this connection.
-     * Accepts both subscriber classes and directories where from subscribers need to be loaded.
-     * Directories support glob patterns.
-     */
-    readonly subscribers?: MixedList<Function | string>;
-    /**
-     * Migrations to be loaded for this connection.
-     * Accepts both migration classes and glob patterns representing migration files.
-     */
-    readonly migrations?: MixedList<Function | string>;
-    /**
-     * Migrations table name, in case of different name from "migrations".
-     * Accepts single string name.
-     */
-    readonly migrationsTableName?: string;
-    /**
-     * Transaction mode for migrations to run in
-     */
-    readonly migrationsTransactionMode?: "all" | "none" | "each";
-    /**
-     * Typeorm metadata table name, in case of different name from "typeorm_metadata".
-     * Accepts single string name.
-     */
-    readonly metadataTableName?: string;
-    /**
-     * Naming strategy to be used to name tables and columns in the database.
-     */
-    readonly namingStrategy?: NamingStrategyInterface;
-    /**
-     * Logging options.
-     */
-    readonly logging?: LoggerOptions;
-    /**
-     * Logger instance used to log queries and events in the ORM.
-     */
-    readonly logger?: "advanced-console" | "simple-console" | "file" | "debug" | Logger;
-    /**
-     * Maximum number of milliseconds query should be executed before logger log a warning.
-     */
-    readonly maxQueryExecutionTime?: number;
-    /**
-     * Maximum number of clients the pool should contain.
-     */
-    readonly poolSize?: number;
-    /**
-     * Indicates if database schema should be auto created on every application launch.
-     * Be careful with this option and don't use this in production - otherwise you can lose production data.
-     * This option is useful during debug and development.
-     * Alternative to it, you can use CLI and run schema:sync command.
-     *
-     * Note that for MongoDB database it does not create schema, because MongoDB is schemaless.
-     * Instead, it syncs just by creating indices.
-     */
-    readonly synchronize?: boolean;
-    /**
-     * Indicates if migrations should be auto run on every application launch.
-     * Alternative to it, you can use CLI and run migrations:run command.
-     */
-    readonly migrationsRun?: boolean;
-    /**
-     * Drops the schema each time connection is being established.
-     * Be careful with this option and don't use this in production - otherwise you'll lose all production data.
-     * This option is useful during debug and development.
-     */
-    readonly dropSchema?: boolean;
-    /**
-     * Prefix to use on all tables (collections) of this connection in the database.
-     */
-    readonly entityPrefix?: string;
-    /**
-     * When creating new Entity instances, skip all constructors when true.
-     */
-    readonly entitySkipConstructor?: boolean;
-    /**
-     * Extra connection options to be passed to the underlying driver.
-     *
-     * todo: deprecate this and move all database-specific types into hts own connection options object.
-     */
-    readonly extra?: any;
-    /**
-     * Specifies how relations must be loaded - using "joins" or separate queries.
-     * If you are loading too much data with nested joins it's better to load relations
-     * using separate queries.
-     *
-     * Default strategy is "join", but this default can be changed here.
-     * Also, strategy can be set per-query in FindOptions and QueryBuilder.
-     */
-    readonly relationLoadStrategy?: "join" | "query";
-    /**
-     * Optionally applied "typename" to the model.
-     * If set, then each hydrated model will have this property with the target model / entity name inside.
-     *
-     * (works like a discriminator property).
-     */
-    readonly typename?: string;
-    /**
-     * Holds reference to the baseDirectory where configuration file are expected.
-     *
-     * @internal
-     */
-    baseDirectory?: string;
-    /**
-     * Allows to setup cache options.
-     */
-    readonly cache?: boolean | {
-        /**
-         * Type of caching.
-         *
-         * - "database" means cached values will be stored in the separate table in database. This is default value.
-         * - "redis" means cached values will be stored inside redis. You must provide redis connection options.
-         */
-        readonly type?: "database" | "redis" | "ioredis" | "ioredis/cluster";
-        /**
-         * Factory function for custom cache providers that implement QueryResultCache.
-         */
-        readonly provider?: (connection: DataSource) => QueryResultCache;
-        /**
-         * Configurable table name for "database" type cache.
-         * Default value is "query-result-cache"
-         */
-        readonly tableName?: string;
-        /**
-         * Used to provide redis connection options.
-         */
-        readonly options?: any;
-        /**
-         * If set to true then queries (using find methods and QueryBuilder's methods) will always be cached.
-         */
-        readonly alwaysEnabled?: boolean;
-        /**
-         * Time in milliseconds in which cache will expire.
-         * This can be setup per-query.
-         * Default value is 1000 which is equivalent to 1 second.
-         */
-        readonly duration?: number;
-        /**
-         * Used to specify if cache errors should be ignored, and pass through the call to the Database.
-         */
-        readonly ignoreErrors?: boolean;
-    };
-}

package/websql/lib/typeorm/data-source/DataSource.d.ts

@@ -1,247 +0,0 @@
-// @ts-nocheck
-import { Driver } from "../driver/Driver";
-import { Repository } from "../repository/Repository";
-import { EntitySubscriberInterface } from "../subscriber/EntitySubscriberInterface";
-import { EntityTarget } from "../common/EntityTarget";
-import { ObjectType } from "../common/ObjectType";
-import { EntityManager } from "../entity-manager/EntityManager";
-import { TreeRepository } from "../repository/TreeRepository";
-import { NamingStrategyInterface } from "../naming-strategy/NamingStrategyInterface";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { Logger } from "../logger/Logger";
-import { MigrationInterface } from "../migration/MigrationInterface";
-import { Migration } from "../migration/Migration";
-import { DataSourceOptions } from "./DataSourceOptions";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-import { UpdateQueryBuilder } from "../query-builder//UpdateQueryBuilder";
-import { DeleteQueryBuilder } from "../query-builder//DeleteQueryBuilder";
-import { SoftDeleteQueryBuilder } from "../query-builder/SoftDeleteQueryBuilder";
-import { InsertQueryBuilder } from "../query-builder/InsertQueryBuilder";
-import { RelationQueryBuilder } from "../query-builder/RelationQueryBuilder";
-import { QueryResultCache } from "../cache/QueryResultCache";
-import { SqljsEntityManager } from "../entity-manager/SqljsEntityManager";
-import { RelationLoader } from "../query-builder/RelationLoader";
-import { IsolationLevel } from "../driver/types/IsolationLevel";
-import { ReplicationMode } from "../driver/types/ReplicationMode";
-import { RelationIdLoader } from "../query-builder/RelationIdLoader";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-/**
- * DataSource is a pre-defined connection configuration to a specific database.
- * You can have multiple data sources connected (with multiple connections in it),
- * connected to multiple databases in your application.
- *
- * Before, it was called `Connection`, but now `Connection` is deprecated
- * because `Connection` isn't the best name for what it's actually is.
- */
-export declare class DataSource {
-    readonly "@instanceof": symbol;
-    SelectQueryBuilder: typeof SelectQueryBuilder;
-    UpdateQueryBuilder: typeof UpdateQueryBuilder;
-    DeleteQueryBuilder: typeof DeleteQueryBuilder;
-    SoftDeleteQueryBuilder: typeof SoftDeleteQueryBuilder;
-    InsertQueryBuilder: typeof InsertQueryBuilder;
-    RelationQueryBuilder: typeof RelationQueryBuilder;
-    /**
-     * Connection name.
-     *
-     * @deprecated we don't need names anymore since we are going to drop all related methods relying on this property.
-     */
-    readonly name: string;
-    /**
-     * Connection options.
-     */
-    readonly options: DataSourceOptions;
-    /**
-     * Indicates if DataSource is initialized or not.
-     */
-    readonly isInitialized: boolean;
-    /**
-     * Database driver used by this connection.
-     */
-    driver: Driver;
-    /**
-     * EntityManager of this connection.
-     */
-    readonly manager: EntityManager;
-    /**
-     * Naming strategy used in the connection.
-     */
-    namingStrategy: NamingStrategyInterface;
-    /**
-     * Name for the metadata table
-     */
-    readonly metadataTableName: string;
-    /**
-     * Logger used to log orm events.
-     */
-    logger: Logger;
-    /**
-     * Migration instances that are registered for this connection.
-     */
-    readonly migrations: MigrationInterface[];
-    /**
-     * Entity subscriber instances that are registered for this connection.
-     */
-    readonly subscribers: EntitySubscriberInterface<any>[];
-    /**
-     * All entity metadatas that are registered for this connection.
-     */
-    readonly entityMetadatas: EntityMetadata[];
-    /**
-     * Used to work with query result cache.
-     */
-    queryResultCache?: QueryResultCache;
-    /**
-     * Used to load relations and work with lazy relations.
-     */
-    readonly relationLoader: RelationLoader;
-    readonly relationIdLoader: RelationIdLoader;
-    constructor(options: DataSourceOptions);
-    /**
-     Indicates if DataSource is initialized or not.
-     *
-     * @deprecated use .isInitialized instead
-     */
-    get isConnected(): boolean;
-    /**
-     * Gets a sql.js specific Entity Manager that allows to perform special load and save operations
-     *
-     * Available only in connection with the sqljs driver.
-     */
-    get sqljsManager(): SqljsEntityManager;
-    /**
-     * Updates current connection options with provided options.
-     */
-    setOptions(options: Partial<DataSourceOptions>): this;
-    /**
-     * Performs connection to the database.
-     * This method should be called once on application bootstrap.
-     * This method not necessarily creates database connection (depend on database type),
-     * but it also can setup a connection pool with database to use.
-     */
-    initialize(): Promise<this>;
-    /**
-     * Performs connection to the database.
-     * This method should be called once on application bootstrap.
-     * This method not necessarily creates database connection (depend on database type),
-     * but it also can setup a connection pool with database to use.
-     *
-     * @deprecated use .initialize method instead
-     */
-    connect(): Promise<this>;
-    /**
-     * Closes connection with the database.
-     * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Closes connection with the database.
-     * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.
-     *
-     * @deprecated use .destroy method instead
-     */
-    close(): Promise<void>;
-    /**
-     * Creates database schema for all entities registered in this connection.
-     * Can be used only after connection to the database is established.
-     *
-     * @param dropBeforeSync If set to true then it drops the database with all its tables and data
-     */
-    synchronize(dropBeforeSync?: boolean): Promise<void>;
-    /**
-     * Drops the database and all its data.
-     * Be careful with this method on production since this method will erase all your database tables and their data.
-     * Can be used only after connection to the database is established.
-     */
-    dropDatabase(): Promise<void>;
-    /**
-     * Runs all pending migrations.
-     * Can be used only after connection to the database is established.
-     */
-    runMigrations(options?: {
-        transaction?: "all" | "none" | "each";
-        fake?: boolean;
-    }): Promise<Migration[]>;
-    /**
-     * Reverts last executed migration.
-     * Can be used only after connection to the database is established.
-     */
-    undoLastMigration(options?: {
-        transaction?: "all" | "none" | "each";
-        fake?: boolean;
-    }): Promise<void>;
-    /**
-     * Lists all migrations and whether they have been run.
-     * Returns true if there are pending migrations
-     */
-    showMigrations(): Promise<boolean>;
-    /**
-     * Checks if entity metadata exist for the given entity class, target name or table name.
-     */
-    hasMetadata(target: EntityTarget<any>): boolean;
-    /**
-     * Gets entity metadata for the given entity class or schema name.
-     */
-    getMetadata(target: EntityTarget<any>): EntityMetadata;
-    /**
-     * Gets repository for the given entity.
-     */
-    getRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): Repository<Entity>;
-    /**
-     * Gets tree repository for the given entity class or name.
-     * Only tree-type entities can have a TreeRepository, like ones decorated with @Tree decorator.
-     */
-    getTreeRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): TreeRepository<Entity>;
-    /**
-     * Gets custom entity repository marked with @EntityRepository decorator.
-     *
-     * @deprecated use Repository.extend function to create a custom repository
-     */
-    getCustomRepository<T>(customRepository: ObjectType<T>): T;
-    /**
-     * Wraps given function execution (and all operations made there) into a transaction.
-     * All database operations must be executed using provided entity manager.
-     */
-    transaction<T>(runInTransaction: (entityManager: EntityManager) => Promise<T>): Promise<T>;
-    transaction<T>(isolationLevel: IsolationLevel, runInTransaction: (entityManager: EntityManager) => Promise<T>): Promise<T>;
-    /**
-     * Executes raw SQL query and returns raw database results.
-     */
-    query(query: string, parameters?: any[], queryRunner?: QueryRunner): Promise<any>;
-    /**
-     * Creates a new query builder that can be used to build a SQL query.
-     */
-    createQueryBuilder<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, alias: string, queryRunner?: QueryRunner): SelectQueryBuilder<Entity>;
-    /**
-     * Creates a new query builder that can be used to build a SQL query.
-     */
-    createQueryBuilder(queryRunner?: QueryRunner): SelectQueryBuilder<any>;
-    /**
-     * Creates a query runner used for perform queries on a single database connection.
-     * Using query runners you can control your queries to execute using single database connection and
-     * manually control your database transaction.
-     *
-     * Mode is used in replication mode and indicates whatever you want to connect
-     * to master database or any of slave databases.
-     * If you perform writes you must use master database,
-     * if you perform reads you can use slave databases.
-     */
-    createQueryRunner(mode?: ReplicationMode): QueryRunner;
-    /**
-     * Gets entity metadata of the junction table (many-to-many table).
-     */
-    getManyToManyMetadata(entityTarget: EntityTarget<any>, relationPropertyPath: string): EntityMetadata;
-    /**
-     * Creates an Entity Manager for the current connection with the help of the EntityManagerFactory.
-     */
-    createEntityManager(queryRunner?: QueryRunner): EntityManager;
-    /**
-     * Finds exist entity metadata by the given entity class, target name or table name.
-     */
-    protected findMetadata(target: EntityTarget<any>): EntityMetadata | undefined;
-    /**
-     * Builds metadatas for all registered classes inside this connection.
-     */
-    protected buildMetadatas(): Promise<void>;
-}

package/websql/lib/typeorm/data-source/DataSourceOptions.d.ts

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { CordovaConnectionOptions } from "../driver/cordova/CordovaConnectionOptions";
-import { SqljsConnectionOptions } from "../driver/sqljs/SqljsConnectionOptions";
-import { ReactNativeConnectionOptions } from "../driver/react-native/ReactNativeConnectionOptions";
-import { NativescriptConnectionOptions } from "../driver/nativescript/NativescriptConnectionOptions";
-/**
- * DataSourceOptions is an interface with settings and options for specific DataSource.
- */
-export type DataSourceOptions = CordovaConnectionOptions | NativescriptConnectionOptions | ReactNativeConnectionOptions | SqljsConnectionOptions;

package/websql/lib/typeorm/data-source/index.d.ts

@@ -1,3 +0,0 @@
-// @ts-nocheck
-export * from "./DataSource";
-export * from "./DataSourceOptions";

package/websql/lib/typeorm/decorator/Check.d.ts

@@ -1,13 +0,0 @@
-// @ts-nocheck
-/**
- * Creates a database check.
- * Can be used on entity property or on entity.
- * Can create checks with composite columns when used on entity.
- */
-export 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.
- */
-export declare function Check(name: string, expression: string): ClassDecorator & PropertyDecorator;

package/websql/lib/typeorm/decorator/EntityRepository.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-import { EntitySchema } from "../entity-schema/EntitySchema";
-/**
- * Used to declare a class as a custom repository.
- * Custom repository can manage some specific entity or just be generic.
- * Custom repository optionally can extend AbstractRepository, Repository or TreeRepository.
- *
- * @deprecated use Repository.extend function to create a custom repository
- */
-export declare function EntityRepository(entity?: Function | EntitySchema<any>): ClassDecorator;

package/websql/lib/typeorm/decorator/Exclusion.d.ts

@@ -1,13 +0,0 @@
-// @ts-nocheck
-/**
- * Creates a database exclusion.
- * Can be used on entity.
- * Can create exclusions with composite columns when used on entity.
- */
-export 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.
- */
-export declare function Exclusion(name: string, expression: string): ClassDecorator & PropertyDecorator;

package/websql/lib/typeorm/decorator/Generated.d.ts

@@ -1,11 +0,0 @@
-// @ts-nocheck
-/**
- * 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.
- */
-export declare function Generated(strategy?: "increment" | "uuid" | "rowid"): PropertyDecorator;