taon-typeorm 19.0.49 → 21.0.4

package/websql/lib/typeorm/subscriber/Broadcaster.d.ts

@@ -1,168 +0,0 @@
-// @ts-nocheck
-import { EntitySubscriberInterface } from "./EntitySubscriberInterface";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { BroadcasterResult } from "./BroadcasterResult";
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-import { RelationMetadata } from "../metadata/RelationMetadata";
-interface BroadcasterEvents {
-    BeforeTransactionCommit: () => void;
-    AfterTransactionCommit: () => void;
-    BeforeTransactionStart: () => void;
-    AfterTransactionStart: () => void;
-    BeforeTransactionRollback: () => void;
-    AfterTransactionRollback: () => void;
-    BeforeUpdate: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]) => void;
-    AfterUpdate: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]) => void;
-    BeforeInsert: (metadata: EntityMetadata, entity: ObjectLiteral | undefined) => void;
-    AfterInsert: (metadata: EntityMetadata, entity: ObjectLiteral | undefined) => void;
-    BeforeRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void;
-    AfterRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void;
-    BeforeSoftRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void;
-    AfterSoftRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void;
-    BeforeRecover: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void;
-    AfterRecover: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void;
-    Load: (metadata: EntityMetadata, entities: ObjectLiteral[]) => void;
-}
-/**
- * Broadcaster provides a helper methods to broadcast events to the subscribers.
- */
-export declare class Broadcaster {
-    private queryRunner;
-    constructor(queryRunner: QueryRunner);
-    broadcast<U extends keyof BroadcasterEvents>(event: U, ...args: Parameters<BroadcasterEvents[U]>): Promise<void>;
-    /**
-     * Broadcasts "BEFORE_INSERT" event.
-     * Before insert event is executed before entity is being inserted to the database for the first time.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastBeforeInsertEvent(result: BroadcasterResult, metadata: EntityMetadata, entity: undefined | ObjectLiteral): void;
-    /**
-     * Broadcasts "BEFORE_UPDATE" event.
-     * Before update event is executed before entity is being updated in the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastBeforeUpdateEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]): void;
-    /**
-     * Broadcasts "BEFORE_REMOVE" event.
-     * Before remove event is executed before entity is being removed from the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastBeforeRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
-    /**
-     * Broadcasts "BEFORE_SOFT_REMOVE" event.
-     * Before soft remove event is executed before entity is being soft removed from the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastBeforeSoftRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
-    /**
-     * Broadcasts "BEFORE_RECOVER" event.
-     * Before recover event is executed before entity is being recovered in the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastBeforeRecoverEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
-    /**
-     * Broadcasts "AFTER_INSERT" event.
-     * After insert event is executed after entity is being persisted to the database for the first time.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastAfterInsertEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral): void;
-    /**
-     * Broadcasts "BEFORE_TRANSACTION_START" event.
-     */
-    broadcastBeforeTransactionStartEvent(result: BroadcasterResult): void;
-    /**
-     * Broadcasts "AFTER_TRANSACTION_START" event.
-     */
-    broadcastAfterTransactionStartEvent(result: BroadcasterResult): void;
-    /**
-     * Broadcasts "BEFORE_TRANSACTION_COMMIT" event.
-     */
-    broadcastBeforeTransactionCommitEvent(result: BroadcasterResult): void;
-    /**
-     * Broadcasts "AFTER_TRANSACTION_COMMIT" event.
-     */
-    broadcastAfterTransactionCommitEvent(result: BroadcasterResult): void;
-    /**
-     * Broadcasts "BEFORE_TRANSACTION_ROLLBACK" event.
-     */
-    broadcastBeforeTransactionRollbackEvent(result: BroadcasterResult): void;
-    /**
-     * Broadcasts "AFTER_TRANSACTION_ROLLBACK" event.
-     */
-    broadcastAfterTransactionRollbackEvent(result: BroadcasterResult): void;
-    /**
-     * Broadcasts "AFTER_UPDATE" event.
-     * After update event is executed after entity is being updated in the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastAfterUpdateEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]): void;
-    /**
-     * Broadcasts "AFTER_REMOVE" event.
-     * After remove event is executed after entity is being removed from the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastAfterRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
-    /**
-     * Broadcasts "AFTER_SOFT_REMOVE" event.
-     * After soft remove event is executed after entity is being soft removed from the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastAfterSoftRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
-    /**
-     * Broadcasts "AFTER_RECOVER" event.
-     * After recover event is executed after entity is being recovered in the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastAfterRecoverEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
-    /**
-     * @deprecated Use `broadcastLoadForAllEvent`
-     */
-    broadcastLoadEventsForAll(result: BroadcasterResult, metadata: EntityMetadata, entities: ObjectLiteral[]): void;
-    /**
-     * Broadcasts "AFTER_LOAD" event for all given entities, and their sub-entities.
-     * After load event is executed after entity has been loaded from the database.
-     * All subscribers and entity listeners who listened to this event will be executed at this point.
-     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
-     *
-     * Note: this method has a performance-optimized code organization, do not change code structure.
-     */
-    broadcastLoadEvent(result: BroadcasterResult, metadata: EntityMetadata, entities: ObjectLiteral[]): void;
-    /**
-     * Checks if subscriber's methods can be executed by checking if its don't listen to the particular entity,
-     * or listens our entity.
-     */
-    protected isAllowedSubscriber(subscriber: EntitySubscriberInterface<any>, target: Function | string): boolean;
-}
-export {};

package/websql/lib/typeorm/subscriber/BroadcasterResult.d.ts

@@ -1,18 +0,0 @@
-// @ts-nocheck
-/**
- * Broadcaster execution result - promises executed by operations and number of executed listeners and subscribers.
- */
-export declare class BroadcasterResult {
-    /**
-     * Number of executed listeners and subscribers.
-     */
-    count: number;
-    /**
-     * Promises returned by listeners and subscribers which needs to be awaited.
-     */
-    promises: Promise<any>[];
-    /**
-     * Wait for all promises to settle
-     */
-    wait(): Promise<BroadcasterResult>;
-}

package/websql/lib/typeorm/subscriber/EntitySubscriberInterface.d.ts

@@ -1,93 +0,0 @@
-// @ts-nocheck
-import { TransactionCommitEvent } from "./event/TransactionCommitEvent";
-import { TransactionRollbackEvent } from "./event/TransactionRollbackEvent";
-import { TransactionStartEvent } from "./event/TransactionStartEvent";
-import { UpdateEvent } from "./event/UpdateEvent";
-import { RemoveEvent } from "./event/RemoveEvent";
-import { InsertEvent } from "./event/InsertEvent";
-import { LoadEvent } from "./event/LoadEvent";
-import { SoftRemoveEvent } from "./event/SoftRemoveEvent";
-import { RecoverEvent } from "./event/RecoverEvent";
-/**
- * Classes that implement this interface are subscribers that subscribe for the specific events in the ORM.
- */
-export interface EntitySubscriberInterface<Entity = any> {
-    /**
-     * Returns the class of the entity to which events will listen.
-     * If this method is omitted, then subscriber will listen to events of all entities.
-     */
-    listenTo?(): Function | string;
-    /**
-     * Called after entity is loaded from the database.
-     *
-     * For backward compatibility this signature is slightly different from the
-     * others.  `event` was added later but is always provided (it is only
-     * optional in the signature so that its introduction does not break
-     * compilation for existing subscribers).
-     */
-    afterLoad?(entity: Entity, event?: LoadEvent<Entity>): Promise<any> | void;
-    /**
-     * Called before entity is inserted to the database.
-     */
-    beforeInsert?(event: InsertEvent<Entity>): Promise<any> | void;
-    /**
-     * Called after entity is inserted to the database.
-     */
-    afterInsert?(event: InsertEvent<Entity>): Promise<any> | void;
-    /**
-     * Called before entity is updated in the database.
-     */
-    beforeUpdate?(event: UpdateEvent<Entity>): Promise<any> | void;
-    /**
-     * Called after entity is updated in the database.
-     */
-    afterUpdate?(event: UpdateEvent<Entity>): Promise<any> | void;
-    /**
-     * Called before entity is removed from the database.
-     */
-    beforeRemove?(event: RemoveEvent<Entity>): Promise<any> | void;
-    /**
-     * Called before entity is soft removed from the database.
-     */
-    beforeSoftRemove?(event: SoftRemoveEvent<Entity>): Promise<any> | void;
-    /**
-     * Called before entity is recovered in the database.
-     */
-    beforeRecover?(event: RecoverEvent<Entity>): Promise<any> | void;
-    /**
-     * Called after entity is removed from the database.
-     */
-    afterRemove?(event: RemoveEvent<Entity>): Promise<any> | void;
-    /**
-     * Called after entity is soft removed from the database.
-     */
-    afterSoftRemove?(event: SoftRemoveEvent<Entity>): Promise<any> | void;
-    /**
-     * Called after entity is recovered in the database.
-     */
-    afterRecover?(event: RecoverEvent<Entity>): Promise<any> | void;
-    /**
-     * Called before transaction is started.
-     */
-    beforeTransactionStart?(event: TransactionStartEvent): Promise<any> | void;
-    /**
-     * Called after transaction is started.
-     */
-    afterTransactionStart?(event: TransactionStartEvent): Promise<any> | void;
-    /**
-     * Called before transaction is committed.
-     */
-    beforeTransactionCommit?(event: TransactionCommitEvent): Promise<any> | void;
-    /**
-     * Called after transaction is committed.
-     */
-    afterTransactionCommit?(event: TransactionCommitEvent): Promise<any> | void;
-    /**
-     * Called before transaction rollback.
-     */
-    beforeTransactionRollback?(event: TransactionRollbackEvent): Promise<any> | void;
-    /**
-     * Called after transaction rollback.
-     */
-    afterTransactionRollback?(event: TransactionRollbackEvent): Promise<any> | void;
-}

package/websql/lib/typeorm/subscriber/event/InsertEvent.d.ts

@@ -1,32 +0,0 @@
-// @ts-nocheck
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { DataSource } from "../../data-source/DataSource";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-import { EntityMetadata } from "../../metadata/EntityMetadata";
-/**
- * InsertEvent is an object that broadcaster sends to the entity subscriber when entity is inserted to the database.
- */
-export interface InsertEvent<Entity> {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-    /**
-     * Inserting event.
-     */
-    entity: Entity;
-    /**
-     * Metadata of the entity.
-     */
-    metadata: EntityMetadata;
-}

package/websql/lib/typeorm/subscriber/event/LoadEvent.d.ts

@@ -1,32 +0,0 @@
-// @ts-nocheck
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { DataSource } from "../../data-source/DataSource";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-import { EntityMetadata } from "../../metadata/EntityMetadata";
-/**
- * LoadEvent is an object that broadcaster sends to the entity subscriber when an entity is loaded from the database.
- */
-export interface LoadEvent<Entity> {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-    /**
-     * Loaded entity.
-     */
-    entity: Entity;
-    /**
-     * Metadata of the entity.
-     */
-    metadata: EntityMetadata;
-}

package/websql/lib/typeorm/subscriber/event/RecoverEvent.d.ts

@@ -1,7 +0,0 @@
-// @ts-nocheck
-import { RemoveEvent } from "./RemoveEvent";
-/**
- * RecoverEvent is an object that broadcaster sends to the entity subscriber when entity is being recovered in the database.
- */
-export interface RecoverEvent<Entity> extends RemoveEvent<Entity> {
-}

package/websql/lib/typeorm/subscriber/event/RemoveEvent.d.ts

@@ -1,41 +0,0 @@
-// @ts-nocheck
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { DataSource } from "../../data-source/DataSource";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-import { EntityMetadata } from "../../metadata/EntityMetadata";
-/**
- * RemoveEvent is an object that broadcaster sends to the entity subscriber when entity is being removed to the database.
- */
-export interface RemoveEvent<Entity> {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-    /**
-     * Entity that is being removed.
-     * This may absent if entity is removed without being loaded (for examples by cascades).
-     */
-    entity?: Entity;
-    /**
-     * Metadata of the entity.
-     */
-    metadata: EntityMetadata;
-    /**
-     * Database representation of entity that is being removed.
-     */
-    databaseEntity: Entity;
-    /**
-     * Id or ids of the entity that is being removed.
-     */
-    entityId?: any;
-}

package/websql/lib/typeorm/subscriber/event/SoftRemoveEvent.d.ts

@@ -1,7 +0,0 @@
-// @ts-nocheck
-import { RemoveEvent } from "./RemoveEvent";
-/**
- * SoftRemoveEvent is an object that broadcaster sends to the entity subscriber when entity is being soft removed to the database.
- */
-export interface SoftRemoveEvent<Entity> extends RemoveEvent<Entity> {
-}

package/websql/lib/typeorm/subscriber/event/TransactionCommitEvent.d.ts

@@ -1,23 +0,0 @@
-// @ts-nocheck
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { DataSource } from "../../data-source/DataSource";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-/**
- * TransactionCommitEvent is an object that broadcaster sends to the entity subscriber when an transaction is committed.
- */
-export interface TransactionCommitEvent {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-}

package/websql/lib/typeorm/subscriber/event/TransactionRollbackEvent.d.ts

@@ -1,23 +0,0 @@
-// @ts-nocheck
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { DataSource } from "../../data-source/DataSource";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-/**
- * TransactionRollbackEvent is an object that broadcaster sends to the entity subscriber on transaction rollback.
- */
-export interface TransactionRollbackEvent {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-}

package/websql/lib/typeorm/subscriber/event/TransactionStartEvent.d.ts

@@ -1,23 +0,0 @@
-// @ts-nocheck
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { DataSource } from "../../data-source/DataSource";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-/**
- * TransactionStartEvent is an object that broadcaster sends to the entity subscriber before transaction is started.
- */
-export interface TransactionStartEvent {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-}

package/websql/lib/typeorm/subscriber/event/UpdateEvent.d.ts

@@ -1,47 +0,0 @@
-// @ts-nocheck
-import { ColumnMetadata } from "../../metadata/ColumnMetadata";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
-import { EntityManager } from "../../entity-manager/EntityManager";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-import { DataSource } from "../../data-source/DataSource";
-import { EntityMetadata } from "../../metadata/EntityMetadata";
-import { ObjectLiteral } from "../../common/ObjectLiteral";
-/**
- * UpdateEvent is an object that broadcaster sends to the entity subscriber when entity is being updated in the database.
- */
-export interface UpdateEvent<Entity> {
-    /**
-     * Connection used in the event.
-     */
-    connection: DataSource;
-    /**
-     * QueryRunner used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this query runner instance.
-     */
-    queryRunner: QueryRunner;
-    /**
-     * EntityManager used in the event transaction.
-     * All database operations in the subscribed event listener should be performed using this entity manager instance.
-     */
-    manager: EntityManager;
-    /**
-     * Updating entity.
-     */
-    entity: ObjectLiteral | undefined;
-    /**
-     * Metadata of the entity.
-     */
-    metadata: EntityMetadata;
-    /**
-     * Updating entity in the database.
-     */
-    databaseEntity: Entity;
-    /**
-     * List of updated columns. In query builder has no affected
-     */
-    updatedColumns: ColumnMetadata[];
-    /**
-     * List of updated relations. In query builder has no affected
-     */
-    updatedRelations: RelationMetadata[];
-}

package/websql/lib/typeorm/util/ApplyValueTransformers.d.ts

@@ -1,6 +0,0 @@
-// @ts-nocheck
-import { ValueTransformer } from "../decorator/options/ValueTransformer";
-export declare class ApplyValueTransformers {
-    static transformFrom(transformer: ValueTransformer | ValueTransformer[], databaseValue: any): any;
-    static transformTo(transformer: ValueTransformer | ValueTransformer[], entityValue: any): any;
-}

package/websql/lib/typeorm/util/DateUtils.d.ts

@@ -1,59 +0,0 @@
-// @ts-nocheck
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-/**
- * Provides utilities to transform hydrated and persisted data.
- */
-export declare class DateUtils {
-    /**
-     * Normalizes date object hydrated from the database.
-     */
-    static normalizeHydratedDate(mixedDate: Date | string | undefined): Date | string | undefined;
-    /**
-     * Converts given value into date string in a "YYYY-MM-DD" format.
-     */
-    static mixedDateToDateString(value: string | Date): string;
-    /**
-     * Converts given value into date object.
-     */
-    static mixedDateToDate(mixedDate: Date | string, toUtc?: boolean, useMilliseconds?: boolean): Date;
-    /**
-     * Converts given value into time string in a "HH:mm:ss" format.
-     */
-    static mixedDateToTimeString(value: Date | any, skipSeconds?: boolean): string | any;
-    /**
-     * Converts given value into time string in a "HH:mm:ss" format.
-     */
-    static mixedTimeToDate(value: Date | any): string | any;
-    /**
-     * Converts given string value with "-" separator into a "HH:mm:ss" format.
-     */
-    static mixedTimeToString(value: string | any, skipSeconds?: boolean): string | any;
-    /**
-     * Converts given value into datetime string in a "YYYY-MM-DD HH-mm-ss" format.
-     */
-    static mixedDateToDatetimeString(value: Date | any, useMilliseconds?: boolean): string | any;
-    /**
-     * Converts given value into utc datetime string in a "YYYY-MM-DD HH-mm-ss.sss" format.
-     */
-    static mixedDateToUtcDatetimeString(value: Date | any): string | any;
-    /**
-     * Converts each item in the given array to string joined by "," separator.
-     */
-    static simpleArrayToString(value: any[] | any): string[] | any;
-    /**
-     * Converts given string to simple array split by "," separator.
-     */
-    static stringToSimpleArray(value: string | any): string | any;
-    static simpleJsonToString(value: any): string;
-    static stringToSimpleJson(value: any): any;
-    static simpleEnumToString(value: any): string;
-    static stringToSimpleEnum(value: any, columnMetadata: ColumnMetadata): any;
-    /**
-     * Formats given number to "0x" format, e.g. if the totalLength = 2 and the value is 1 then it will return "01".
-     */
-    private static formatZerolessValue;
-    /**
-     * Formats given number to "0x" format, e.g. if it is 1 then it will return "01".
-     */
-    private static formatMilliseconds;
-}

package/websql/lib/typeorm/util/DepGraph.d.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-/**
- * This source code is from https://github.com/jriecken/dependency-graph
- * Just added "any" types here, wrapper everything into exported class.
- * We cant use a package itself because we want to package "everything-in-it" for the frontend users of TypeORM.
- */
-export declare class DepGraph {
-    nodes: any;
-    outgoingEdges: any;
-    incomingEdges: any;
-    /**
-     * Add a node to the dependency graph. If a node already exists, this method will do nothing.
-     */
-    addNode(node: any, data?: any): void;
-    /**
-     * Remove a node from the dependency graph. If a node does not exist, this method will do nothing.
-     */
-    removeNode(node: any): void;
-    /**
-     * Check if a node exists in the graph
-     */
-    hasNode(node: any): any;
-    /**
-     * Get the data associated with a node name
-     */
-    getNodeData(node: any): any;
-    /**
-     * Set the associated data for a given node name. If the node does not exist, this method will throw an error
-     */
-    setNodeData(node: any, data: any): void;
-    /**
-     * Add a dependency between two nodes. If either of the nodes does not exist,
-     * an Error will be thrown.
-     */
-    addDependency(from: any, to: any): boolean;
-    /**
-     * Remove a dependency between two nodes.
-     */
-    removeDependency(from: any, to: any): void;
-    /**
-     * Get an array containing the nodes that the specified node depends on (transitively).
-     *
-     * Throws an Error if the graph has a cycle, or the specified node does not exist.
-     *
-     * If `leavesOnly` is true, only nodes that do not depend on any other nodes will be returned
-     * in the array.
-     */
-    dependenciesOf(node: any, leavesOnly: any): any[];
-    /**
-     * get an array containing the nodes that depend on the specified node (transitively).
-     *
-     * Throws an Error if the graph has a cycle, or the specified node does not exist.
-     *
-     * If `leavesOnly` is true, only nodes that do not have any dependants will be returned in the array.
-     */
-    dependantsOf(node: any, leavesOnly: any): any[];
-    /**
-     * Construct the overall processing order for the dependency graph.
-     *
-     * Throws an Error if the graph has a cycle.
-     *
-     * If `leavesOnly` is true, only nodes that do not depend on any other nodes will be returned.
-     */
-    overallOrder(leavesOnly?: any): any[];
-}