@decohere/core 0.0.1-dev.125 → 0.0.1-dev.5

package/es6/src/objects/deep-merge.js

@@ -1,57 +0,0 @@
-// Source https://github.com/voodoocreation/ts-deepmerge/blob/master/package.json
-// istanbul ignore next
-const isObject = (obj)=>{
-    if (typeof obj === "object" && obj !== null) {
-        if (typeof Object.getPrototypeOf === "function") {
-            const prototype = Object.getPrototypeOf(obj);
-            return prototype === Object.prototype || prototype === null;
-        }
-        return Object.prototype.toString.call(obj) === "[object Object]";
-    }
-    return false;
-};
-export const merge = (...objects)=>objects.reduce((result, current)=>{
-        if (current === undefined) {
-            return result;
-        }
-        if (Array.isArray(current)) {
-            throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
-        }
-        Object.keys(current).forEach((key)=>{
-            if ([
-                "__proto__",
-                "constructor",
-                "prototype"
-            ].includes(key)) {
-                return;
-            }
-            if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-                result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [
-                    ...result[key],
-                    ...current[key]
-                ] : current[key];
-            } else if (isObject(result[key]) && isObject(current[key])) {
-                result[key] = merge(result[key], current[key]);
-            } else if (!isObject(result[key]) && isObject(current[key])) {
-                result[key] = merge(current[key], undefined);
-            } else {
-                result[key] = current[key] === undefined ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
-            }
-        });
-        return result;
-    }, {});
-const defaultOptions = {
-    allowUndefinedOverrides: true,
-    mergeArrays: true,
-    uniqueArrayItems: true
-};
-merge.options = defaultOptions;
-merge.withOptions = (options, ...objects)=>{
-    merge.options = {
-        ...defaultOptions,
-        ...options
-    };
-    const result = merge(...objects);
-    merge.options = defaultOptions;
-    return result;
-};

package/es6/src/reflection/types/reflection.types.js

@@ -1,8 +0,0 @@
-export const MetaDataOwners = {
-    Hearth: "hearth",
-    Reflect: "design"
-};
-export const ReflectionMeta = {
-    paramtypes: `${MetaDataOwners.Reflect}:paramtypes`,
-    type: `${MetaDataOwners.Reflect}:type`
-};

package/es6/src/reflection/utilities.js

@@ -1,74 +0,0 @@
-import { ReflectionMeta } from "./types/reflection.types.js";
-const Primitives = [
-    "string",
-    "number",
-    "bigint",
-    "boolean",
-    "undefined",
-    "symbol",
-    "null"
-];
-export const isPrimitiveOrDateType = (type)=>{
-    return Primitives.includes(type.name.toLocaleLowerCase()) || isDateType(type);
-};
-export const isDateType = (type)=>{
-    return type?.prototype === Date.prototype;
-};
-export function isConstructable(type) {
-    const proto = type?.prototype;
-    const isConstructable = typeof type === "function" && typeof proto === "object";
-    return isConstructable;
-}
-export const isArrayType = (type)=>{
-    return type?.prototype === Array.prototype;
-};
-export function getMeta(key, target, propertyKey) {
-    const meta = Reflect.getMetadata(key, target, propertyKey);
-    return meta;
-}
-export function getFunctions(object) {
-    const functions = Object.entries(Object.getOwnPropertyDescriptors(object.prototype)).filter(([key])=>key !== "constructor").map(([, value])=>value);
-    return functions;
-}
-export function getFunction(object, functionName) {
-    const [, value] = Object.entries(Object.getOwnPropertyDescriptors(object.prototype)).find(([k])=>k !== "constructor" && k === functionName);
-    return value;
-}
-export function getFunctionMetadata(key, target, func) {
-    const meta = Reflect.getMetadata(key, target, func.name);
-    return meta;
-}
-export function getFunctionArgs(target, func) {
-    const meta = getFunctionMetadata(ReflectionMeta.paramtypes, target, func);
-    return meta;
-}
-/**
- * @description Gets the fields from an object
- * @param object
- * @returns
- */ export function getFields(object) {
-    const fields = Object.entries(Object.getOwnPropertyDescriptors(object)).filter(([, val])=>typeof val.value !== "function").map(([key, propertyDescriptor])=>({
-            key,
-            propertyDescriptor
-        }));
-    return fields;
-}
-export function getFieldType(target, fieldName) {
-    return Reflect.getMetadata(ReflectionMeta.type, target, fieldName);
-}
-export function getArgumentMeta(key, target, argIndex) {
-    const meta = Reflect.getMetadata(key, target, argIndex.toString());
-    return meta;
-}
-export function defineMeta(key, value, target) {
-    Reflect.defineMetadata(key, value, target);
-}
-/**
- * @description Facade function to define metadata for a function argument
- * @param key
- * @param value
- * @param func
- * @param argIndex
- */ export function defineArgumentMeta(key, value, func, argIndex) {
-    Reflect.defineMetadata(key, value, func, argIndex.toString());
-}

package/es6/src/system/camel-case.js

@@ -1,3 +0,0 @@
-export function lowerCamelCase(val) {
-    return String(val).charAt(0).toLowerCase() + String(val).slice(1);
-}

package/es6/src/system/debounce.js

@@ -1,9 +0,0 @@
-export function debounce(callback, delay) {
-    let timeoutTimer;
-    return (...args)=>{
-        clearTimeout(timeoutTimer);
-        timeoutTimer = setTimeout(async ()=>{
-            await callback(...args);
-        }, delay);
-    };
-}

package/es6/src/system/decorator.js

@@ -1,30 +0,0 @@
-export class FunctionDecorator {
-    options;
-    constructor(){
-        this.decoratorFactory = this.decoratorFactory.bind(this);
-    }
-    decoratorFactory(options) {
-        this.options = options;
-        return this.decorator.bind(this);
-    }
-}
-/**
- * Skips the decorated method decorator if any of the named environment variables equal "true".
- * Useful for disabling decorators like @cache() during unit tests or via feature flags.
- *
- * @example @ignoreIf("TEST", "DISABLE_CACHE")
- */ export function ignoreIf(...envVars) {
-    return (_, __, descriptor)=>{
-        const originalFunction = descriptor.value;
-        descriptor.value = function(target, key, descriptor) {
-            if (envVars.some((v)=>process.env[v] === "true")) {
-                return descriptor;
-            }
-            return originalFunction.bind(this)(target, key, descriptor);
-        };
-        return descriptor;
-    };
-}
-/** @deprecated Use ignoreIf("TEST") instead */ export function ignoreDuringUnitTest() {
-    return ignoreIf("TEST");
-}

package/es6/src/system/environment.js

@@ -1,5 +0,0 @@
-export const Environments = {
-    production: "production",
-    development: "development"
-};
-export const DefaultEnvironment = Environments.development;

package/es6/src/system/function.types.js

@@ -1,26 +0,0 @@
-/**
- * Generic function type that can replace arrow function signatures.
- *
- * @example
- * ```typescript
- * // Instead of: (arg1: string, arg2: number) => boolean
- * type MyCallback = Func<[string, number], boolean>;
- *
- * // Instead of: (data: any) => void
- * type MyHandler = Func<[any], void>;
- *
- * // Instead of: () => Promise<string>
- * type MyAsyncFunc = Func<[], Promise<string>>;
- * ```
- */ /**
- * Action function type that returns void.
- *
- * @example
- * ```typescript
- * // Instead of: (event: Event) => void
- * type EventHandler = Action<[Event]>;
- *
- * // Instead of: () => void
- * type Callback = Action<[]>;
- * ```
- */ export { };

package/es6/src/system/retry.decorator.js

@@ -1,30 +0,0 @@
-import { FunctionDecorator } from "./decorator.js";
-import { sleep } from "./sleep.js";
-class RetryDecorator extends FunctionDecorator {
-    decorator(_target, _propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const attempts = Math.max(1, this.options?.attempts ?? 3);
-        const delayMs = Math.max(0, this.options?.delayMs ?? 0);
-        const shouldRetry = this.options?.shouldRetry ?? (()=>true);
-        descriptor.value = async function(...args) {
-            let lastError;
-            for(let attempt = 1; attempt <= attempts; attempt++){
-                try {
-                    return await Promise.resolve(originalMethod.apply(this, args));
-                } catch (error) {
-                    lastError = error;
-                    const shouldAttemptAgain = attempt < attempts && shouldRetry(error);
-                    if (!shouldAttemptAgain) {
-                        throw error;
-                    }
-                    if (delayMs > 0) {
-                        await sleep(delayMs);
-                    }
-                }
-            }
-            throw lastError;
-        };
-        return descriptor;
-    }
-}
-export const retry = new RetryDecorator().decoratorFactory;

package/es6/src/system/sleep.js

@@ -1,3 +0,0 @@
-export const sleep = (ms)=>new Promise((resolve)=>setTimeout(()=>{
-            resolve(null);
-        }, ms));

package/es6/src/system/type.utils.js

@@ -1 +0,0 @@
-export { };

package/types/src/caching/cache-manager.d.ts

@@ -1,59 +0,0 @@
-import type { ICache } from "./cache.js";
-export declare const Caches: {
-    readonly default: "DEFAULT";
-    readonly memoize: "MEMOIZE_CACHE";
-};
-/**
- * Central cache manager for managing named cache instances
- */
-declare class CacheManager {
-    private caches;
-    private readonly defaultCacheName;
-    /**
-     * Set a cache instance with the given name
-     * @param name - The name of the cache
-     * @param cache - The cache instance
-     */
-    setCache(name: string, cache: ICache): void;
-    /**
-     * Get a cache instance by name
-     * @param name - The name of the cache, defaults to "DEFAULT"
-     * @returns The cache instance
-     */
-    getCache(name?: string, memoize?: boolean): ICache;
-    /**
-     * Clear a cache by name. If no name is provided, clears the default cache.
-     * Note: This only works if the cache implements a clear() method.
-     * @param name - The name of the cache to clear
-     */
-    flush(name?: string): void;
-    flushAllCaches(): void;
-    /**
-     * Remove a cache instance by name
-     * @param name - The name of the cache to remove
-     */
-    removeCache(name: string): void;
-    /**
-     * Check if a cache with the given name exists
-     * @param name - The name of the cache
-     * @returns True if the cache exists, false otherwise
-     */
-    hasCache(name: string): boolean;
-    private readonly instanceIds;
-    private instanceIdCounter;
-    /**
-     * Generate a cache key for a given instance, function name, and arguments.
-     * Each instance receives a stable numeric ID so cache entries are never
-     * shared across instances of the same class.
-     * @param instance - The class instance (`this` at call time)
-     * @param functionName - The name of the decorated method
-     * @param args - The method arguments
-     * @returns A unique cache key string
-     */
-    generateCacheKey(instance: object, functionName: string, args: unknown[]): string;
-}
-/**
- * Singleton instance of the cache manager
- */
-export declare const Caching: CacheManager;
-export {};

package/types/src/caching/cache.d.ts

@@ -1,11 +0,0 @@
-/**
- * Interface for cache implementations used by the @cache() decorator
- */
-export interface ICache {
-    get(key: string): unknown;
-    set(key: string, value: unknown): void;
-    has(key: string): boolean;
-    del(key: string): void;
-    flushAll(): any;
-    get isMemoize(): boolean;
-}

package/types/src/caching/cache.decorator.d.ts

@@ -1,18 +0,0 @@
-import { FunctionDecorator } from "../system/decorator.js";
-import type { ICache } from "./cache.js";
-/**
- * Options for configuring the @cache() decorator
- */
-export interface CacheOptions {
-    cache?: ICache;
-    name?: string;
-    /**
-     * Custom key function. When provided, replaces the default instance-scoped key
-     * with a caller-defined key, enabling cross-instance cache sharing.
-     */
-    keyFn?: (...args: unknown[]) => string;
-}
-export declare class CacheDecorator extends FunctionDecorator<CacheOptions> {
-    decorator(_target: object, propertyKey: string, descriptor: PropertyDescriptor): void;
-}
-export declare const cache: (options?: CacheOptions) => any;

package/types/src/caching/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./cache.decorator.js";
-export * from "./cache.js";
-export * from "./cache-manager.js";
-export * from "./invalidate-cache.decorator.js";
-export * from "./memoize.decorator.js";
-export * from "./map-cache.js";

package/types/src/caching/invalidate-cache.decorator.d.ts

@@ -1,17 +0,0 @@
-import { FunctionDecorator } from "../system/decorator.js";
-import type { CacheOptions } from "./cache.decorator.js";
-type InvalidateCacheOptions = CacheOptions & {
-    getKey: (instance: object, args: unknown[]) => string;
-};
-export declare class InvalidateCacheDecorator extends FunctionDecorator<InvalidateCacheOptions> {
-    decorator(_target: object, _propertyKey: string, descriptor: PropertyDescriptor): void;
-}
-export declare const invalidateCache: {
-    (method: string | ((...args: never[]) => unknown), options?: CacheOptions): any;
-    evict(instance: object, method: (...args: never[]) => unknown, args?: unknown[]): void;
-};
-export declare const invalidateMemoize: {
-    (method: string | ((...args: never[]) => unknown), options?: CacheOptions): any;
-    evict(instance: object, method: (...args: never[]) => unknown, args?: unknown[]): void;
-};
-export {};

package/types/src/caching/map-cache.d.ts

@@ -1,23 +0,0 @@
-import type { ICache } from "./cache.js";
-type MapCacheOptions = {
-    /** Hand out the stored reference instead of a copy (what `@memoize` needs). */
-    memoize?: boolean;
-};
-/**
- * The built-in cache: a plain `Map`, no expiry.
- *
- * By default `get` returns a `structuredClone` of an object, so a caller that changes what it
- * got back can't change the cached value. With `memoize` it returns the stored reference.
- * Scalars, `null` and `undefined` are returned as they are.
- */
-export declare class MapCache implements ICache {
-    #private;
-    constructor(options?: MapCacheOptions);
-    get isMemoize(): boolean;
-    get(key: string): unknown;
-    set(key: string, value: unknown): void;
-    has(key: string): boolean;
-    del(key: string): void;
-    flushAll(): void;
-}
-export {};

package/types/src/caching/memoize.decorator.d.ts

@@ -1,16 +0,0 @@
-import { CacheDecorator } from "./cache.decorator.js";
-/**
- * Memoize decorator class that extends CacheDecorator with memoization support
- * Automatically uses a memoization-capable cache (a MapCache that hands out references)
- */
-export declare class MemoizeDecorator extends CacheDecorator {
-    decorator(target: object, propertyKey: string, descriptor: PropertyDescriptor): void;
-}
-/**
- * Memoize decorator factory
- * Provides true memoization by storing object references instead of clones
- *
- * @param options - Optional configuration for the memoize decorator
- * @returns Decorator function
- */
-export declare const memoize: (options?: import("./cache.decorator.js").CacheOptions) => any;

package/types/src/collections/collections.d.ts

@@ -1,4 +0,0 @@
-export * from "./find-duplicates.js";
-export * from "./merge-arrays.js";
-export * from "./sum.js";
-export * from "./unique-objects.js";

package/types/src/collections/find-duplicates.d.ts

@@ -1,2 +0,0 @@
-export declare function findDuplicatesByKey<T>(items: T[], key: keyof T): [string, T[]][];
-export declare function findDuplicatesBy<T>(items: T[], selector: (item: T) => string): [string, T[]][];

package/types/src/collections/index.d.ts

@@ -1 +0,0 @@
-export * as collections from "./collections.js";

package/types/src/collections/merge-arrays.d.ts

@@ -1,2 +0,0 @@
-export declare function mergeByKey<T>(first: T[], second: T[], key: keyof T): T[];
-export declare function mergeBy<T>(first: T[], second: T[], selector: (item: T) => string): T[];

package/types/src/collections/sum.d.ts

@@ -1,4 +0,0 @@
-export declare function sumByKey<T>(objects: T[], key: keyof T): number;
-export declare function sumByKey<T>(objects: T[], key: keyof T): bigint;
-export declare function sumBy<T>(objects: T[], key: (obj: T) => number): number;
-export declare function sumBy<T>(objects: T[], key: (obj: T) => bigint): bigint;

package/types/src/collections/unique-objects.d.ts

@@ -1,2 +0,0 @@
-export declare function uniqueObjectsByKey<T>(objects: T[], key: keyof T): T[];
-export declare function uniqueObjectsBy<T>(objects: T[], key: (obj: T) => string): T[];

package/types/src/composition/index.d.ts

@@ -1,37 +0,0 @@
-import type { Constructable } from "../reflection/index.js";
-export type ResolveRequest<T extends object = object> = string | symbol | Constructable<T>;
-export type Scope = "single-instance" | "request" | "transient";
-export interface ServiceProvider {
-    /**
-     * @param key
-     * @throws {ServiceNotFoundException}
-     */
-    resolve<T extends object>(key: ResolveRequest<T>): T;
-    resolveMany<T extends object = object>(resolveRequest: ResolveRequest<T>): T[];
-}
-export interface LifetimeScope extends ServiceProvider {
-    /** A name must be unique among open scopes; omit it for per-request scopes. */
-    beginScope(name?: string): LifetimeScope;
-    [Symbol.dispose](): void;
-    [Symbol.asyncDispose](): Promise<void>;
-}
-export interface IContainer extends LifetimeScope {
-}
-export interface ContainerRegistrar {
-    registerTransient(key: string | symbol, type: Constructable): unknown;
-    registerTransient(type: Constructable): unknown;
-    registerRequestScoped<T>(type: () => T): unknown;
-    registerRequestScoped<T>(key: string | symbol, type: () => T): unknown;
-    registerRequestScoped(key: string | symbol, type: Constructable): unknown;
-    registerRequestScoped(type: Constructable): unknown;
-    registerSingleton(key: string | symbol | Constructable, instance: object): unknown;
-    registerSingleton(key: string | symbol, type: Constructable): unknown;
-    registerSingleton(type: Constructable): unknown;
-    registerType(type: Constructable, scope?: Scope): unknown;
-    registerTypes(...types: Constructable[]): unknown[];
-    registerTypes(scope: Scope, ...types: Constructable[]): unknown[];
-}
-export interface ContainerBuilder extends ContainerRegistrar {
-    readonly override: ContainerRegistrar;
-    build(): IContainer;
-}

package/types/src/configuration/configuration.types.d.ts

@@ -1,10 +0,0 @@
-import type { Constructable } from "../reflection/index.js";
-export declare const ConfigurationServiceToken: unique symbol;
-export interface IConfigurationService {
-    readonly dataSources: readonly IConfigurationDataSource[];
-    get<T extends object>(typeOrString: Constructable<T> | string): Promise<T>;
-}
-export interface IConfigurationDataSource {
-    readonly name: string;
-    getData(): Promise<Record<string, unknown>>;
-}

package/types/src/configuration/index.d.ts

@@ -1 +0,0 @@
-export * from "./configuration.types.js";

package/types/src/extensibility/decorator-factory-base.d.ts

@@ -1,39 +0,0 @@
-import type { FunctionDecorator } from "./decorator-factory.js";
-/**
- * Base class for creating decorator factory instances with methods that can be
- * conditionally disabled during unit testing.
- *
- * Example usage:
- * ```typescript
- * class MyDecoratorFactory extends DecoratorFactory {
- *   @ignoreInUnitTest
- *   cache(options?: CacheOptions) {
- *     return cache(options);
- *   }
- *
- *   @ignoreInUnitTest
- *   logger(options?: LoggerOptions) {
- *     return logger(options);
- *   }
- * }
- *
- * const decorators = new MyDecoratorFactory();
- *
- * class TestClass {
- *   @decorators.cache({ ttl: 1000 })
- *   async getData() {
- *     // This decorator will be disabled when TEST=true
- *   }
- * }
- * ```
- */
-export declare abstract class DecoratorFactoryBase {
-    /**
-     * Utility method to check if we're currently in a test environment
-     */
-    protected isTestEnvironment(): boolean;
-    /**
-     * Creates a no-op decorator that returns the original function unchanged
-     */
-    protected createNoOpDecorator(): FunctionDecorator;
-}

package/types/src/extensibility/decorator-factory.d.ts

@@ -1,19 +0,0 @@
-/**
- * Decorator factory class that provides decorator methods which can be conditionally
- * disabled during unit testing using the @ignoreInUnitTest decorator.
- *
- * Inspired by: https://jasonharper.blog/2018/03/13/decorate-the-decorator-to-exclude-in-unit-testing/
- */
-/**
- * Decorator that disables the decorated decorator method when TEST environment variable is true.
- * If TEST=true, it returns a no-op decorator that simply returns the original function unchanged.
- */
-export declare function ignoreInUnitTest(_target: object, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
-/**
- * Type definition for a function decorator
- */
-export type FunctionDecorator = (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor | undefined;
-/**
- * Type definition for a decorator factory function (returns a decorator)
- */
-export type DecoratorFactory<TOptions = unknown> = (options?: TOptions) => FunctionDecorator;

package/types/src/extensibility/extension.d.ts

@@ -1,9 +0,0 @@
-import type { Type } from "../reflection/types/reflection.types.js";
-export type ExtensionOptions = {
-    /**
-     * Also install the method on the constructor. Use for singleton facades
-     * (`scribe.withPinoPretty()`) whose instance lives at `ctor.instance`.
-     */
-    static?: boolean;
-};
-export declare function extension(ctor: Type, options?: ExtensionOptions): (_target: object, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/types/src/extensibility/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./decorator-factory.js";
-export * from "./decorator-factory-base.js";
-export * from "./extension.js";
-export * from "./mixwith.js";
-export * from "./pipeline.js";
-export * from "./step.js";

package/types/src/extensibility/mixwith.d.ts

@@ -1,6 +0,0 @@
-type Constructor<T = object> = abstract new (...args: unknown[]) => T;
-type UnionToIntersection<T> = (T extends unknown ? (arg: T) => void : never) extends (arg: infer TResult) => void ? TResult : never;
-type MixedInstance<TMixins extends readonly Constructor[]> = UnionToIntersection<InstanceType<TMixins[number]>>;
-type MixedClass<TMixins extends readonly Constructor[]> = abstract new (...args: unknown[]) => MixedInstance<TMixins>;
-export declare function mixwith<TMixins extends readonly Constructor[]>(...mixins: TMixins): MixedClass<TMixins>;
-export {};

package/types/src/extensibility/pipeline.d.ts

@@ -1,12 +0,0 @@
-export interface PipelineStep<TContext extends Record<string, unknown> = Record<string, unknown>> {
-    run(ctx: TContext, next: Next): Promise<void> | void;
-}
-export type Next = () => Promise<void> | void;
-export declare class Pipeline<T extends Record<string, unknown>> {
-    private readonly stack;
-    private readonly logger;
-    private currentStep;
-    constructor(...steps: [string, PipelineStep<T>, ((ctx: T) => boolean)?][]);
-    [Symbol.dispose](): void;
-    start(context: T): Promise<void>;
-}

package/types/src/io/copy-file.d.ts

@@ -1,4 +0,0 @@
-export type CopyFileOptions = {
-    mkdir?: boolean;
-};
-export declare function copyFile(src: string, dest: string, options?: CopyFileOptions): Promise<void>;

package/types/src/io/delete-file.d.ts

@@ -1 +0,0 @@
-export declare function deleteFile(filePath: string): Promise<void>;

package/types/src/io/directory-exists.d.ts

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

package/types/src/io/file-exists.d.ts

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

package/types/src/io/index.d.ts

@@ -1,2 +0,0 @@
-export * as io from "./io.js";
-export * from "./types/index.js";

package/types/src/io/io.d.ts

@@ -1,8 +0,0 @@
-export * from "./copy-file.js";
-export * from "./delete-file.js";
-export * from "./directory-exists.js";
-export * from "./file-exists.js";
-export * from "./read-file.js";
-export * from "./remove-dir.js";
-export * from "./url-to-path.js";
-export * from "./write-file.js";

package/types/src/io/read-file.d.ts

@@ -1,4 +0,0 @@
-import type { File } from "./types/file.js";
-export declare function readFiles(filePaths: File[], encoding?: BufferEncoding): Promise<string[]>;
-export declare function readFile(filePath: string, encoding?: BufferEncoding): Promise<string>;
-export declare function readJsonFile<T>(filePath: string, encoding?: BufferEncoding): Promise<T>;

package/types/src/io/remove-dir.d.ts

@@ -1,5 +0,0 @@
-export type RemoveDirOptions = {
-    force: boolean;
-    recursive: boolean;
-};
-export declare function removeDir(path: string, options?: RemoveDirOptions): Promise<void>;