@depup/typeorm-extension 3.9.0-depup.0

package/dist/query/index.d.ts

@@ -0,0 +1,4 @@
+export * from './module';
+export * from './parameter';
+export * from './type';
+export * from './utils';

package/dist/query/module.d.ts

@@ -0,0 +1,5 @@
+import type { ParseInput, ParseOutput } from 'rapiq';
+import type { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { QueryApplyOptions, QueryApplyOutput } from './type';
+export declare function applyQueryParseOutput<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, context: ParseOutput, options?: QueryApplyOptions<T>): ParseOutput;
+export declare function applyQuery<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, input: ParseInput, options?: QueryApplyOptions<T>): QueryApplyOutput;

package/dist/query/parameter/fields/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/query/parameter/fields/module.d.ts

@@ -0,0 +1,25 @@
+import type { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { QueryFieldsApplyOptions, QueryFieldsApplyOutput } from './type';
+/**
+ * Apply parsed fields parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */
+export declare function applyQueryFieldsParseOutput<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: QueryFieldsApplyOutput, options?: QueryFieldsApplyOptions<T>): import("rapiq").FieldsParseOutput;
+/**
+ * Apply raw fields parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQueryFields<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryFieldsApplyOptions<T>): QueryFieldsApplyOutput;
+/**
+ * Apply raw fields parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyFields<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryFieldsApplyOptions<T>): QueryFieldsApplyOutput;

package/dist/query/parameter/fields/type.d.ts

@@ -0,0 +1,6 @@
+import type { FieldsParseOptions, FieldsParseOutput } from 'rapiq';
+import type { ObjectLiteral } from 'typeorm';
+export type QueryFieldsApplyOptions<T extends ObjectLiteral = ObjectLiteral> = FieldsParseOptions<T> & {
+    defaultAlias?: string;
+};
+export type QueryFieldsApplyOutput = FieldsParseOutput;

package/dist/query/parameter/filters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/query/parameter/filters/module.d.ts

@@ -0,0 +1,35 @@
+import type { FiltersParseOutput } from 'rapiq';
+import type { ObjectLiteral, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm';
+import type { QueryFiltersApplyOptions, QueryFiltersApplyOutput, QueryFiltersOutput } from './type';
+export declare function transformParsedFilters<T extends ObjectLiteral = ObjectLiteral>(data: FiltersParseOutput, options?: QueryFiltersApplyOptions<T>): QueryFiltersOutput;
+/**
+ * Apply transformed filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */
+export declare function applyFiltersTransformed<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T> | WhereExpressionBuilder, data: QueryFiltersOutput): QueryFiltersOutput;
+/**
+ * Apply parsed filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQueryFiltersParseOutput<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T> | WhereExpressionBuilder, data: FiltersParseOutput, options?: QueryFiltersApplyOptions<T>): QueryFiltersApplyOutput;
+/**
+ * Apply raw filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQueryFilters<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryFiltersApplyOptions<T>): QueryFiltersApplyOutput;
+/**
+ * Apply raw filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyFilters<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryFiltersApplyOptions<T>): QueryFiltersApplyOutput;

package/dist/query/parameter/filters/type.d.ts

@@ -0,0 +1,12 @@
+import type { FiltersParseOptions, FiltersParseOutput } from 'rapiq';
+import type { ObjectLiteral } from 'typeorm';
+export type QueryFiltersApplyOptions<T extends ObjectLiteral = ObjectLiteral> = FiltersParseOptions<T> & {
+    bindingKey?: (key: string) => string;
+    defaultAlias?: string;
+};
+export type QueryFiltersApplyOutput = FiltersParseOutput;
+export type QueryFiltersOutputElement = {
+    statement: string;
+    binding: Record<string, any>;
+};
+export type QueryFiltersOutput = QueryFiltersOutputElement[];

package/dist/query/parameter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './fields';
+export * from './filters';
+export * from './pagination';
+export * from './relations';
+export * from './sort';

package/dist/query/parameter/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/query/parameter/pagination/module.d.ts

@@ -0,0 +1,26 @@
+import type { ObjectLiteral } from 'rapiq';
+import type { SelectQueryBuilder } from 'typeorm';
+import type { QueryPaginationApplyOptions, QueryPaginationApplyOutput } from './type';
+/**
+ * Apply parsed page/pagination parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */
+export declare function applyQueryPaginationParseOutput<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: QueryPaginationApplyOutput): import("rapiq").PaginationParseOutput;
+/**
+ * Apply raw page/pagination parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQueryPagination<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryPaginationApplyOptions): QueryPaginationApplyOutput;
+/**
+ * Apply raw page/pagination parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyPagination<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryPaginationApplyOptions): QueryPaginationApplyOutput;

package/dist/query/parameter/pagination/type.d.ts

@@ -0,0 +1,3 @@
+import type { PaginationParseOptions, PaginationParseOutput } from 'rapiq';
+export type QueryPaginationApplyOptions = PaginationParseOptions;
+export type QueryPaginationApplyOutput = PaginationParseOutput;

package/dist/query/parameter/relations/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/query/parameter/relations/module.d.ts

@@ -0,0 +1,27 @@
+import type { RelationsParseOutput } from 'rapiq';
+import type { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { QueryRelationsApplyOptions, QueryRelationsApplyOutput } from './type';
+/**
+ * Apply parsed include/relation parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQueryRelationsParseOutput<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: RelationsParseOutput, options?: QueryRelationsApplyOptions<T>): QueryRelationsApplyOutput;
+/**
+ * Apply raw include/relations parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQueryRelations<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryRelationsApplyOptions<T>): QueryRelationsApplyOutput;
+/**
+ * Apply raw include/relations parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyRelations<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QueryRelationsApplyOptions<T>): QueryRelationsApplyOutput;

package/dist/query/parameter/relations/type.d.ts

@@ -0,0 +1,8 @@
+import type { RelationsParseOptions, RelationsParseOutput } from 'rapiq';
+import type { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+export type QueryRelationsOnJoinFn<T extends ObjectLiteral = ObjectLiteral> = (property: string, alias: string, query: SelectQueryBuilder<T>) => void;
+export type QueryRelationsApplyOptions<T extends ObjectLiteral = ObjectLiteral> = RelationsParseOptions<T> & {
+    defaultAlias?: string;
+    onJoin?: QueryRelationsOnJoinFn<T>;
+};
+export type QueryRelationsApplyOutput = RelationsParseOutput;

package/dist/query/parameter/sort/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/query/parameter/sort/module.d.ts

@@ -0,0 +1,26 @@
+import type { SortParseOutput } from 'rapiq';
+import type { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { QuerySortApplyOptions, QuerySortApplyOutput } from './type';
+/**
+ * Apply parsed sort parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */
+export declare function applyQuerySortParseOutput<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: SortParseOutput): QuerySortApplyOutput;
+/**
+ * Apply raw sort parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applyQuerySort<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QuerySortApplyOptions<T>): SortParseOutput;
+/**
+ * Apply raw sort parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */
+export declare function applySort<T extends ObjectLiteral = ObjectLiteral>(query: SelectQueryBuilder<T>, data: unknown, options?: QuerySortApplyOptions<T>): SortParseOutput;

package/dist/query/parameter/sort/type.d.ts

@@ -0,0 +1,6 @@
+import type { SortParseOptions, SortParseOutput } from 'rapiq';
+import type { ObjectLiteral } from 'typeorm';
+export type QuerySortApplyOptions<T extends ObjectLiteral = ObjectLiteral> = SortParseOptions<T> & {
+    defaultAlias?: string;
+};
+export type QuerySortApplyOutput = SortParseOutput;

package/dist/query/type.d.ts

@@ -0,0 +1,16 @@
+import type { ParseOutput } from 'rapiq';
+import type { ObjectLiteral } from 'typeorm';
+import type { QueryFieldsApplyOptions, QueryFiltersApplyOptions, QueryPaginationApplyOptions, QueryRelationsApplyOptions, QuerySortApplyOptions } from './parameter';
+export type QueryApplyOptions<T extends ObjectLiteral = ObjectLiteral> = {
+    defaultPath?: string;
+    throwOnFailure?: boolean;
+    defaultAlias?: string;
+    fields?: boolean | QueryFieldsApplyOptions<T>;
+    filters?: boolean | QueryFiltersApplyOptions<T>;
+    pagination?: boolean | QueryPaginationApplyOptions;
+    relations?: boolean | QueryRelationsApplyOptions<T>;
+    sort?: boolean | QuerySortApplyOptions<T>;
+};
+export type QueryApplyOutput = ParseOutput & {
+    defaultAlias?: string;
+};

package/dist/query/utils/alias.d.ts

@@ -0,0 +1,2 @@
+import type { QueryRelationsApplyOutput } from '../parameter';
+export declare function getAliasForPath(items?: QueryRelationsApplyOutput, path?: string): string | undefined;

package/dist/query/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './alias';
+export * from './key';
+export * from './option';

package/dist/query/utils/key.d.ts

@@ -0,0 +1 @@
+export declare function buildKeyWithPrefix(name: string, prefix?: string): string;

package/dist/query/utils/option.d.ts

@@ -0,0 +1 @@
+export declare function isQueryOptionDefined(input: Record<string, any> | boolean, option: string | string[]): boolean;

package/dist/seeder/entity.d.ts

@@ -0,0 +1,42 @@
+import type { Seeder, SeederConstructor } from './type';
+export declare class SeederEntity {
+    /**
+     * ID of the seeder.
+     *
+     * Indicates order of the executed seeders.
+     */
+    id?: number;
+    /**
+     * Timestamp of the seeder.
+     */
+    timestamp: number;
+    /**
+     * Name of the seeder (class name).
+     */
+    name: string;
+    /**
+     * Instance of seeder constructor.
+     */
+    instance?: Seeder;
+    /**
+     * File name of the seeder.
+     */
+    fileName?: string;
+    /**
+     * File path of the seeder.
+     */
+    filePath?: string;
+    /**
+     * Result of the executed seeder.
+     */
+    result?: unknown;
+    constructor(ctx: {
+        id?: number;
+        timestamp: number;
+        name: string;
+        constructor?: SeederConstructor;
+        fileName?: string;
+        filePath?: string;
+    });
+    get trackExecution(): boolean | undefined;
+}

package/dist/seeder/executor.d.ts

@@ -0,0 +1,24 @@
+import type { DataSource, DataSourceOptions, QueryRunner } from 'typeorm';
+import { SeederEntity } from './entity';
+import type { SeederExecutorOptions, SeederOptions, SeederPrepareElement } from './type';
+export declare class SeederExecutor {
+    protected dataSource: DataSource;
+    protected options: SeederExecutorOptions;
+    private readonly tableName;
+    constructor(dataSource: DataSource, options?: SeederExecutorOptions);
+    execute(input?: SeederOptions): Promise<SeederEntity[]>;
+    protected loadExisting(queryRunner: QueryRunner): Promise<SeederEntity[]>;
+    /**
+     * Gets all migrations that setup for this connection.
+     */
+    protected buildEntities(seeds?: SeederPrepareElement[]): Promise<SeederEntity[]>;
+    protected checkForDuplicates(entities: SeederEntity[]): void;
+    protected createTableIfNotExist(queryRunner: QueryRunner): Promise<void>;
+    protected track(queryRunner: QueryRunner, seederEntity: SeederEntity): Promise<void>;
+    protected get dataSourceOptions(): DataSourceOptions & SeederOptions;
+    protected get database(): string | undefined;
+    protected get schema(): string | undefined;
+    protected get table(): string;
+    protected buildOptions(input?: SeederOptions): Promise<SeederOptions>;
+    protected classNameToTimestamp(className: string): number | undefined;
+}

package/dist/seeder/factory/index.d.ts

@@ -0,0 +1,4 @@
+export * from './manager';
+export * from './module';
+export * from './type';
+export * from './utils';

package/dist/seeder/factory/manager.d.ts

@@ -0,0 +1,8 @@
+import type { EntitySchema, ObjectType } from 'typeorm';
+import type { FactoryCallback, SeederFactoryItem } from './type';
+import { SeederFactory } from './module';
+export declare class SeederFactoryManager {
+    readonly items: Record<string, SeederFactoryItem>;
+    set<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>, factoryFn: FactoryCallback<O, Meta>): SeederFactoryItem;
+    get<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>): SeederFactory<O, Meta>;
+}

package/dist/seeder/factory/module.d.ts

@@ -0,0 +1,17 @@
+import type { Faker } from '@faker-js/faker';
+import type { SaveOptions } from 'typeorm';
+import type { SeederFactoryContext } from './type';
+export declare class SeederFactory<O extends Record<string, any>, Meta = unknown> {
+    readonly context: SeederFactoryContext<O, Meta>;
+    meta: Meta | undefined;
+    protected faker: Faker | undefined;
+    protected locale: string[] | undefined;
+    constructor(context: SeederFactoryContext<O, Meta>);
+    setMeta(value: Meta): this;
+    setLocale(value: string | string[]): void;
+    make(params?: Partial<O>, save?: boolean): Promise<O>;
+    save(params?: Partial<O>, options?: SaveOptions): Promise<O>;
+    saveMany(amount: number, params?: Partial<O>, options?: SaveOptions): Promise<O[]>;
+    private resolve;
+    protected useFaker(): Promise<Faker>;
+}

package/dist/seeder/factory/type.d.ts

@@ -0,0 +1,12 @@
+import type { Faker } from '@faker-js/faker';
+import type { EntitySchema, ObjectType } from 'typeorm';
+export type FactoryCallback<O, Meta = unknown> = (faker: Faker, meta: Meta) => O | Promise<O>;
+export type SeederFactoryItem = {
+    factoryFn: FactoryCallback<any, any>;
+    entity: ObjectType<any> | EntitySchema<any>;
+};
+export type SeederFactoryContext<O, Meta = unknown> = {
+    name: string;
+    entity: ObjectType<O> | EntitySchema<O>;
+    factoryFn: FactoryCallback<O, Meta | undefined>;
+};

package/dist/seeder/factory/utils.d.ts

@@ -0,0 +1,7 @@
+import type { EntitySchema, ObjectType } from 'typeorm';
+import { SeederFactoryManager } from './manager';
+import type { FactoryCallback, SeederFactoryItem } from './type';
+export declare function useSeederFactoryManager(): SeederFactoryManager;
+export declare function setSeederFactory<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>, factoryFn: FactoryCallback<O, Meta>): SeederFactoryItem;
+export declare function useSeederFactory<O extends Record<string, any>>(entity: ObjectType<O> | EntitySchema<O>): import("./module").SeederFactory<O, unknown>;
+export declare function prepareSeederFactories(items: SeederFactoryItem[] | string[], root?: string): Promise<void>;

package/dist/seeder/index.d.ts

@@ -0,0 +1,6 @@
+export * from './entity';
+export * from './executor';
+export * from './factory';
+export * from './module';
+export * from './utils';
+export * from './type';

package/dist/seeder/module.d.ts

@@ -0,0 +1,5 @@
+import type { DataSource } from 'typeorm';
+import type { SeederEntity } from './entity';
+import type { SeederConstructor, SeederOptions } from './type';
+export declare function runSeeder(dataSource: DataSource, seeder: SeederConstructor | string, options?: SeederOptions): Promise<SeederEntity | undefined>;
+export declare function runSeeders(dataSource: DataSource, options?: SeederOptions): Promise<SeederEntity[]>;

package/dist/seeder/type.d.ts

@@ -0,0 +1,44 @@
+import type { DataSource } from 'typeorm';
+import type { TSConfig } from '../utils/tsconfig';
+import type { SeederFactoryItem, SeederFactoryManager } from './factory';
+export interface Seeder {
+    /**
+     * Track seeder execution.
+     *
+     * Default: false
+     */
+    track?: boolean;
+    run(dataSource: DataSource, factoryManager: SeederFactoryManager): Promise<any>;
+}
+export type SeederConstructor = new () => Seeder;
+export type SeederOptions = {
+    seeds?: SeederConstructor[] | string[];
+    seedName?: string;
+    seedTableName?: string;
+    seedTracking?: boolean;
+    factories?: SeederFactoryItem[] | string[];
+    factoriesLoad?: boolean;
+};
+export type SeederExecutorOptions = {
+    /**
+     * Root directory of the project.
+     */
+    root?: string;
+    /**
+     * Directory path to the tsconfig.json file
+     *
+     * Default: process.cwd() + path.sep + tsconfig.json
+     */
+    tsconfig?: string | TSConfig;
+    /**
+     * This option indicates if file paths should be preserved,
+     * and treated as if the just-in-time compilation environment is detected.
+     */
+    preserveFilePaths?: boolean;
+};
+export type SeederPrepareElement = {
+    constructor: SeederConstructor;
+    timestamp?: number;
+    fileName?: string;
+    filePath?: string;
+};

package/dist/seeder/utils/file-path.d.ts

@@ -0,0 +1,7 @@
+import type { LocatorInfo } from 'locter';
+export declare function resolveFilePatterns(filesPattern: string[], root?: string): Promise<string[]>;
+export declare function resolveFilePaths(filePaths: string[], root?: string): string[];
+/**
+ * Exported only for testing purposes
+ */
+export declare function buildFilePathname(files: LocatorInfo[]): string[];

package/dist/seeder/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './file-path';
+export * from './prepare';
+export * from './template';

package/dist/seeder/utils/prepare.d.ts

@@ -0,0 +1,2 @@
+import type { SeederConstructor, SeederPrepareElement } from '../type';
+export declare function prepareSeederSeeds(input: SeederConstructor[] | string[], root?: string): Promise<SeederPrepareElement[]>;

package/dist/seeder/utils/template.d.ts

@@ -0,0 +1 @@
+export declare function buildSeederFileTemplate(name: string, timestamp: number): string;

package/dist/utils/code-transformation/constants.d.ts

@@ -0,0 +1,4 @@
+export declare enum CodeTransformation {
+    JUST_IN_TIME = "jit",
+    NONE = "none"
+}

package/dist/utils/code-transformation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './module';

package/dist/utils/code-transformation/module.d.ts

@@ -0,0 +1,3 @@
+import { CodeTransformation } from './constants';
+export declare function detectCodeTransformation(): `${CodeTransformation}`;
+export declare function isCodeTransformation(input: string): boolean;

package/dist/utils/entity.d.ts

@@ -0,0 +1,2 @@
+import type { EntitySchema, ObjectType } from 'typeorm';
+export declare function getEntityName<O>(entity: ObjectType<O> | EntitySchema<O>): string;

package/dist/utils/file-path.d.ts

@@ -0,0 +1,9 @@
+import type { TSConfig } from './tsconfig';
+export declare function transformFilePath(input: string, dist?: string, src?: string): string;
+export declare function adjustFilePath<T extends unknown | unknown[]>(input: T, tsconfig?: string | TSConfig): Promise<T>;
+export declare function adjustFilePaths<T extends Record<string, any>>(input: T, keys?: (keyof T)[], tsconfig?: string | TSConfig): Promise<T>;
+export declare function resolveFilePath(filePath: string, root?: string): string;
+export declare function parseFilePath(filePath: string, root?: string): {
+    directory: string;
+    name: string;
+};

package/dist/utils/file-system.d.ts

@@ -0,0 +1 @@
+export declare function isDirectory(input: string): Promise<boolean>;

package/dist/utils/has-property.d.ts

@@ -0,0 +1,2 @@
+export declare function hasOwnProperty<X extends Record<string, any>, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+export declare function hasStringProperty<X extends Record<string, any>, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, string>;

package/dist/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './code-transformation';
+export * from './entity';
+export * from './file-path';
+export * from './file-system';
+export * from './has-property';
+export * from './object';
+export * from './promise';
+export * from './separator';
+export * from './slash';
+export * from './tsconfig';

package/dist/utils/object.d.ts

@@ -0,0 +1,2 @@
+export declare function pickRecord(data: Record<string, any>, keys: string[]): Record<string, any>;
+export declare function extendObject<T extends Record<string, any>>(target: T, source: Partial<T>): T;

package/dist/utils/promise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(p: unknown): p is Promise<unknown>;

package/dist/utils/separator.d.ts

@@ -0,0 +1,3 @@
+export declare function canReplaceWindowsSeparator(input: string): boolean;
+export declare function replaceWindowSeparator(input: string): string;
+export declare function safeReplaceWindowsSeparator(input: string): string;

package/dist/utils/slash.d.ts

@@ -0,0 +1,2 @@
+export declare function hasTrailingSlash(input?: string, queryParams?: boolean): boolean;
+export declare function withoutTrailingSlash(input?: string, queryParams?: boolean): string;

package/dist/utils/tsconfig/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/utils/tsconfig/module.d.ts

@@ -0,0 +1,2 @@
+import type { TSConfig } from './type';
+export declare function readTSConfig(input?: string): Promise<TSConfig>;

package/dist/utils/tsconfig/type.d.ts

@@ -0,0 +1,13 @@
+import type { CompilerOptions, TypeAcquisition } from 'typescript';
+export type StripEnums<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any;
+};
+export interface TSConfig {
+    compilerOptions?: StripEnums<CompilerOptions>;
+    exclude?: string[];
+    compileOnSave?: boolean;
+    extends?: string;
+    files?: string[];
+    include?: string[];
+    typeAcquisition?: TypeAcquisition;
+}