@reliverse/relifso 1.4.4 → 2.2.7

package/dist/copy.d.ts

@@ -0,0 +1,3 @@
+import type { CopyOptions, MoveOptions, PathLike } from "./types.js";
+export declare const copy: (from: PathLike, to: PathLike, options?: CopyOptions) => Promise<void>;
+export declare const move: (from: PathLike, to: PathLike, options?: MoveOptions) => Promise<void>;

package/dist/copy.js

@@ -0,0 +1,95 @@
+import { dirname, join } from "node:path";
+import { ensureDir, pathExists, remove } from "./dir.js";
+import {
+  fsLStat,
+  fsReaddir,
+  fsReadlink,
+  fsRename,
+  fsStat,
+  fsSymlink
+} from "./internal/fs.js";
+import { toPathString } from "./internal/path.js";
+const shouldCopyEntry = async (path, filter) => {
+  if (!filter) {
+    return true;
+  }
+  const result = filter(path);
+  if (result instanceof Promise) {
+    return result;
+  }
+  return result;
+};
+const copyFile = async (source, destination, overwrite) => {
+  await ensureDir(dirname(destination));
+  if (!overwrite && await pathExists(destination)) {
+    return;
+  }
+  await Bun.write(destination, Bun.file(source));
+};
+const copySymlink = async (source, destination) => {
+  const target = await fsReadlink(source);
+  try {
+    await fsSymlink(target, destination);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      await remove(destination);
+      await fsSymlink(target, destination);
+      return;
+    }
+    throw error;
+  }
+};
+const copyDirectory = async (source, destination, options) => {
+  await ensureDir(destination);
+  const entries = await fsReaddir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const entrySource = join(source, entry.name);
+    const entryDest = join(destination, entry.name);
+    if (!await shouldCopyEntry(entrySource, options.filter)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await copyDirectory(entrySource, entryDest, options);
+      continue;
+    }
+    if (entry.isSymbolicLink() && !options.dereference) {
+      await copySymlink(entrySource, entryDest);
+      continue;
+    }
+    await copyFile(entrySource, entryDest, options.overwrite ?? true);
+  }
+};
+export const copy = async (from, to, options = {}) => {
+  const source = toPathString(from);
+  const destination = toPathString(to);
+  const stats = options.dereference ? await fsStat(source) : await fsLStat(source);
+  if (stats.isDirectory()) {
+    await copyDirectory(source, destination, options);
+    return;
+  }
+  if (stats.isSymbolicLink() && !options.dereference) {
+    await copySymlink(source, destination);
+    return;
+  }
+  await copyFile(source, destination, options.overwrite ?? true);
+};
+export const move = async (from, to, options) => {
+  const source = toPathString(from);
+  const destination = toPathString(to);
+  if (!options?.overwrite && await pathExists(destination)) {
+    return;
+  }
+  try {
+    await ensureDir(dirname(destination));
+    await fsRename(source, destination);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      await copy(source, destination, {
+        overwrite: options?.overwrite ?? true
+      });
+      await remove(source);
+      return;
+    }
+    throw error;
+  }
+};

package/dist/dir.d.ts

@@ -0,0 +1,13 @@
+import type { EmptyDirOptions, ListFilesOptions, PathLike, ReaddirOptions, SizeOfOptions } from "./types.js";
+export declare const pathExists: (path: PathLike) => Promise<boolean>;
+export declare const ensureDir: (path: PathLike) => Promise<void>;
+export declare const mkdirp: (path: PathLike) => Promise<void>;
+export declare const remove: (path: PathLike, options?: {
+    readonly force?: boolean;
+}) => Promise<void>;
+export declare const emptyDir: (path: PathLike, options?: EmptyDirOptions) => Promise<void>;
+export declare const sizeOf: (path: PathLike, options?: SizeOfOptions) => Promise<number>;
+export declare const readdir: (path: PathLike, options?: ReaddirOptions) => Promise<string[]>;
+export declare const readdirRecursive: (path: PathLike, options?: ListFilesOptions) => Promise<string[]>;
+export declare const listFiles: (path: PathLike, options?: ListFilesOptions) => Promise<string[]>;
+export declare const ensureFile: (path: PathLike) => Promise<void>;

package/dist/dir.js

@@ -0,0 +1,113 @@
+import { dirname, join } from "node:path";
+import {
+  fsLStat,
+  fsMkdir,
+  fsReaddir,
+  fsRm,
+  fsStat,
+  fsUnlink
+} from "./internal/fs.js";
+import { toPathString } from "./internal/path.js";
+export const pathExists = async (path) => {
+  const pathStr = toPathString(path);
+  const file = Bun.file(pathStr);
+  return file.exists();
+};
+export const ensureDir = async (path) => {
+  await fsMkdir(toPathString(path), { recursive: true });
+};
+export const mkdirp = ensureDir;
+export const remove = async (path, options) => {
+  await fsRm(toPathString(path), {
+    recursive: true,
+    force: options?.force ?? true
+  });
+};
+export const emptyDir = async (path, options) => {
+  const target = toPathString(path);
+  await ensureDir(target);
+  const entries = await fsReaddir(target, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = join(target, entry.name);
+    if (options?.filter) {
+      const shouldKeep = await options.filter(entryPath);
+      if (shouldKeep) {
+        continue;
+      }
+    }
+    if (entry.isDirectory()) {
+      await remove(entryPath);
+      continue;
+    }
+    await fsUnlink(entryPath);
+  }
+};
+export const sizeOf = async (path, options) => {
+  const target = toPathString(path);
+  const stats = options?.followSymlinks ? await fsStat(target) : await fsLStat(target);
+  if (stats.isDirectory()) {
+    let total = 0;
+    const entries = await fsReaddir(target, { withFileTypes: true });
+    for (const entry of entries) {
+      total += await sizeOf(join(target, entry.name), options);
+    }
+    return total;
+  }
+  return stats.size;
+};
+export const readdir = async (path, options) => {
+  const target = toPathString(path);
+  if (options?.withFileTypes) {
+    const entries2 = await fsReaddir(target, { withFileTypes: true });
+    return entries2.map((entry) => entry.name);
+  }
+  const entries = await fsReaddir(target);
+  return entries;
+};
+export const readdirRecursive = async (path, options) => {
+  const target = toPathString(path);
+  const queue = [target];
+  const files = [];
+  const follow = options?.followSymlinks ?? false;
+  const extensions = options?.extensions?.map(
+    (ext) => ext.startsWith(".") ? ext : `.${ext}`
+  );
+  while (queue.length > 0) {
+    const current = queue.pop();
+    const entries = await fsReaddir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(entryPath);
+        continue;
+      }
+      if (entry.isSymbolicLink() && !follow) {
+        continue;
+      }
+      if (extensions && extensions.length > 0) {
+        const match = extensions.some((ext) => entry.name.endsWith(ext));
+        if (!match) {
+          continue;
+        }
+      }
+      files.push(entryPath);
+    }
+  }
+  return files;
+};
+export const listFiles = readdirRecursive;
+export const ensureFile = async (path) => {
+  const fullPath = toPathString(path);
+  const dir = dirname(fullPath);
+  if (dir.length > 0) {
+    await ensureDir(dir);
+  }
+  try {
+    await Bun.write(fullPath, "");
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+};

package/dist/file.d.ts

@@ -0,0 +1,12 @@
+import type { FileEncoding, FileInput, JsonWriteOptions, PathLike, ReadFileOptions, WriteFileOptions } from "./types.js";
+export declare function readFile(path: PathLike, options: ReadFileOptions & {
+    readonly encoding: FileEncoding;
+}): Promise<string>;
+export declare function readFile(path: PathLike): Promise<Uint8Array>;
+export declare const readJson: <T>(path: PathLike, _options?: ReadFileOptions) => Promise<T>;
+export declare const readJSONSync: <T>(path: PathLike) => T;
+export declare const writeFile: (destination: PathLike, input: FileInput, options?: WriteFileOptions) => Promise<void>;
+export declare const writeJson: (destination: PathLike, data: unknown, options?: JsonWriteOptions) => Promise<void>;
+export declare const outputFile: (destination: PathLike, input: FileInput, options?: WriteFileOptions) => Promise<void>;
+export declare const outputJson: (destination: PathLike, data: unknown, options?: JsonWriteOptions) => Promise<void>;
+export declare const appendFile: (file: PathLike, data: FileInput, options?: WriteFileOptions) => Promise<void>;

package/dist/file.js

@@ -0,0 +1,169 @@
+import { readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { ensureDir } from "./dir.js";
+import { fsAppendFile, fsWriteFile } from "./internal/fs.js";
+import { toPathString } from "./internal/path.js";
+const toBunWritable = async (input) => {
+  if (typeof input === "string" || input instanceof Uint8Array) {
+    return input;
+  }
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  if (input instanceof Blob) {
+    const buffer = await input.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  if (input instanceof SharedArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  return new Uint8Array(input);
+};
+const toNodeWritable = async (input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input instanceof Blob) {
+    const buffer = await input.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  if (input instanceof SharedArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  return new Uint8Array(input);
+};
+const ensureOutputDestination = async (path) => {
+  const resolved = toPathString(path);
+  const directory = dirname(resolved);
+  if (directory.length > 0) {
+    await ensureDir(directory);
+  }
+  return resolved;
+};
+export async function readFile(path, options) {
+  const file = Bun.file(toPathString(path));
+  const encoding = options?.encoding;
+  if (!encoding || encoding === "binary") {
+    return file.bytes();
+  }
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return file.text();
+  }
+  const bytes = await file.bytes();
+  const buffer = Buffer.from(bytes);
+  switch (encoding) {
+    case "ascii":
+      return buffer.toString("ascii");
+    case "base64":
+      return buffer.toString("base64");
+    case "hex":
+      return buffer.toString("hex");
+    case "latin1":
+      return buffer.toString("latin1");
+    case "ucs-2":
+    case "ucs2":
+      return buffer.toString("ucs2");
+    case "utf16le":
+      return buffer.toString("utf16le");
+    default:
+      return buffer.toString("utf8");
+  }
+}
+export const readJson = async (path, _options) => {
+  const file = Bun.file(toPathString(path));
+  return file.json();
+};
+export const readJSONSync = (path) => {
+  const pathStr = toPathString(path);
+  const content = readFileSync(pathStr, "utf8");
+  return JSON.parse(content);
+};
+export const writeFile = async (destination, input, options) => {
+  const encoding = options?.encoding;
+  const hasSpecialOptions = options?.mode !== void 0 || options?.signal !== void 0;
+  if (typeof input === "string" && encoding && encoding !== "utf8" && encoding !== "utf-8" && encoding !== "binary") {
+    const buffer = Buffer.from(input, encoding);
+    const bytes = new Uint8Array(buffer);
+    if (!hasSpecialOptions) {
+      await Bun.write(destination, bytes);
+      return;
+    }
+    const path2 = toPathString(destination);
+    await fsWriteFile(path2, bytes, {
+      mode: options.mode,
+      signal: options.signal
+    });
+    return;
+  }
+  if (!hasSpecialOptions) {
+    if (typeof input === "string" || input instanceof Uint8Array || input instanceof Blob) {
+      await Bun.write(destination, input);
+      return;
+    }
+    const payload2 = await toBunWritable(input);
+    await Bun.write(destination, payload2);
+    return;
+  }
+  const payload = await toNodeWritable(input);
+  const path = toPathString(destination);
+  await fsWriteFile(path, payload, {
+    mode: options.mode,
+    signal: options.signal
+  });
+};
+export const writeJson = async (destination, data, options) => {
+  const spaces = options?.spaces ?? 2;
+  const text = `${JSON.stringify(data, void 0, spaces)}
+`;
+  await writeFile(destination, text, options);
+};
+export const outputFile = async (destination, input, options) => {
+  const target = await ensureOutputDestination(destination);
+  await writeFile(target, input, options);
+};
+export const outputJson = async (destination, data, options) => {
+  const target = await ensureOutputDestination(destination);
+  await writeJson(target, data, options);
+};
+export const appendFile = async (file, data, options) => {
+  const pathStr = toPathString(file);
+  const encoding = options?.encoding;
+  const dir = dirname(pathStr);
+  if (dir.length > 0) {
+    await ensureDir(dir);
+  }
+  if (typeof data === "string" && encoding && encoding !== "utf8" && encoding !== "utf-8" && encoding !== "binary") {
+    const buffer = Buffer.from(data, encoding);
+    await fsAppendFile(pathStr, buffer, {
+      mode: options?.mode
+    });
+    return;
+  }
+  let payload;
+  if (typeof data === "string") {
+    payload = data;
+  } else if (data instanceof Uint8Array) {
+    payload = data;
+  } else if (data instanceof Blob) {
+    const buffer = await data.arrayBuffer();
+    payload = new Uint8Array(buffer);
+  } else if (ArrayBuffer.isView(data)) {
+    payload = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  } else if (data instanceof SharedArrayBuffer) {
+    payload = new Uint8Array(data);
+  } else {
+    payload = new Uint8Array(data);
+  }
+  await fsAppendFile(pathStr, payload, {
+    mode: options?.mode
+  });
+};

package/dist/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { PathLike, ReadLinesOptions, TouchOptions } from "./types.js";
+export declare const touch: (path: PathLike, options?: TouchOptions | Date) => Promise<void>;
+export declare const readLines: (path: PathLike, options?: ReadLinesOptions) => Promise<string[]>;

package/dist/helpers.js

@@ -0,0 +1,38 @@
+import { ensureFile } from "./dir.js";
+import { readFile } from "./file.js";
+import { fsStat, fsUtimes } from "./internal/fs.js";
+import { toPathString } from "./internal/path.js";
+export const touch = async (path, options) => {
+  const target = toPathString(path);
+  await ensureFile(target);
+  const stats = await fsStat(target);
+  if (options instanceof Date) {
+    await fsUtimes(target, stats.atime, options);
+    return;
+  }
+  const mtime = options?.mtime ?? /* @__PURE__ */ new Date();
+  const atime = options?.atime ?? stats.atime;
+  await fsUtimes(target, atime, mtime);
+};
+export const readLines = async (path, options) => {
+  const text = await readFile(path, { encoding: "utf8" });
+  const lines = text.split(/\r?\n/);
+  const result = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    let line = lines[index] ?? "";
+    if (options?.trim) {
+      line = line.trim();
+    }
+    if (options?.skipEmpty && line === "") {
+      continue;
+    }
+    if (options?.maxLines && result.length >= options.maxLines) {
+      break;
+    }
+    if (line === "" && index === lines.length - 1) {
+      continue;
+    }
+    result.push(line);
+  }
+  return result;
+};

package/dist/internal/fs.d.ts

@@ -0,0 +1,16 @@
+import { access, appendFile, link, lstat, mkdir, readdir, readlink, rename, rm, stat, symlink, unlink, utimes, writeFile } from "node:fs/promises";
+export declare const fsAccess: typeof access;
+export declare const fsAppendFile: typeof appendFile;
+export declare const fsConstants: typeof import("fs").constants;
+export declare const fsLink: typeof link;
+export declare const fsLStat: typeof lstat;
+export declare const fsMkdir: typeof mkdir;
+export declare const fsReaddir: typeof readdir;
+export declare const fsReadlink: typeof readlink;
+export declare const fsRename: typeof rename;
+export declare const fsRm: typeof rm;
+export declare const fsStat: typeof stat;
+export declare const fsSymlink: typeof symlink;
+export declare const fsUnlink: typeof unlink;
+export declare const fsUtimes: typeof utimes;
+export declare const fsWriteFile: typeof writeFile;

package/dist/internal/fs.js

@@ -0,0 +1,32 @@
+import {
+  access,
+  appendFile,
+  constants,
+  link,
+  lstat,
+  mkdir,
+  readdir,
+  readlink,
+  rename,
+  rm,
+  stat,
+  symlink,
+  unlink,
+  utimes,
+  writeFile
+} from "node:fs/promises";
+export const fsAccess = access;
+export const fsAppendFile = appendFile;
+export const fsConstants = constants;
+export const fsLink = link;
+export const fsLStat = lstat;
+export const fsMkdir = mkdir;
+export const fsReaddir = readdir;
+export const fsReadlink = readlink;
+export const fsRename = rename;
+export const fsRm = rm;
+export const fsStat = stat;
+export const fsSymlink = symlink;
+export const fsUnlink = unlink;
+export const fsUtimes = utimes;
+export const fsWriteFile = writeFile;

package/dist/internal/path.d.ts

@@ -0,0 +1,3 @@
+import type { PathLike } from "../types.js";
+export declare const toPathString: (input: PathLike) => string;
+export declare const getPathDirname: (input: PathLike) => string;

package/dist/internal/path.js

@@ -0,0 +1,11 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const toPathString = (input) => {
+  if (typeof input === "string") {
+    return resolve(input);
+  }
+  return resolve(fileURLToPath(input));
+};
+export const getPathDirname = (input) => {
+  return dirname(toPathString(input));
+};

package/dist/links.d.ts

@@ -0,0 +1,3 @@
+import type { EnsureSymlinkOptions, PathLike } from "./types.js";
+export declare const ensureLink: (from: PathLike, to: PathLike) => Promise<void>;
+export declare const ensureSymlink: (from: PathLike, to: PathLike, options?: EnsureSymlinkOptions) => Promise<void>;

package/dist/links.js

@@ -0,0 +1,74 @@
+import { dirname } from "node:path";
+import { ensureDir, remove } from "./dir.js";
+import { fsLink, fsLStat, fsSymlink, fsUnlink } from "./internal/fs.js";
+import { toPathString } from "./internal/path.js";
+const ensureParentDirectory = async (path) => {
+  const directory = dirname(path);
+  if (directory.length === 0) {
+    return;
+  }
+  await ensureDir(directory);
+};
+const removeExistingPath = async (path) => {
+  try {
+    await fsUnlink(path);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return;
+    }
+    if (code === "EISDIR" || code === "EPERM") {
+      await remove(path);
+      return;
+    }
+    throw error;
+  }
+};
+const resolveSymlinkType = async (source, type) => {
+  if (type) {
+    if (type === "dir" && process.platform === "win32") {
+      return "junction";
+    }
+    return type;
+  }
+  if (process.platform !== "win32") {
+    return void 0;
+  }
+  try {
+    const stats = await fsLStat(source);
+    return stats.isDirectory() ? "junction" : "file";
+  } catch {
+    return "file";
+  }
+};
+export const ensureLink = async (from, to) => {
+  const source = toPathString(from);
+  const destination = toPathString(to);
+  await ensureParentDirectory(destination);
+  try {
+    await fsLink(source, destination);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      await removeExistingPath(destination);
+      await fsLink(source, destination);
+      return;
+    }
+    throw error;
+  }
+};
+export const ensureSymlink = async (from, to, options) => {
+  const source = toPathString(from);
+  const destination = toPathString(to);
+  const type = await resolveSymlinkType(source, options?.type);
+  await ensureParentDirectory(destination);
+  try {
+    await fsSymlink(source, destination, type);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      await remove(destination);
+      await fsSymlink(source, destination, type);
+      return;
+    }
+    throw error;
+  }
+};

package/dist/mod.d.ts

@@ -0,0 +1,40 @@
+import { copy, move } from "./copy.js";
+import { emptyDir, ensureDir, ensureFile, listFiles, mkdirp, pathExists, readdir, readdirRecursive, remove, sizeOf } from "./dir.js";
+import { appendFile, outputFile, outputJson, readFile, readJSONSync, readJson, writeFile, writeJson } from "./file.js";
+import { readLines, touch } from "./helpers.js";
+import { ensureLink, ensureSymlink } from "./links.js";
+export type { CopyOptions, EmptyDirOptions, EnsureSymlinkOptions, FileEncoding, JsonWriteOptions, ListFilesOptions, MoveOptions, PathLike, ReaddirOptions, ReadFileOptions, ReadLinesOptions, SizeOfOptions, TouchOptions, WriteFileOptions, } from "./types.js";
+export { copy, move };
+export { emptyDir, ensureDir, ensureFile, listFiles, mkdirp, pathExists, readdir, readdirRecursive, remove, sizeOf, };
+export { appendFile, outputFile, outputJson, readFile, readJson, readJSONSync, writeFile, writeJson, };
+export { readLines, touch };
+export { ensureLink, ensureSymlink };
+declare const fs: {
+    readonly appendFile: (file: import("./types.js").PathLike, data: import("./types.js").FileInput, options?: import("./types.js").WriteFileOptions) => Promise<void>;
+    readonly copy: (from: import("./types.js").PathLike, to: import("./types.js").PathLike, options?: import("./types.js").CopyOptions) => Promise<void>;
+    readonly move: (from: import("./types.js").PathLike, to: import("./types.js").PathLike, options?: import("./types.js").MoveOptions) => Promise<void>;
+    readonly emptyDir: (path: import("./types.js").PathLike, options?: import("./types.js").EmptyDirOptions) => Promise<void>;
+    readonly ensureDir: (path: import("./types.js").PathLike) => Promise<void>;
+    readonly ensureFile: (path: import("./types.js").PathLike) => Promise<void>;
+    readonly listFiles: (path: import("./types.js").PathLike, options?: import("./types.js").ListFilesOptions) => Promise<string[]>;
+    readonly mkdirp: (path: import("./types.js").PathLike) => Promise<void>;
+    readonly pathExists: (path: import("./types.js").PathLike) => Promise<boolean>;
+    readonly readdir: (path: import("./types.js").PathLike, options?: import("./types.js").ReaddirOptions) => Promise<string[]>;
+    readonly readdirRecursive: (path: import("./types.js").PathLike, options?: import("./types.js").ListFilesOptions) => Promise<string[]>;
+    readonly remove: (path: import("./types.js").PathLike, options?: {
+        readonly force?: boolean;
+    }) => Promise<void>;
+    readonly sizeOf: (path: import("./types.js").PathLike, options?: import("./types.js").SizeOfOptions) => Promise<number>;
+    readonly outputFile: (destination: import("./types.js").PathLike, input: import("./types.js").FileInput, options?: import("./types.js").WriteFileOptions) => Promise<void>;
+    readonly outputJson: (destination: import("./types.js").PathLike, data: unknown, options?: import("./types.js").JsonWriteOptions) => Promise<void>;
+    readonly readFile: typeof readFile;
+    readonly readJson: <T>(path: import("./types.js").PathLike, _options?: import("./types.js").ReadFileOptions) => Promise<T>;
+    readonly readJSONSync: <T>(path: import("./types.js").PathLike) => T;
+    readonly writeFile: (destination: import("./types.js").PathLike, input: import("./types.js").FileInput, options?: import("./types.js").WriteFileOptions) => Promise<void>;
+    readonly writeJson: (destination: import("./types.js").PathLike, data: unknown, options?: import("./types.js").JsonWriteOptions) => Promise<void>;
+    readonly readLines: (path: import("./types.js").PathLike, options?: import("./types.js").ReadLinesOptions) => Promise<string[]>;
+    readonly touch: (path: import("./types.js").PathLike, options?: import("./types.js").TouchOptions | Date) => Promise<void>;
+    readonly ensureLink: (from: import("./types.js").PathLike, to: import("./types.js").PathLike) => Promise<void>;
+    readonly ensureSymlink: (from: import("./types.js").PathLike, to: import("./types.js").PathLike, options?: import("./types.js").EnsureSymlinkOptions) => Promise<void>;
+};
+export default fs;