taon-typeorm 19.0.49 → 21.0.4

package/browser/lib/typeorm/repository/BaseEntity.d.ts

@@ -1,298 +0,0 @@
-// @ts-nocheck
-import { Repository } from "./Repository";
-import { FindOptionsWhere } from "../find-options/FindOptionsWhere";
-import { DeepPartial } from "../common/DeepPartial";
-import { SaveOptions } from "./SaveOptions";
-import { FindOneOptions } from "../find-options/FindOneOptions";
-import { RemoveOptions } from "./RemoveOptions";
-import { FindManyOptions } from "../find-options/FindManyOptions";
-import { DataSource } from "../data-source";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-import { InsertResult } from "../query-builder/result/InsertResult";
-import { UpdateResult } from "../query-builder/result/UpdateResult";
-import { DeleteResult } from "../query-builder/result/DeleteResult";
-import { ObjectID } from "../driver/mongodb/typings";
-import { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity";
-import { UpsertOptions } from "./UpsertOptions";
-import { EntityTarget } from "../common/EntityTarget";
-/**
- * Base abstract entity for all entities, used in ActiveRecord patterns.
- */
-export declare class BaseEntity {
-    /**
-     * DataSource used in all static methods of the BaseEntity.
-     */
-    private static dataSource;
-    /**
-     * Checks if entity has an id.
-     * If entity composite compose ids, it will check them all.
-     */
-    hasId(): boolean;
-    /**
-     * Saves current entity in the database.
-     * If entity does not exist in the database then inserts, otherwise updates.
-     */
-    save(options?: SaveOptions): Promise<this>;
-    /**
-     * Removes current entity from the database.
-     */
-    remove(options?: RemoveOptions): Promise<this>;
-    /**
-     * Records the delete date of current entity.
-     */
-    softRemove(options?: SaveOptions): Promise<this>;
-    /**
-     * Recovers a given entity in the database.
-     */
-    recover(options?: SaveOptions): Promise<this>;
-    /**
-     * Reloads entity data from the database.
-     */
-    reload(): Promise<void>;
-    /**
-     * Sets DataSource to be used by entity.
-     */
-    static useDataSource(dataSource: DataSource | null): void;
-    /**
-     * Gets current entity's Repository.
-     */
-    static getRepository<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity): Repository<T>;
-    /**
-     * Returns object that is managed by this repository.
-     * If this repository manages entity from schema,
-     * then it returns a name of that schema instead.
-     */
-    static get target(): EntityTarget<any>;
-    /**
-     * Checks entity has an id.
-     * If entity composite compose ids, it will check them all.
-     */
-    static hasId(entity: BaseEntity): boolean;
-    /**
-     * Gets entity mixed id.
-     */
-    static getId<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entity: T): any;
-    /**
-     * Creates a new query builder that can be used to build a SQL query.
-     */
-    static createQueryBuilder<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, alias?: string): SelectQueryBuilder<T>;
-    /**
-     * Creates a new entity instance.
-     */
-    static create<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity): T;
-    /**
-     * Creates a new entities and copies all entity properties from given objects into their new entities.
-     * Note that it copies only properties that present in entity schema.
-     */
-    static create<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entityLikeArray: DeepPartial<T>[]): T[];
-    /**
-     * Creates a new entity instance and copies all entity properties from this object into a new entity.
-     * Note that it copies only properties that present in entity schema.
-     */
-    static create<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entityLike: DeepPartial<T>): T;
-    /**
-     * Merges multiple entities (or entity-like objects) into a given entity.
-     */
-    static merge<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, mergeIntoEntity: T, ...entityLikes: DeepPartial<T>[]): T;
-    /**
-     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
-     * it loads it (and everything related to it), replaces all values with the new ones from the given object
-     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
-     * replaced from the new object.
-     *
-     * Note that given entity-like object must have an entity id / primary key to find entity by.
-     * Returns undefined if entity with given id was not found.
-     */
-    static preload<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entityLike: DeepPartial<T>): Promise<T | undefined>;
-    /**
-     * Saves all given entities in the database.
-     * If entities do not exist in the database then inserts, otherwise updates.
-     */
-    static save<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entities: DeepPartial<T>[], options?: SaveOptions): Promise<T[]>;
-    /**
-     * Saves a given entity in the database.
-     * If entity does not exist in the database then inserts, otherwise updates.
-     */
-    static save<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entity: DeepPartial<T>, options?: SaveOptions): Promise<T>;
-    /**
-     * Removes a given entities from the database.
-     */
-    static remove<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entities: T[], options?: RemoveOptions): Promise<T[]>;
-    /**
-     * Removes a given entity from the database.
-     */
-    static remove<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entity: T, options?: RemoveOptions): Promise<T>;
-    /**
-     * Records the delete date of all given entities.
-     */
-    static softRemove<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entities: T[], options?: SaveOptions): Promise<T[]>;
-    /**
-     * Records the delete date of a given entity.
-     */
-    static softRemove<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entity: T, options?: SaveOptions): Promise<T>;
-    /**
-     * Inserts a given entity into the database.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient INSERT query.
-     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
-     */
-    static insert<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entity: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T>[]): Promise<InsertResult>;
-    /**
-     * Updates entity partially. Entity can be found by a given conditions.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient UPDATE query.
-     * Does not check if entity exist in the database.
-     */
-    static update<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<T>, partialEntity: QueryDeepPartialEntity<T>): Promise<UpdateResult>;
-    /**
-     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
-     */
-    static upsert<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, entityOrEntities: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T>[], conflictPathsOrOptions: string[] | UpsertOptions<T>): Promise<InsertResult>;
-    /**
-     * Deletes entities by a given criteria.
-     * Unlike remove method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    static delete<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<T>): Promise<DeleteResult>;
-    /**
-     * Counts entities that match given options.
-     */
-    static count<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, options?: FindManyOptions<T>): Promise<number>;
-    /**
-     * Counts entities that match given WHERE conditions.
-     */
-    static countBy<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, where: FindOptionsWhere<T>): Promise<number>;
-    /**
-     * Finds entities that match given options.
-     */
-    static find<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, options?: FindManyOptions<T>): Promise<T[]>;
-    /**
-     * Finds entities that match given WHERE conditions.
-     */
-    static findBy<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, where: FindOptionsWhere<T>): Promise<T[]>;
-    /**
-     * Finds entities that match given find options.
-     * Also counts all entities that match given conditions,
-     * but ignores pagination settings (from and take options).
-     */
-    static findAndCount<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, options?: FindManyOptions<T>): Promise<[T[], number]>;
-    /**
-     * Finds entities that match given WHERE conditions.
-     * Also counts all entities that match given conditions,
-     * but ignores pagination settings (from and take options).
-     */
-    static findAndCountBy<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, where: FindOptionsWhere<T>): Promise<[T[], number]>;
-    /**
-     * Finds entities by ids.
-     * Optionally find options can be applied.
-     *
-     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findBy({
-     *     id: In([1, 2, 3])
-     * })
-     */
-    static findByIds<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, ids: any[]): Promise<T[]>;
-    /**
-     * Finds first entity that matches given conditions.
-     */
-    static findOne<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, options: FindOneOptions<T>): Promise<T | null>;
-    /**
-     * Finds first entity that matches given conditions.
-     */
-    static findOneBy<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, where: FindOptionsWhere<T>): Promise<T | null>;
-    /**
-     * Finds first entity that matches given options.
-     *
-     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findOneBy({
-     *     id: 1 // where "id" is your primary column name
-     * })
-     */
-    static findOneById<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, id: string | number | Date | ObjectID): Promise<T | null>;
-    /**
-     * Finds first entity that matches given conditions.
-     */
-    static findOneOrFail<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, options: FindOneOptions<T>): Promise<T>;
-    /**
-     * Finds first entity that matches given conditions.
-     */
-    static findOneByOrFail<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, where: FindOptionsWhere<T>): Promise<T>;
-    /**
-     * Executes a raw SQL query and returns a raw database results.
-     * Raw query execution is supported only by relational databases (MongoDB is not supported).
-     */
-    static query<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity, query: string, parameters?: any[]): Promise<any>;
-    /**
-     * Clears all the data from the given table/collection (truncates/drops it).
-     */
-    static clear<T extends BaseEntity>(this: {
-        new (): T;
-    } & typeof BaseEntity): Promise<void>;
-}

package/browser/lib/typeorm/repository/FindTreesOptions.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-/**
- * Special options passed to TreeRepository#findTrees
- */
-export interface FindTreesOptions {
-    /**
-     * When loading a tree from a TreeRepository, limits the depth of the descendents loaded
-     */
-    depth?: number;
-}

package/browser/lib/typeorm/repository/RemoveOptions.d.ts

@@ -1,28 +0,0 @@
-// @ts-nocheck
-/**
- * Special options passed to Repository#remove and Repository#delete methods.
- */
-export interface RemoveOptions {
-    /**
-     * Additional data to be passed with remove method.
-     * This data can be used in subscribers then.
-     */
-    data?: any;
-    /**
-     * Indicates if listeners and subscribers are called for this operation.
-     * By default they are enabled, you can disable them by setting { listeners: false } in save/remove options.
-     */
-    listeners?: boolean;
-    /**
-     * By default transactions are enabled and all queries in persistence operation are wrapped into the transaction.
-     * You can disable this behaviour by setting { transaction: false } in the persistence options.
-     */
-    transaction?: boolean;
-    /**
-     * Breaks save execution into given number of chunks.
-     * For example, if you want to save 100,000 objects but you have issues with saving them,
-     * you can break them into 10 groups of 10,000 objects (by setting { chunk: 10000 }) and save each group separately.
-     * This option is needed to perform very big insertions when you have issues with underlying driver parameter number limitation.
-     */
-    chunk?: number;
-}

package/browser/lib/typeorm/repository/Repository.d.ts

@@ -1,292 +0,0 @@
-// @ts-nocheck
-import { FindManyOptions } from "../find-options/FindManyOptions";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { FindOneOptions } from "../find-options/FindOneOptions";
-import { DeepPartial } from "../common/DeepPartial";
-import { SaveOptions } from "./SaveOptions";
-import { RemoveOptions } from "./RemoveOptions";
-import { EntityManager } from "../entity-manager/EntityManager";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-import { DeleteResult } from "../query-builder/result/DeleteResult";
-import { UpdateResult } from "../query-builder/result/UpdateResult";
-import { InsertResult } from "../query-builder/result/InsertResult";
-import { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity";
-import { ObjectID } from "../driver/mongodb/typings";
-import { FindOptionsWhere } from "../find-options/FindOptionsWhere";
-import { UpsertOptions } from "./UpsertOptions";
-import { EntityTarget } from "../common/EntityTarget";
-/**
- * Repository is supposed to work with your entity objects. Find entities, insert, update, delete, etc.
- */
-export declare class Repository<Entity extends ObjectLiteral> {
-    /**
-     * Entity target that is managed by this repository.
-     * If this repository manages entity from schema,
-     * then it returns a name of that schema instead.
-     */
-    readonly target: EntityTarget<Entity>;
-    /**
-     * Entity Manager used by this repository.
-     */
-    readonly manager: EntityManager;
-    /**
-     * Query runner provider used for this repository.
-     */
-    readonly queryRunner?: QueryRunner;
-    /**
-     * Entity metadata of the entity current repository manages.
-     */
-    get metadata(): import("taon-typeorm/browser").EntityMetadata;
-    constructor(target: EntityTarget<Entity>, manager: EntityManager, queryRunner?: QueryRunner);
-    /**
-     * Creates a new query builder that can be used to build a SQL query.
-     */
-    createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<Entity>;
-    /**
-     * Checks if entity has an id.
-     * If entity composite compose ids, it will check them all.
-     */
-    hasId(entity: Entity): boolean;
-    /**
-     * Gets entity mixed id.
-     */
-    getId(entity: Entity): any;
-    /**
-     * Creates a new entity instance.
-     */
-    create(): Entity;
-    /**
-     * Creates new entities and copies all entity properties from given objects into their new entities.
-     * Note that it copies only properties that are present in entity schema.
-     */
-    create(entityLikeArray: DeepPartial<Entity>[]): Entity[];
-    /**
-     * Creates a new entity instance and copies all entity properties from this object into a new entity.
-     * Note that it copies only properties that are present in entity schema.
-     */
-    create(entityLike: DeepPartial<Entity>): Entity;
-    /**
-     * Merges multiple entities (or entity-like objects) into a given entity.
-     */
-    merge(mergeIntoEntity: Entity, ...entityLikes: DeepPartial<Entity>[]): Entity;
-    /**
-     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
-     * it loads it (and everything related to it), replaces all values with the new ones from the given object
-     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
-     * replaced from the new object.
-     *
-     * Note that given entity-like object must have an entity id / primary key to find entity by.
-     * Returns undefined if entity with given id was not found.
-     */
-    preload(entityLike: DeepPartial<Entity>): Promise<Entity | undefined>;
-    /**
-     * Saves all given entities in the database.
-     * If entities do not exist in the database then inserts, otherwise updates.
-     */
-    save<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & {
-        reload: false;
-    }): Promise<T[]>;
-    /**
-     * Saves all given entities in the database.
-     * If entities do not exist in the database then inserts, otherwise updates.
-     */
-    save<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
-    /**
-     * Saves a given entity in the database.
-     * If entity does not exist in the database then inserts, otherwise updates.
-     */
-    save<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & {
-        reload: false;
-    }): Promise<T>;
-    /**
-     * Saves a given entity in the database.
-     * If entity does not exist in the database then inserts, otherwise updates.
-     */
-    save<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions): Promise<T & Entity>;
-    /**
-     * Removes a given entities from the database.
-     */
-    remove(entities: Entity[], options?: RemoveOptions): Promise<Entity[]>;
-    /**
-     * Removes a given entity from the database.
-     */
-    remove(entity: Entity, options?: RemoveOptions): Promise<Entity>;
-    /**
-     * Records the delete date of all given entities.
-     */
-    softRemove<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & {
-        reload: false;
-    }): Promise<T[]>;
-    /**
-     * Records the delete date of all given entities.
-     */
-    softRemove<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
-    /**
-     * Records the delete date of a given entity.
-     */
-    softRemove<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & {
-        reload: false;
-    }): Promise<T>;
-    /**
-     * Records the delete date of a given entity.
-     */
-    softRemove<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions): Promise<T & Entity>;
-    /**
-     * Recovers all given entities in the database.
-     */
-    recover<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & {
-        reload: false;
-    }): Promise<T[]>;
-    /**
-     * Recovers all given entities in the database.
-     */
-    recover<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
-    /**
-     * Recovers a given entity in the database.
-     */
-    recover<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & {
-        reload: false;
-    }): Promise<T>;
-    /**
-     * Recovers a given entity in the database.
-     */
-    recover<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions): Promise<T & Entity>;
-    /**
-     * Inserts a given entity into the database.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient INSERT query.
-     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
-     */
-    insert(entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult>;
-    /**
-     * Updates entity partially. Entity can be found by a given conditions.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient UPDATE query.
-     * Does not check if entity exist in the database.
-     */
-    update(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>, partialEntity: QueryDeepPartialEntity<Entity>): Promise<UpdateResult>;
-    /**
-     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
-     */
-    upsert(entityOrEntities: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[], conflictPathsOrOptions: string[] | UpsertOptions<Entity>): Promise<InsertResult>;
-    /**
-     * Deletes entities by a given criteria.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    delete(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>): Promise<DeleteResult>;
-    /**
-     * Records the delete date of entities by a given criteria.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient SOFT-DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    softDelete(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
-    /**
-     * Restores entities by a given criteria.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient SOFT-DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    restore(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
-    /**
-     * Counts entities that match given options.
-     * Useful for pagination.
-     */
-    count(options?: FindManyOptions<Entity>): Promise<number>;
-    /**
-     * Counts entities that match given conditions.
-     * Useful for pagination.
-     */
-    countBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number>;
-    /**
-     * Finds entities that match given find options.
-     */
-    find(options?: FindManyOptions<Entity>): Promise<Entity[]>;
-    /**
-     * Finds entities that match given find options.
-     */
-    findBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity[]>;
-    /**
-     * Finds entities that match given find options.
-     * Also counts all entities that match given conditions,
-     * but ignores pagination settings (from and take options).
-     */
-    findAndCount(options?: FindManyOptions<Entity>): Promise<[Entity[], number]>;
-    /**
-     * Finds entities that match given WHERE conditions.
-     * Also counts all entities that match given conditions,
-     * but ignores pagination settings (from and take options).
-     */
-    findAndCountBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<[Entity[], number]>;
-    /**
-     * Finds entities with ids.
-     * Optionally find options or conditions can be applied.
-     *
-     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findBy({
-     *     id: In([1, 2, 3])
-     * })
-     */
-    findByIds(ids: any[]): Promise<Entity[]>;
-    /**
-     * Finds first entity by a given find options.
-     * If entity was not found in the database - returns null.
-     */
-    findOne(options: FindOneOptions<Entity>): Promise<Entity | null>;
-    /**
-     * Finds first entity that matches given where condition.
-     * If entity was not found in the database - returns null.
-     */
-    findOneBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity | null>;
-    /**
-     * Finds first entity that matches given id.
-     * If entity was not found in the database - returns null.
-     *
-     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findOneBy({
-     *     id: 1 // where "id" is your primary column name
-     * })
-     */
-    findOneById(id: number | string | Date | ObjectID): Promise<Entity | null>;
-    /**
-     * Finds first entity by a given find options.
-     * If entity was not found in the database - rejects with error.
-     */
-    findOneOrFail(options: FindOneOptions<Entity>): Promise<Entity>;
-    /**
-     * Finds first entity that matches given where condition.
-     * If entity was not found in the database - rejects with error.
-     */
-    findOneByOrFail(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity>;
-    /**
-     * Executes a raw SQL query and returns a raw database results.
-     * Raw query execution is supported only by relational databases (MongoDB is not supported).
-     */
-    query(query: string, parameters?: any[]): Promise<any>;
-    /**
-     * Clears all the data from the given table/collection (truncates/drops it).
-     *
-     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
-     * @see https://stackoverflow.com/a/5972738/925151
-     */
-    clear(): Promise<void>;
-    /**
-     * Increments some column by provided value of the entities matched given conditions.
-     */
-    increment(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
-    /**
-     * Decrements some column by provided value of the entities matched given conditions.
-     */
-    decrement(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
-    /**
-     * Extends repository with provided functions.
-     */
-    extend<CustomRepository>(custom: CustomRepository & ThisType<Repository<Entity> & CustomRepository>): Repository<Entity> & CustomRepository;
-}

package/browser/lib/typeorm/repository/SaveOptions.d.ts

@@ -1,36 +0,0 @@
-// @ts-nocheck
-/**
- * Special options passed to Repository#save, Repository#insert and Repository#update methods.
- */
-export interface SaveOptions {
-    /**
-     * Additional data to be passed with persist method.
-     * This data can be used in subscribers then.
-     */
-    data?: any;
-    /**
-     * Indicates if listeners and subscribers are called for this operation.
-     * By default they are enabled, you can disable them by setting { listeners: false } in save/remove options.
-     */
-    listeners?: boolean;
-    /**
-     * By default transactions are enabled and all queries in persistence operation are wrapped into the transaction.
-     * You can disable this behaviour by setting { transaction: false } in the persistence options.
-     */
-    transaction?: boolean;
-    /**
-     * Breaks save execution into chunks of a given size.
-     * For example, if you want to save 100,000 objects but you have issues with saving them,
-     * you can break them into 10 groups of 10,000 objects (by setting { chunk: 10000 }) and save each group separately.
-     * This option is needed to perform very big insertions when you have issues with underlying driver parameter number limitation.
-     */
-    chunk?: number;
-    /**
-     * Flag to determine whether the entity that is being persisted
-     * should be reloaded during the persistence operation.
-     *
-     * It will work only on databases which does not support RETURNING / OUTPUT statement.
-     * Enabled by default.
-     */
-    reload?: boolean;
-}