taon-typeorm 21.0.2 → 21.0.6

package/browser/lib/typeorm/persistence/Subject.d.ts

@@ -1,156 +0,0 @@
-// @ts-nocheck
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { SubjectChangeMap } from "./SubjectChangeMap";
-import { RelationMetadata } from "../metadata/RelationMetadata";
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-/**
- * Subject is a subject of persistence.
- * It holds information about each entity that needs to be persisted:
- * - what entity should be persisted
- * - what is database representation of the persisted entity
- * - what entity metadata of the persisted entity
- * - what is allowed to with persisted entity (insert/update/remove)
- *
- * Having this collection of subjects we can perform database queries.
- */
-export declare class Subject {
-    readonly "@instanceof": symbol;
-    /**
-     * Entity metadata of the subject entity.
-     */
-    metadata: EntityMetadata;
-    /**
-     * Subject identifier.
-     * This identifier is not limited to table entity primary columns.
-     * This can be entity id or ids as well as some unique entity properties, like name or title.
-     * Insert / Update / Remove operation will be executed by a given identifier.
-     */
-    identifier: ObjectLiteral | undefined;
-    /**
-     * Copy of entity but with relational ids fulfilled.
-     */
-    entityWithFulfilledIds: ObjectLiteral | undefined;
-    /**
-     * If subject was created by cascades this property will contain subject
-     * from where this subject was created.
-     */
-    parentSubject?: Subject;
-    /**
-     * Gets entity sent to the persistence (e.g. changed entity).
-     * If entity is not set then this subject is created only for the entity loaded from the database,
-     * or this subject is used for the junction operation (junction operations are relying only on identifier).
-     */
-    entity?: ObjectLiteral;
-    /**
-     * Database entity.
-     * THIS IS NOT RAW ENTITY DATA, its a real entity.
-     */
-    databaseEntity?: ObjectLiteral;
-    /**
-     * Indicates if database entity was loaded.
-     * No matter if it was found or not, it indicates the fact of loading.
-     */
-    databaseEntityLoaded: boolean;
-    /**
-     * Changes needs to be applied in the database for the given subject.
-     */
-    changeMaps: SubjectChangeMap[];
-    /**
-     * Generated values returned by a database (for example generated id or default values).
-     * Used in insert and update operations.
-     * Has entity-like structure (not just column database name and values).
-     */
-    generatedMap?: ObjectLiteral;
-    /**
-     * Inserted values with updated values of special and default columns.
-     * Has entity-like structure (not just column database name and values).
-     */
-    insertedValueSet?: ObjectLiteral;
-    /**
-     * Indicates if this subject can be inserted into the database.
-     * This means that this subject either is newly persisted, either can be inserted by cascades.
-     */
-    canBeInserted: boolean;
-    /**
-     * Indicates if this subject can be updated in the database.
-     * This means that this subject either was persisted, either can be updated by cascades.
-     */
-    canBeUpdated: boolean;
-    /**
-     * Indicates if this subject MUST be removed from the database.
-     * This means that this subject either was removed, either was removed by cascades.
-     */
-    mustBeRemoved: boolean;
-    /**
-     * Indicates if this subject can be soft-removed from the database.
-     * This means that this subject either was soft-removed, either was soft-removed by cascades.
-     */
-    canBeSoftRemoved: boolean;
-    /**
-     * Indicates if this subject can be recovered from the database.
-     * This means that this subject either was recovered, either was recovered by cascades.
-     */
-    canBeRecovered: boolean;
-    /**
-     * Relations updated by the change maps.
-     */
-    updatedRelationMaps: {
-        relation: RelationMetadata;
-        value: ObjectLiteral;
-    }[];
-    /**
-     * List of updated columns
-     */
-    diffColumns: ColumnMetadata[];
-    /**
-     * List of updated relations
-     */
-    diffRelations: RelationMetadata[];
-    constructor(options: {
-        metadata: EntityMetadata;
-        parentSubject?: Subject;
-        entity?: ObjectLiteral;
-        canBeInserted?: boolean;
-        canBeUpdated?: boolean;
-        mustBeRemoved?: boolean;
-        canBeSoftRemoved?: boolean;
-        canBeRecovered?: boolean;
-        identifier?: ObjectLiteral;
-        changeMaps?: SubjectChangeMap[];
-    });
-    /**
-     * Checks if this subject must be inserted into the database.
-     * Subject can be inserted into the database if it is allowed to be inserted (explicitly persisted or by cascades)
-     * and if it does not have database entity set.
-     */
-    get mustBeInserted(): boolean;
-    /**
-     * Checks if this subject must be updated into the database.
-     * Subject can be updated in the database if it is allowed to be updated (explicitly persisted or by cascades)
-     * and if it does have differentiated columns or relations.
-     */
-    get mustBeUpdated(): boolean;
-    /**
-     * Checks if this subject must be soft-removed into the database.
-     * Subject can be updated in the database if it is allowed to be soft-removed (explicitly persisted or by cascades)
-     * and if it does have differentiated columns or relations.
-     */
-    get mustBeSoftRemoved(): boolean | ObjectLiteral;
-    /**
-     * Checks if this subject must be recovered into the database.
-     * Subject can be updated in the database if it is allowed to be recovered (explicitly persisted or by cascades)
-     * and if it does have differentiated columns or relations.
-     */
-    get mustBeRecovered(): boolean | ObjectLiteral;
-    /**
-     * Creates a value set needs to be inserted / updated in the database.
-     * Value set is based on the entity and change maps of the subject.
-     * Important note: this method pops data from this subject's change maps.
-     */
-    createValueSetAndPopChangeMap(): ObjectLiteral;
-    /**
-     * Recomputes entityWithFulfilledIds and identifier when entity changes.
-     */
-    recompute(): void;
-}

package/browser/lib/typeorm/persistence/SubjectChangeMap.d.ts

@@ -1,24 +0,0 @@
-// @ts-nocheck
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-import { RelationMetadata } from "../metadata/RelationMetadata";
-import { Subject } from "./Subject";
-/**
- * Change for insertion or updation of the column of the subject.
- */
-export interface SubjectChangeMap {
-    /**
-     * Column that needs to be changed.
-     * Either column, either relation must be set in the change.
-     */
-    column?: ColumnMetadata;
-    /**
-     * Relation that needs to be changed.
-     * Either column, either relation must be set in the change.
-     */
-    relation?: RelationMetadata;
-    /**
-     * Value needs to be inserted into given column.
-     * This value can also be another subject, when this column has a referenced column.
-     */
-    value: Subject | any;
-}

package/browser/lib/typeorm/persistence/SubjectChangedColumnsComputer.d.ts

@@ -1,19 +0,0 @@
-// @ts-nocheck
-import { Subject } from "./Subject";
-/**
- * Finds what columns are changed in the subject entities.
- */
-export declare class SubjectChangedColumnsComputer {
-    /**
-     * Finds what columns are changed in the subject entities.
-     */
-    compute(subjects: Subject[]): void;
-    /**
-     * Differentiate columns from the updated entity and entity stored in the database.
-     */
-    protected computeDiffColumns(subject: Subject): void;
-    /**
-     * Difference columns of the owning one-to-one and many-to-one columns.
-     */
-    protected computeDiffRelationalColumns(allSubjects: Subject[], subject: Subject): void;
-}

package/browser/lib/typeorm/persistence/SubjectDatabaseEntityLoader.d.ts

@@ -1,36 +0,0 @@
-// @ts-nocheck
-import { Subject } from "./Subject";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { QueryRunner } from "../query-runner/QueryRunner";
-/**
- * Loads database entities for all operate subjects which do not have database entity set.
- * All entities that we load database entities for are marked as updated or inserted.
- * To understand which of them really needs to be inserted or updated we need to load
- * their original representations from the database.
- */
-export declare class SubjectDatabaseEntityLoader {
-    protected queryRunner: QueryRunner;
-    protected subjects: Subject[];
-    constructor(queryRunner: QueryRunner, subjects: Subject[]);
-    /**
-     * Loads database entities for all subjects.
-     *
-     * loadAllRelations flag is used to load all relation ids of the object, no matter if they present in subject entity or not.
-     * This option is used for deletion.
-     */
-    load(operationType: "save" | "remove" | "soft-remove" | "recover"): Promise<void>;
-    /**
-     * Finds subjects where entity like given subject's entity.
-     * Comparison made by entity id.
-     * Multiple subjects may be returned if duplicates are present in the subject array.
-     * This will likely result in the same row being updated multiple times during a transaction.
-     */
-    protected findByPersistEntityLike(entityTarget: Function | string, entity: ObjectLiteral): Subject[];
-    /**
-     * Groups given Subject objects into groups separated by entity targets.
-     */
-    protected groupByEntityTargets(): {
-        target: Function | string;
-        subjects: Subject[];
-    }[];
-}

package/browser/lib/typeorm/persistence/SubjectExecutor.d.ts

@@ -1,119 +0,0 @@
-// @ts-nocheck
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { Subject } from "./Subject";
-import { SaveOptions } from "../repository/SaveOptions";
-import { RemoveOptions } from "../repository/RemoveOptions";
-import { BroadcasterResult } from "../subscriber/BroadcasterResult";
-/**
- * Executes all database operations (inserts, updated, deletes) that must be executed
- * with given persistence subjects.
- */
-export declare class SubjectExecutor {
-    /**
-     * Indicates if executor has any operations to execute (e.g. has insert / update / delete operations to be executed).
-     */
-    hasExecutableOperations: boolean;
-    /**
-     * QueryRunner used to execute all queries with a given subjects.
-     */
-    protected queryRunner: QueryRunner;
-    /**
-     * Persistence options.
-     */
-    protected options?: SaveOptions & RemoveOptions;
-    /**
-     * All subjects that needs to be operated.
-     */
-    protected allSubjects: Subject[];
-    /**
-     * Subjects that must be inserted.
-     */
-    protected insertSubjects: Subject[];
-    /**
-     * Subjects that must be updated.
-     */
-    protected updateSubjects: Subject[];
-    /**
-     * Subjects that must be removed.
-     */
-    protected removeSubjects: Subject[];
-    /**
-     * Subjects that must be soft-removed.
-     */
-    protected softRemoveSubjects: Subject[];
-    /**
-     * Subjects that must be recovered.
-     */
-    protected recoverSubjects: Subject[];
-    constructor(queryRunner: QueryRunner, subjects: Subject[], options?: SaveOptions & RemoveOptions);
-    /**
-     * Executes all operations over given array of subjects.
-     * Executes queries using given query runner.
-     */
-    execute(): Promise<void>;
-    /**
-     * Validates all given subjects.
-     */
-    protected validate(): void;
-    /**
-     * Performs entity re-computations - finds changed columns, re-builds insert/update/remove subjects.
-     */
-    protected recompute(): void;
-    /**
-     * Broadcasts "BEFORE_INSERT", "BEFORE_UPDATE", "BEFORE_REMOVE", "BEFORE_SOFT_REMOVE", "BEFORE_RECOVER" events for all given subjects.
-     */
-    protected broadcastBeforeEventsForAll(): BroadcasterResult;
-    /**
-     * Broadcasts "AFTER_INSERT", "AFTER_UPDATE", "AFTER_REMOVE", "AFTER_SOFT_REMOVE", "AFTER_RECOVER" events for all given subjects.
-     * Returns void if there wasn't any listener or subscriber executed.
-     * Note: this method has a performance-optimized code organization.
-     */
-    protected broadcastAfterEventsForAll(): BroadcasterResult;
-    /**
-     * Executes insert operations.
-     */
-    protected executeInsertOperations(): Promise<void>;
-    /**
-     * Updates all given subjects in the database.
-     */
-    protected executeUpdateOperations(): Promise<void>;
-    /**
-     * Removes all given subjects from the database.
-     *
-     * todo: we need to apply topological sort here as well
-     */
-    protected executeRemoveOperations(): Promise<void>;
-    private cloneMongoSubjectEntity;
-    /**
-     * Soft-removes all given subjects in the database.
-     */
-    protected executeSoftRemoveOperations(): Promise<void>;
-    /**
-     * Recovers all given subjects in the database.
-     */
-    protected executeRecoverOperations(): Promise<void>;
-    /**
-     * Updates all special columns of the saving entities (create date, update date, version, etc.).
-     * Also updates nullable columns and columns with default values.
-     */
-    protected updateSpecialColumnsInPersistedEntities(): void;
-    /**
-     * Updates all special columns of the saving entities (create date, update date, version, etc.).
-     * Also updates nullable columns and columns with default values.
-     */
-    protected updateSpecialColumnsInInsertedAndUpdatedEntities(subjects: Subject[]): void;
-    /**
-     * Groups subjects by metadata names (by tables) to make bulk insertions and deletions possible.
-     * However there are some limitations with bulk insertions of data into tables with generated (increment) columns
-     * in some drivers. Some drivers like mysql and sqlite does not support returning multiple generated columns
-     * after insertion and can only return a single generated column value, that's why its not possible to do bulk insertion,
-     * because it breaks insertion result's generatedMap and leads to problems when this subject is used in other subjects saves.
-     * That's why we only support bulking in junction tables for those drivers.
-     *
-     * Other drivers like postgres and sql server support RETURNING / OUTPUT statement which allows to return generated
-     * id for each inserted row, that's why bulk insertion is not limited to junction tables in there.
-     */
-    protected groupBulkSubjects(subjects: Subject[], type: "insert" | "delete"): [{
-        [key: string]: Subject[];
-    }, string[]];
-}

package/browser/lib/typeorm/persistence/SubjectTopoligicalSorter.d.ts

@@ -1,46 +0,0 @@
-// @ts-nocheck
-import { Subject } from "./Subject";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-/**
- * Orders insert or remove subjects in proper order (using topological sorting)
- * to make sure insert or remove operations are executed in a proper order.
- */
-export declare class SubjectTopoligicalSorter {
-    /**
-     * Insert subjects needs to be sorted.
-     */
-    subjects: Subject[];
-    /**
-     * Unique list of entity metadatas of this subject.
-     */
-    metadatas: EntityMetadata[];
-    constructor(subjects: Subject[]);
-    /**
-     * Sorts (orders) subjects in their topological order.
-     */
-    sort(direction: "insert" | "delete"): Subject[];
-    /**
-     * Removes already sorted subjects from this.subjects list of subjects.
-     */
-    protected removeAlreadySorted(subjects: Subject[]): void;
-    /**
-     * Extracts all unique metadatas from the given subjects.
-     */
-    protected getUniqueMetadatas(subjects: Subject[]): EntityMetadata[];
-    /**
-     * Gets dependency tree for all entity metadatas with non-nullable relations.
-     * We need to execute insertions first for entities which non-nullable relations.
-     */
-    protected getNonNullableDependencies(): string[][];
-    /**
-     * Gets dependency tree for all entity metadatas with non-nullable relations.
-     * We need to execute insertions first for entities which non-nullable relations.
-     */
-    protected getDependencies(): string[][];
-    /**
-     * Sorts given graph using topological sorting algorithm.
-     *
-     * Algorithm is kindly taken from https://github.com/marcelklehr/toposort repository.
-     */
-    protected toposort(edges: any[][]): any[];
-}

package/browser/lib/typeorm/persistence/subject-builder/CascadesSubjectBuilder.d.ts

@@ -1,20 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { ObjectLiteral } from "../../common/ObjectLiteral";
-/**
- * Finds all cascade operations of the given subject and cascade operations of the found cascaded subjects,
- * e.g. builds a cascade tree and creates a subjects for them.
- */
-export declare class CascadesSubjectBuilder {
-    protected allSubjects: Subject[];
-    constructor(allSubjects: Subject[]);
-    /**
-     * Builds a cascade subjects tree and pushes them in into the given array of subjects.
-     */
-    build(subject: Subject, operationType: "save" | "remove" | "soft-remove" | "recover"): void;
-    /**
-     * Finds subject where entity like given subject's entity.
-     * Comparison made by entity id.
-     */
-    protected findByPersistEntityLike(entityTarget: Function | string, entity: ObjectLiteral): Subject | undefined;
-}

package/browser/lib/typeorm/persistence/subject-builder/ManyToManySubjectBuilder.d.ts

@@ -1,35 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { ObjectLiteral } from "../../common/ObjectLiteral";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
-/**
- * Builds operations needs to be executed for many-to-many relations of the given subjects.
- *
- * by example: post contains owner many-to-many relation with categories in the property called "categories", e.g.
- *             @ManyToMany(type => Category, category => category.posts) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of junction table.
- */
-export declare class ManyToManySubjectBuilder {
-    protected subjects: Subject[];
-    constructor(subjects: Subject[]);
-    /**
-     * Builds operations for any changes in the many-to-many relations of the subjects.
-     */
-    build(): void;
-    /**
-     * Builds operations for removal of all many-to-many records of all many-to-many relations of the given subject.
-     */
-    buildForAllRemoval(subject: Subject): void;
-    /**
-     * Builds operations for a given subject and relation.
-     *
-     * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
-     */
-    protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata): void;
-    /**
-     * Creates identifiers for junction table.
-     * Example: { postId: 1, categoryId: 2 }
-     */
-    protected buildJunctionIdentifier(subject: Subject, relation: RelationMetadata, relationId: ObjectLiteral): ObjectLiteral;
-}

package/browser/lib/typeorm/persistence/subject-builder/OneToManySubjectBuilder.d.ts

@@ -1,28 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
-/**
- * Builds operations needs to be executed for one-to-many relations of the given subjects.
- *
- * by example: post contains one-to-many relation with category in the property called "categories", e.g.
- *             @OneToMany(type => Category, category => category.post) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
- *
- * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class
- *       make sure to reflect changes there as well.
- */
-export declare class OneToManySubjectBuilder {
-    protected subjects: Subject[];
-    constructor(subjects: Subject[]);
-    /**
-     * Builds all required operations.
-     */
-    build(): void;
-    /**
-     * Builds operations for a given subject and relation.
-     *
-     * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
-     */
-    protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata): void;
-}

package/browser/lib/typeorm/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.d.ts

@@ -1,28 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
-/**
- * Builds operations needs to be executed for one-to-one non-owner relations of the given subjects.
- *
- * by example: post contains one-to-one non-owner relation with category in the property called "category", e.g.
- *             @OneToOne(type => Category, category => category.post) category: Category
- *             If user sets a category into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
- *
- * note: this class shares lot of things with OneToManyUpdateBuilder, so when you change this class
- *       make sure to reflect changes there as well.
- */
-export declare class OneToOneInverseSideSubjectBuilder {
-    protected subjects: Subject[];
-    constructor(subjects: Subject[]);
-    /**
-     * Builds all required operations.
-     */
-    build(): void;
-    /**
-     * Builds operations for a given subject and relation.
-     *
-     * by example: subject is "post" entity we are saving here and relation is "category" inside it here.
-     */
-    protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata): void;
-}

package/browser/lib/typeorm/persistence/tree/ClosureSubjectExecutor.d.ts

@@ -1,27 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-/**
- * Executes subject operations for closure entities.
- */
-export declare class ClosureSubjectExecutor {
-    protected queryRunner: QueryRunner;
-    constructor(queryRunner: QueryRunner);
-    /**
-     * Executes operations when subject is being inserted.
-     */
-    insert(subject: Subject): Promise<void>;
-    /**
-     * Executes operations when subject is being updated.
-     */
-    update(subject: Subject): Promise<void>;
-    /**
-     * Executes operations when subject is being removed.
-     */
-    remove(subjects: Subject | Subject[]): Promise<void>;
-    /**
-     * Gets escaped table name with schema name if SqlServer or Postgres driver used with custom
-     * schema name, otherwise returns escaped table name.
-     */
-    protected getTableName(tablePath: string): string;
-}

package/browser/lib/typeorm/persistence/tree/MaterializedPathSubjectExecutor.d.ts

@@ -1,19 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-/**
- * Executes subject operations for materialized-path tree entities.
- */
-export declare class MaterializedPathSubjectExecutor {
-    protected queryRunner: QueryRunner;
-    constructor(queryRunner: QueryRunner);
-    /**
-     * Executes operations when subject is being inserted.
-     */
-    insert(subject: Subject): Promise<void>;
-    /**
-     * Executes operations when subject is being updated.
-     */
-    update(subject: Subject): Promise<void>;
-    private getEntityPath;
-}

package/browser/lib/typeorm/persistence/tree/NestedSetSubjectExecutor.d.ts

@@ -1,39 +0,0 @@
-// @ts-nocheck
-import { Subject } from "../Subject";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-import { ObjectLiteral } from "../../common/ObjectLiteral";
-import { EntityMetadata } from "../../metadata/EntityMetadata";
-declare class NestedSetIds {
-    left: number;
-    right: number;
-}
-/**
- * Executes subject operations for nested set tree entities.
- */
-export declare class NestedSetSubjectExecutor {
-    protected queryRunner: QueryRunner;
-    constructor(queryRunner: QueryRunner);
-    /**
-     * Executes operations when subject is being inserted.
-     */
-    insert(subject: Subject): Promise<void>;
-    /**
-     * Executes operations when subject is being updated.
-     */
-    update(subject: Subject): Promise<void>;
-    /**
-     * Executes operations when subject is being removed.
-     */
-    remove(subjects: Subject | Subject[]): Promise<void>;
-    /**
-     * Get the nested set ids for a given entity
-     */
-    protected getNestedSetIds(metadata: EntityMetadata, ids: ObjectLiteral | ObjectLiteral[]): Promise<NestedSetIds[]>;
-    private isUniqueRootEntity;
-    /**
-     * Gets escaped table name with schema name if SqlServer or Postgres driver used with custom
-     * schema name, otherwise returns escaped table name.
-     */
-    protected getTableName(tablePath: string): string;
-}
-export {};

package/browser/lib/typeorm/platform/PlatformTools.d.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-/**
- * Platform-specific tools.
- */
-export declare class PlatformTools {
-    /**
-     * Type of the currently running platform.
-     */
-    static get type(): 'node' | 'browser';
-    /**
-     * Gets global variable where global stuff can be stored.
-     */
-    static getGlobalVariable(): any;
-    /**
-     * Loads ("require"-s) given file or package.
-     * This operation only supports on node platform
-     */
-    static load(name: string): any;
-    /**
-     * Normalizes given path. Does "path.normalize".
-     */
-    static pathNormalize(pathStr: string): string;
-    /**
-     * Gets file extension. Does "path.extname".
-     */
-    static pathExtname(pathStr: string): string;
-    /**
-     * Resolved given path. Does "path.resolve".
-     */
-    static pathResolve(pathStr: string): string;
-    /**
-     * Synchronously checks if file exist. Does "fs.existsSync".
-     */
-    static fileExist(pathStr: string): boolean;
-    static readFileSync(filename: string): any;
-    static appendFileSync(filename: string, data: any): void;
-    static writeFile(path: string, data: any): Promise<void>;
-    /**
-     * Loads a dotenv file into the environment variables.
-     *
-     * @param path The file to load as a dotenv configuration
-     */
-    static dotenv(pathStr: string): void;
-    /**
-     * Gets environment variable.
-     */
-    static getEnvVariable(name: string): any;
-    /**
-     * Highlights sql string to be print in the console.
-     */
-    static highlightSql(sql: string): any;
-    /**
-     * Highlights json string to be print in the console.
-     */
-    static highlightJson(json: string): any;
-    /**
-     * Logging functions needed by AdvancedConsoleLogger
-     */
-    static logInfo(prefix: string, info: any): void;
-    static logError(prefix: string, error: any): void;
-    static logWarn(prefix: string, warning: any): void;
-    static log(message: string): void;
-    static warn(message: string): void;
-    static logCmdErr(prefix: string, err?: any): void;
-}