@decohere/core 0.0.1-dev.116

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

@@ -0,0 +1,7 @@
+export type { Action, ActionClassMap, ActionOptions, Actions, MergeOptions, Result, ResultStatus, } from "./action.js";
+export { ActionMap, ActionResponse } from "./action.js";
+export type { CommandHandler, CommandType } from "./command.js";
+export { CommandError, CommandResponse, DecohereCommand } from "./command.js";
+export type { ApplicationModule, CommandMap as CommandClassMap, ModuleConfig, WorkspaceFactoryOptions, } from "./module.type.js";
+export { ModuleManifest } from "./module.type.js";
+export { ConfigFileOption, ConfigurationOption, DryRunOption, EnvFileIfExistsOption, EnvFileOption, LogLevelOption, NoBuildOptions, NoCleanOptions, ProjectOption, } from "./options.js";

package/types/src/cli/module.type.d.ts

@@ -0,0 +1,36 @@
+import type { ContainerBuilder } from "../composition/index.js";
+import type { ActionClassMap } from "./action.js";
+import type { CommandType, DecohereCommand } from "./command.js";
+export type CommandMap = Record<string, CommandType>;
+export type WorkspaceFactoryOptions = {
+    configFile?: string;
+    rootDir?: string;
+};
+export interface ApplicationModule {
+    id: string;
+    dispose?(): void;
+    asyncDispose?(): Promise<void>;
+    command: DecohereCommand;
+}
+export type ModuleConfig = {
+    actions?: ActionClassMap;
+    commands?: CommandMap;
+};
+/**
+ * Simple declaration interface for a CLI module.
+ * Extend this and implement the four abstract members.
+ */
+export declare abstract class ModuleManifest {
+    /** Unique module identifier, used as the root command name. */
+    abstract readonly id: string;
+    /** Sub-command classes this module contributes. */
+    readonly commands: CommandMap;
+    /** Action classes this module contributes. */
+    readonly actions: ActionClassMap;
+    /** The root command class for this module. */
+    abstract readonly command: CommandType;
+    /** Register infrastructure services into the DI container. */
+    registerServices(_builder: ContainerBuilder): void;
+    /** Lazily create a workspace instance. Return null if this module does not use a workspace. */
+    createWorkspace(_options: WorkspaceFactoryOptions): Promise<object | null>;
+}

package/types/src/cli/options.d.ts

@@ -0,0 +1,28 @@
+import { Option } from "commander";
+export declare class ConfigurationOption extends Option {
+    constructor(defaultValue: string);
+}
+export declare class ConfigFileOption extends Option {
+    constructor(defaultValue?: string);
+}
+export declare class LogLevelOption extends Option {
+    constructor();
+}
+export declare class EnvFileOption extends Option {
+    constructor();
+}
+export declare class EnvFileIfExistsOption extends Option {
+    constructor();
+}
+export declare class NoCleanOptions extends Option {
+    constructor(defaultValue: boolean);
+}
+export declare class NoBuildOptions extends Option {
+    constructor(defaultValue: boolean);
+}
+export declare class DryRunOption extends Option {
+    constructor(description: string, defaultValue?: boolean);
+}
+export declare class ProjectOption extends Option {
+    constructor();
+}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,2 @@
+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

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

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,10 @@
+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

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

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

@@ -0,0 +1 @@
+export { Trace, timed, trace } from "./trace.js";

package/types/src/diagnostics/trace.d.ts

@@ -0,0 +1,10 @@
+export declare function trace(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Always-on method timing. Logs duration at `info` regardless of `FORGE_TRACE`.
+ * Use this to time a specific method without raising the process log level.
+ */
+export declare function timed(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function Trace(constructor: {
+    name: string;
+    prototype: object;
+}): void;

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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,19 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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/extensibility/step.d.ts

@@ -0,0 +1,16 @@
+import type { Constructable } from "../reflection/index.js";
+import type { PipelineStep } from "./pipeline.js";
+/**
+ * Wraps a pipeline step with an optional `when` predicate.
+ * When `when` is provided, the step only runs if `when(ctx)` returns `true`.
+ * If `when` returns `false`, the pipeline logs `"Skipping step <name>"` and
+ * advances to the next step without invoking `run()`.
+ *
+ * Predicates are declared in the command constructor via `addDisableStepOption`,
+ * keeping skip conditions co-located with the option that controls them.
+ */
+export declare class Step<T extends Record<string, unknown> = Record<string, unknown>> {
+    readonly type: Constructable<PipelineStep<T>>;
+    readonly when?: (ctx: T) => boolean;
+    constructor(type: Constructable<PipelineStep<T>>, when?: (ctx: T) => boolean);
+}

package/types/src/interop/docker/docker.d.ts

@@ -0,0 +1,19 @@
+import { Shell } from "../shell/shell.js";
+export type DockerBuildOptions = {
+    cwd?: string;
+    dockerfile?: string;
+    tags?: string[];
+    buildArgs?: Record<string, string>;
+    secrets?: Record<string, string>;
+    noCache?: boolean;
+    pull?: boolean;
+};
+export type DockerPushOptions = {
+    cwd?: string;
+};
+export declare class Docker extends Shell {
+    readonly name: "docker";
+    protected program: string;
+    build(contextDir: string, options?: DockerBuildOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    push(tag: string, options?: DockerPushOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+}

package/types/src/interop/errors/interop.error.d.ts

@@ -0,0 +1,2 @@
+export declare class InteropError extends Error {
+}

package/types/src/interop/git/git.d.ts

@@ -0,0 +1,16 @@
+import { Shell } from "../shell/shell.js";
+import type { ShellResponse } from "../shell/shell.types.js";
+import type { CommitOptions, GitOptions, PushOptions, StageOptions } from "./git.types.js";
+export declare class Git extends Shell {
+    protected program: string;
+    getModifiedFiles(options?: GitOptions): Promise<string[]>;
+    getBranchName(options?: GitOptions): Promise<string>;
+    tag(tag: string, options?: GitOptions): Promise<ShellResponse>;
+    pushTag(tag: string, options?: GitOptions & {
+        remote?: string;
+    }): Promise<ShellResponse>;
+    commit(message: string, options: CommitOptions): Promise<ShellResponse>;
+    push(branch: string, options?: PushOptions): Promise<ShellResponse>;
+    pull(branch: string, options?: GitOptions): Promise<ShellResponse>;
+    stage(options: StageOptions): Promise<void>;
+}

package/types/src/interop/git/git.types.d.ts

@@ -0,0 +1,14 @@
+export type GitOptions = {
+    cwd?: string;
+};
+export type CommitOptions = {
+    files?: string[];
+    all?: boolean;
+} & GitOptions;
+export type PushOptions = {
+    setUpstream: string;
+} & GitOptions;
+export type StageOptions = {
+    files?: string[];
+    all?: string;
+};

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

@@ -0,0 +1,14 @@
+export * from "./docker/docker.js";
+export * from "./git/git.js";
+export * as git from "./git/git.types.js";
+export * from "./node/node.js";
+export * from "./npm/npm.js";
+export * as npm from "./npm/npm.types.js";
+export * from "./pnpm/pnpm.js";
+export * as pnpm from "./pnpm/pnpm.types.js";
+export * from "./shell/shell.js";
+export * as shell from "./shell/shell.types.js";
+export * from "./types/detect-package-manager.js";
+export * from "./types/package-manager.js";
+export * from "./yarn/yarn.js";
+export * as yarn from "./yarn/yarn.types.js";

package/types/src/interop/node/index.d.ts

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

package/types/src/interop/node/node.d.ts

@@ -0,0 +1,5 @@
+import { Shell } from "../shell/shell.js";
+export declare class Node extends Shell {
+    protected program: string;
+    runScript(script: string, ...args: string[]): Promise<unknown>;
+}

package/types/src/interop/npm/npm.d.ts

@@ -0,0 +1,29 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { NpmOptions, PublishOptions, VersionOptions, VersionType } from "./npm.types.js";
+export declare class Npm extends Shell implements PackageManager {
+    readonly name: "npm";
+    protected program: string;
+    publish(directory: string, options?: PublishOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    /**
+     * @description Runs in the directory of the package
+     * @param options
+     * @returns
+     */
+    version(versionType: VersionType, options: VersionOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    link(directory: string, options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    install(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    /**
+     * Install only `dependencies` as real folders: `--omit=dev` skips devDependencies and
+     * `--no-bin-links` skips the `.bin` symlinks, so the result holds no symlinks at all.
+     */
+    installProduction(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    syncLockFile(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    /**
+     * True when package@version exists on the registry.
+     * Uses ambient npm config (cwd `.npmrc`); do not pass tokens on argv.
+     */
+    private isPublished;
+    private createTempUserConfig;
+    private removeTempUserConfig;
+}

package/types/src/interop/npm/npm.types.d.ts

@@ -0,0 +1,24 @@
+export type NpmOptions = {
+    cwd?: string;
+};
+export type PublishOptions = {
+    dryRun?: boolean;
+    skipIfPublished?: boolean;
+    authToken?: string;
+    otp?: string;
+    provenance?: boolean;
+    /** @deprecated use channel */
+    versionType?: VersionType;
+    channel?: string;
+} & NpmOptions;
+export type VersionType = "major" | "minor" | "patch" | "prerelease";
+export declare const VersionTypes: {
+    major: "major";
+    minor: "minor";
+    patch: "patch";
+    prerelease: "prerelease";
+};
+export type VersionOptions = {
+    preid?: string;
+    noTag?: boolean;
+} & NpmOptions;

package/types/src/interop/pnpm/pnpm.d.ts

@@ -0,0 +1,9 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { PnpmOptions } from "./pnpm.types.js";
+export declare class Pnpm extends Shell implements PackageManager {
+    readonly name: "pnpm";
+    protected program: string;
+    install(options?: PnpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    syncLockFile(options?: PnpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+}

package/types/src/interop/pnpm/pnpm.types.d.ts

@@ -0,0 +1,3 @@
+export type PnpmOptions = {
+    cwd?: string;
+};

package/types/src/interop/shell/shell.argv.d.ts

@@ -0,0 +1,5 @@
+declare function fields(args: string[]): Record<string, string | boolean | string[]>;
+export declare const shellArgv: {
+    fields: typeof fields;
+};
+export {};

package/types/src/interop/shell/shell.d.ts

@@ -0,0 +1,6 @@
+import type { ShellOptions, ShellResponse } from "./shell.types.js";
+export declare abstract class Shell {
+    protected abstract program: string;
+    protected run(options: ShellOptions, ...args: string[]): Promise<ShellResponse>;
+    private parseStream;
+}

package/types/src/interop/shell/shell.types.d.ts

@@ -0,0 +1,9 @@
+export type ShellResponse = {
+    message: string;
+    data: string[];
+};
+export interface ShellOptions {
+    cwd?: string;
+    /** Spawn env. Defaults to `process.env`. Not written to logs. */
+    env?: NodeJS.ProcessEnv;
+}

package/types/src/interop/types/detect-package-manager.d.ts

@@ -0,0 +1,4 @@
+import type { PackageManager } from "./package-manager.js";
+export declare function detectPackageManager(cwd: string): PackageManager | undefined;
+export declare function packageManagerFromString(name: string): PackageManager;
+export declare function promptForPackageManager(): Promise<PackageManager>;

package/types/src/interop/types/package-manager.d.ts

@@ -0,0 +1,10 @@
+import type { ShellResponse } from "../shell/shell.types.js";
+export interface PackageManager {
+    readonly name: "npm" | "pnpm" | "yarn";
+    install(options?: {
+        cwd?: string;
+    }): Promise<ShellResponse>;
+    syncLockFile(options?: {
+        cwd?: string;
+    }): Promise<ShellResponse>;
+}

package/types/src/interop/yarn/yarn.d.ts

@@ -0,0 +1,9 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { YarnOptions } from "./yarn.types.js";
+export declare class Yarn extends Shell implements PackageManager {
+    readonly name: "yarn";
+    protected program: string;
+    install(options?: YarnOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    syncLockFile(options?: YarnOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+}

package/types/src/interop/yarn/yarn.types.d.ts

@@ -0,0 +1,3 @@
+export type YarnOptions = {
+    cwd?: string;
+};

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

@@ -0,0 +1,4 @@
+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

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

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

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

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

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

package/types/src/io/find-directories.d.ts

@@ -0,0 +1,2 @@
+import type { Directory } from "./types/directory.type.js";
+export declare function findDirectories(...pattern: string[]): Promise<Directory[]>;

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

@@ -0,0 +1,9 @@
+import { FileEx } from "./types/file.js";
+export type FindFileOptions = {
+    cwd: string;
+    ignore?: string | string[];
+};
+export declare function findFile(pattern: string): Promise<{
+    relativePath: string;
+}>;
+export declare function findFiles(patterns: string[], options?: FindFileOptions): Promise<FileEx[]>;

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

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

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

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

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

@@ -0,0 +1,4 @@
+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

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

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

@@ -0,0 +1,4 @@
+export type Directory = {
+    name: string;
+    parentPath: string;
+};

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

@@ -0,0 +1,20 @@
+export type File = {
+    fullPath: string;
+    relativePath: string;
+};
+export declare class FileEx implements File {
+    #private;
+    constructor(data: Partial<File> & {
+        content?: string;
+    });
+    fullPath: string;
+    relativePath: string;
+    toString(): string;
+    getContent(): Promise<string>;
+}
+export type Watcher = {
+    readonly ready: Promise<void>;
+    on(event: "ready", handler: () => unknown): Watcher;
+    on(event: "add" | "change" | "addDir" | "unlink" | "unlinkDir", handler: (file: File) => unknown): Watcher;
+    close(): void;
+};

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

@@ -0,0 +1,2 @@
+export * from "./directory.type.js";
+export * from "./file.js";

package/types/src/io/url-to-path.d.ts

@@ -0,0 +1,2 @@
+export declare const fileUrlToPath: (url: string) => string;
+export declare const pathToFileUrl: (path: string) => string;

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

@@ -0,0 +1,16 @@
+import { type Watcher } from "./types/file.js";
+export type WatchOptions = {
+    include?: string[];
+    ignore?: string[];
+    cwd?: string;
+    ignoreInitial?: boolean;
+};
+export type WatchEventName = "add" | "change" | "addDir" | "unlink" | "unlinkDir";
+export declare const WatchEvents: {
+    add: "add";
+    change: "change";
+    addDir: "addDir";
+    unlink: "unlink";
+    unlinkDir: "unlinkDir";
+};
+export declare function watch(directory: string, options?: WatchOptions): Watcher;

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

@@ -0,0 +1,5 @@
+export type WriteFileOptions = {
+    mkdir?: boolean;
+    encoding?: BufferEncoding;
+};
+export declare function writeFile(filePath: string, content: string, options?: WriteFileOptions): Promise<void>;