@duplojs/server 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/file/folderInterface.d.ts

@@ -6,7 +6,6 @@ import { ReadDirectoryResult } from './readDirectory';
 import { StatResult } from './stat';
 import { WalkDirectoryParams, WalkDirectoryResult } from './walkDirectory';
 import { RelocateResult } from './relocate';
-import { EntryPath } from './unknownEntryInterface';
 import type * as DKind from "@duplojs/lang/kind";
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
@@ -14,21 +13,21 @@ declare const folderInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServe
 type FolderInterfaceRenameResult = Exclude<RenameResult, DEither.Right> | DEither.Right<"file-system-rename", FolderInterface>;
 type FolderInterfaceRelocateResult = Exclude<RelocateResult, DEither.Right> | DEither.Right<"file-system-relocate", FolderInterface>;
 type FolderInterfaceMoveResult = Exclude<MoveResult, DEither.Right> | DEither.Right<"file-system-move", FolderInterface>;
-export interface FolderInterface<GenericPath extends EntryPath = EntryPath> extends DKind.Kind<typeof folderInterfaceKind> {
+export interface FolderInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> extends DKind.Kind<typeof folderInterfaceKind> {
     path: GenericPath & DPath.Path;
     getName(): (string & DPath.Segment & DPath.Path) | null;
-    getParentPath(): (string & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
     rename(newName: (string & DPath.Segment)): Promise<FolderInterfaceRenameResult>;
     exists(): Promise<ExistsResult>;
-    relocate(parentPath: string & DPath.Path): Promise<FolderInterfaceRelocateResult>;
-    move(newPath: string & DPath.Path): Promise<FolderInterfaceMoveResult>;
+    relocate(parentPath: DPath.AnyPath): Promise<FolderInterfaceRelocateResult>;
+    move(newPath: DPath.AnyPath): Promise<FolderInterfaceMoveResult>;
     remove(): Promise<RemoveResult>;
     getChildren(): Promise<ReadDirectoryResult>;
     stat(): Promise<StatResult>;
     walk(params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
     isFolder(): Promise<boolean>;
 }
-export declare function createFolderInterface<GenericPath extends EntryPath = EntryPath>(path: GenericPath): FolderInterface<GenericPath>;
+export declare function createFolderInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(path: GenericPath): FolderInterface<GenericPath>;
 export declare function isFolderInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, FolderInterface>;
 export declare const isFolderInterfaceFromUnknown: (input: unknown) => input is FolderInterface;
 export {};

package/dist/file/folderInterface.mjs

@@ -47,7 +47,7 @@ function createFolderInterface(path) {
 		return DCommon.asyncPipe(localStat(), DEither.whenHasInformationOtherwise("file-system-stat", ({ isDirectory }) => isDirectory, DCommon.justReturn(false)));
 	}
 	return {
-		path,
+		path: DCommon.cast(path),
 		getName,
 		getParentPath,
 		move: localMove,

package/dist/file/index.cjs

@@ -36,6 +36,259 @@ const require_writeJsonFile = require("./writeJsonFile.cjs");
 const require_writeTextFile = require("./writeTextFile.cjs");
 //#region scripts/file/index.ts
 var file_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	AppendFileError: () => require_appendFile.AppendFileError,
+	AppendFileErrorBusy: () => require_appendFile.AppendFileErrorBusy,
+	AppendFileErrorInvalidArgument: () => require_appendFile.AppendFileErrorInvalidArgument,
+	AppendFileErrorIsDirectory: () => require_appendFile.AppendFileErrorIsDirectory,
+	AppendFileErrorNoSpace: () => require_appendFile.AppendFileErrorNoSpace,
+	AppendFileErrorNotDirectory: () => require_appendFile.AppendFileErrorNotDirectory,
+	AppendFileErrorNotFound: () => require_appendFile.AppendFileErrorNotFound,
+	AppendFileErrorPermissionDenied: () => require_appendFile.AppendFileErrorPermissionDenied,
+	AppendFileErrorReadOnly: () => require_appendFile.AppendFileErrorReadOnly,
+	AppendFileErrorTooManyOpenFiles: () => require_appendFile.AppendFileErrorTooManyOpenFiles,
+	AppendTextFileError: () => require_appendTextFile.AppendTextFileError,
+	AppendTextFileErrorBusy: () => require_appendTextFile.AppendTextFileErrorBusy,
+	AppendTextFileErrorInvalidArgument: () => require_appendTextFile.AppendTextFileErrorInvalidArgument,
+	AppendTextFileErrorIsDirectory: () => require_appendTextFile.AppendTextFileErrorIsDirectory,
+	AppendTextFileErrorNoSpace: () => require_appendTextFile.AppendTextFileErrorNoSpace,
+	AppendTextFileErrorNotDirectory: () => require_appendTextFile.AppendTextFileErrorNotDirectory,
+	AppendTextFileErrorNotFound: () => require_appendTextFile.AppendTextFileErrorNotFound,
+	AppendTextFileErrorPermissionDenied: () => require_appendTextFile.AppendTextFileErrorPermissionDenied,
+	AppendTextFileErrorReadOnly: () => require_appendTextFile.AppendTextFileErrorReadOnly,
+	AppendTextFileErrorTooManyOpenFiles: () => require_appendTextFile.AppendTextFileErrorTooManyOpenFiles,
+	CopyError: () => require_copy.CopyError,
+	CopyErrorAlreadyExists: () => require_copy.CopyErrorAlreadyExists,
+	CopyErrorBusy: () => require_copy.CopyErrorBusy,
+	CopyErrorInvalidArgument: () => require_copy.CopyErrorInvalidArgument,
+	CopyErrorNoSpace: () => require_copy.CopyErrorNoSpace,
+	CopyErrorNotDirectory: () => require_copy.CopyErrorNotDirectory,
+	CopyErrorNotFound: () => require_copy.CopyErrorNotFound,
+	CopyErrorPermissionDenied: () => require_copy.CopyErrorPermissionDenied,
+	CopyErrorReadOnly: () => require_copy.CopyErrorReadOnly,
+	CopyErrorTooManyOpenFiles: () => require_copy.CopyErrorTooManyOpenFiles,
+	EnsureDirectoryError: () => require_ensureDirectory.EnsureDirectoryError,
+	EnsureDirectoryErrorBusy: () => require_ensureDirectory.EnsureDirectoryErrorBusy,
+	EnsureDirectoryErrorInvalidArgument: () => require_ensureDirectory.EnsureDirectoryErrorInvalidArgument,
+	EnsureDirectoryErrorNoSpace: () => require_ensureDirectory.EnsureDirectoryErrorNoSpace,
+	EnsureDirectoryErrorNotDirectory: () => require_ensureDirectory.EnsureDirectoryErrorNotDirectory,
+	EnsureDirectoryErrorPermissionDenied: () => require_ensureDirectory.EnsureDirectoryErrorPermissionDenied,
+	EnsureDirectoryErrorReadOnly: () => require_ensureDirectory.EnsureDirectoryErrorReadOnly,
+	EnsureDirectoryErrorTooManyOpenFiles: () => require_ensureDirectory.EnsureDirectoryErrorTooManyOpenFiles,
+	EnsureFileError: () => require_ensureFile.EnsureFileError,
+	EnsureFileErrorBusy: () => require_ensureFile.EnsureFileErrorBusy,
+	EnsureFileErrorInvalidArgument: () => require_ensureFile.EnsureFileErrorInvalidArgument,
+	EnsureFileErrorIsDirectory: () => require_ensureFile.EnsureFileErrorIsDirectory,
+	EnsureFileErrorNoSpace: () => require_ensureFile.EnsureFileErrorNoSpace,
+	EnsureFileErrorNotDirectory: () => require_ensureFile.EnsureFileErrorNotDirectory,
+	EnsureFileErrorPermissionDenied: () => require_ensureFile.EnsureFileErrorPermissionDenied,
+	EnsureFileErrorReadOnly: () => require_ensureFile.EnsureFileErrorReadOnly,
+	EnsureFileErrorTooManyOpenFiles: () => require_ensureFile.EnsureFileErrorTooManyOpenFiles,
+	ExistsError: () => require_exists.ExistsError,
+	ExistsErrorNotDirectory: () => require_exists.ExistsErrorNotDirectory,
+	ExistsErrorNotFound: () => require_exists.ExistsErrorNotFound,
+	ExistsErrorPermissionDenied: () => require_exists.ExistsErrorPermissionDenied,
+	ExistsErrorTooManyOpenFiles: () => require_exists.ExistsErrorTooManyOpenFiles,
+	LinkError: () => require_link.LinkError,
+	LinkErrorAlreadyExists: () => require_link.LinkErrorAlreadyExists,
+	LinkErrorBusy: () => require_link.LinkErrorBusy,
+	LinkErrorCrossDevice: () => require_link.LinkErrorCrossDevice,
+	LinkErrorInvalidArgument: () => require_link.LinkErrorInvalidArgument,
+	LinkErrorNoSpace: () => require_link.LinkErrorNoSpace,
+	LinkErrorNotDirectory: () => require_link.LinkErrorNotDirectory,
+	LinkErrorNotFound: () => require_link.LinkErrorNotFound,
+	LinkErrorPermissionDenied: () => require_link.LinkErrorPermissionDenied,
+	LinkErrorReadOnly: () => require_link.LinkErrorReadOnly,
+	LinkErrorTooManyOpenFiles: () => require_link.LinkErrorTooManyOpenFiles,
+	LinkStatError: () => require_linkStat.LinkStatError,
+	LinkStatErrorBusy: () => require_linkStat.LinkStatErrorBusy,
+	LinkStatErrorNotDirectory: () => require_linkStat.LinkStatErrorNotDirectory,
+	LinkStatErrorNotFound: () => require_linkStat.LinkStatErrorNotFound,
+	LinkStatErrorPermissionDenied: () => require_linkStat.LinkStatErrorPermissionDenied,
+	LinkStatErrorTooManyOpenFiles: () => require_linkStat.LinkStatErrorTooManyOpenFiles,
+	MakeDirectoryError: () => require_makeDirectory.MakeDirectoryError,
+	MakeDirectoryErrorAlreadyExists: () => require_makeDirectory.MakeDirectoryErrorAlreadyExists,
+	MakeDirectoryErrorBusy: () => require_makeDirectory.MakeDirectoryErrorBusy,
+	MakeDirectoryErrorInvalidArgument: () => require_makeDirectory.MakeDirectoryErrorInvalidArgument,
+	MakeDirectoryErrorNoSpace: () => require_makeDirectory.MakeDirectoryErrorNoSpace,
+	MakeDirectoryErrorNotDirectory: () => require_makeDirectory.MakeDirectoryErrorNotDirectory,
+	MakeDirectoryErrorNotFound: () => require_makeDirectory.MakeDirectoryErrorNotFound,
+	MakeDirectoryErrorPermissionDenied: () => require_makeDirectory.MakeDirectoryErrorPermissionDenied,
+	MakeDirectoryErrorReadOnly: () => require_makeDirectory.MakeDirectoryErrorReadOnly,
+	MakeDirectoryErrorTooManyOpenFiles: () => require_makeDirectory.MakeDirectoryErrorTooManyOpenFiles,
+	MakeTemporaryDirectoryError: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryError,
+	MakeTemporaryDirectoryErrorInvalidArgument: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorInvalidArgument,
+	MakeTemporaryDirectoryErrorNoSpace: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorNoSpace,
+	MakeTemporaryDirectoryErrorNotDirectory: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorNotDirectory,
+	MakeTemporaryDirectoryErrorPermissionDenied: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorPermissionDenied,
+	MakeTemporaryDirectoryErrorReadOnly: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorReadOnly,
+	MakeTemporaryDirectoryErrorTooManyOpenFiles: () => require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorTooManyOpenFiles,
+	MakeTemporaryFileError: () => require_makeTemporaryFile.MakeTemporaryFileError,
+	MakeTemporaryFileErrorAlreadyExists: () => require_makeTemporaryFile.MakeTemporaryFileErrorAlreadyExists,
+	MakeTemporaryFileErrorInvalidArgument: () => require_makeTemporaryFile.MakeTemporaryFileErrorInvalidArgument,
+	MakeTemporaryFileErrorNoSpace: () => require_makeTemporaryFile.MakeTemporaryFileErrorNoSpace,
+	MakeTemporaryFileErrorNotDirectory: () => require_makeTemporaryFile.MakeTemporaryFileErrorNotDirectory,
+	MakeTemporaryFileErrorPermissionDenied: () => require_makeTemporaryFile.MakeTemporaryFileErrorPermissionDenied,
+	MakeTemporaryFileErrorReadOnly: () => require_makeTemporaryFile.MakeTemporaryFileErrorReadOnly,
+	MakeTemporaryFileErrorTooManyOpenFiles: () => require_makeTemporaryFile.MakeTemporaryFileErrorTooManyOpenFiles,
+	MoveError: () => require_move.MoveError,
+	MoveErrorAlreadyExists: () => require_move.MoveErrorAlreadyExists,
+	MoveErrorBusy: () => require_move.MoveErrorBusy,
+	MoveErrorCrossDevice: () => require_move.MoveErrorCrossDevice,
+	MoveErrorDirectoryNotEmpty: () => require_move.MoveErrorDirectoryNotEmpty,
+	MoveErrorInvalidArgument: () => require_move.MoveErrorInvalidArgument,
+	MoveErrorIsDirectory: () => require_move.MoveErrorIsDirectory,
+	MoveErrorNotDirectory: () => require_move.MoveErrorNotDirectory,
+	MoveErrorNotFound: () => require_move.MoveErrorNotFound,
+	MoveErrorPermissionDenied: () => require_move.MoveErrorPermissionDenied,
+	MoveErrorReadOnly: () => require_move.MoveErrorReadOnly,
+	ReadDirectoryError: () => require_readDirectory.ReadDirectoryError,
+	ReadDirectoryErrorBusy: () => require_readDirectory.ReadDirectoryErrorBusy,
+	ReadDirectoryErrorNotDirectory: () => require_readDirectory.ReadDirectoryErrorNotDirectory,
+	ReadDirectoryErrorNotFound: () => require_readDirectory.ReadDirectoryErrorNotFound,
+	ReadDirectoryErrorPermissionDenied: () => require_readDirectory.ReadDirectoryErrorPermissionDenied,
+	ReadDirectoryErrorTooManyOpenFiles: () => require_readDirectory.ReadDirectoryErrorTooManyOpenFiles,
+	ReadFileError: () => require_readFile.ReadFileError,
+	ReadFileErrorBusy: () => require_readFile.ReadFileErrorBusy,
+	ReadFileErrorIsDirectory: () => require_readFile.ReadFileErrorIsDirectory,
+	ReadFileErrorNotDirectory: () => require_readFile.ReadFileErrorNotDirectory,
+	ReadFileErrorNotFound: () => require_readFile.ReadFileErrorNotFound,
+	ReadFileErrorPermissionDenied: () => require_readFile.ReadFileErrorPermissionDenied,
+	ReadFileErrorTooManyOpenFiles: () => require_readFile.ReadFileErrorTooManyOpenFiles,
+	ReadJsonFileError: () => require_readJsonFile.ReadJsonFileError,
+	ReadJsonFileErrorBusy: () => require_readJsonFile.ReadJsonFileErrorBusy,
+	ReadJsonFileErrorIsDirectory: () => require_readJsonFile.ReadJsonFileErrorIsDirectory,
+	ReadJsonFileErrorNotDirectory: () => require_readJsonFile.ReadJsonFileErrorNotDirectory,
+	ReadJsonFileErrorNotFound: () => require_readJsonFile.ReadJsonFileErrorNotFound,
+	ReadJsonFileErrorPermissionDenied: () => require_readJsonFile.ReadJsonFileErrorPermissionDenied,
+	ReadJsonFileErrorTooManyOpenFiles: () => require_readJsonFile.ReadJsonFileErrorTooManyOpenFiles,
+	ReadLinkError: () => require_readLink.ReadLinkError,
+	ReadLinkErrorInvalidArgument: () => require_readLink.ReadLinkErrorInvalidArgument,
+	ReadLinkErrorNotDirectory: () => require_readLink.ReadLinkErrorNotDirectory,
+	ReadLinkErrorNotFound: () => require_readLink.ReadLinkErrorNotFound,
+	ReadLinkErrorPermissionDenied: () => require_readLink.ReadLinkErrorPermissionDenied,
+	ReadLinkErrorTooManyOpenFiles: () => require_readLink.ReadLinkErrorTooManyOpenFiles,
+	ReadTextFileError: () => require_readTextFile.ReadTextFileError,
+	ReadTextFileErrorBusy: () => require_readTextFile.ReadTextFileErrorBusy,
+	ReadTextFileErrorIsDirectory: () => require_readTextFile.ReadTextFileErrorIsDirectory,
+	ReadTextFileErrorNotDirectory: () => require_readTextFile.ReadTextFileErrorNotDirectory,
+	ReadTextFileErrorNotFound: () => require_readTextFile.ReadTextFileErrorNotFound,
+	ReadTextFileErrorPermissionDenied: () => require_readTextFile.ReadTextFileErrorPermissionDenied,
+	ReadTextFileErrorTooManyOpenFiles: () => require_readTextFile.ReadTextFileErrorTooManyOpenFiles,
+	RealPathError: () => require_realPath.RealPathError,
+	RealPathErrorNotDirectory: () => require_realPath.RealPathErrorNotDirectory,
+	RealPathErrorNotFound: () => require_realPath.RealPathErrorNotFound,
+	RealPathErrorPermissionDenied: () => require_realPath.RealPathErrorPermissionDenied,
+	RealPathErrorTooManyOpenFiles: () => require_realPath.RealPathErrorTooManyOpenFiles,
+	RelocateError: () => require_relocate.RelocateError,
+	RelocateErrorAlreadyExists: () => require_relocate.RelocateErrorAlreadyExists,
+	RelocateErrorBusy: () => require_relocate.RelocateErrorBusy,
+	RelocateErrorCrossDevice: () => require_relocate.RelocateErrorCrossDevice,
+	RelocateErrorDirectoryNotEmpty: () => require_relocate.RelocateErrorDirectoryNotEmpty,
+	RelocateErrorInvalidArgument: () => require_relocate.RelocateErrorInvalidArgument,
+	RelocateErrorIsDirectory: () => require_relocate.RelocateErrorIsDirectory,
+	RelocateErrorNotDirectory: () => require_relocate.RelocateErrorNotDirectory,
+	RelocateErrorNotFound: () => require_relocate.RelocateErrorNotFound,
+	RelocateErrorPermissionDenied: () => require_relocate.RelocateErrorPermissionDenied,
+	RelocateErrorReadOnly: () => require_relocate.RelocateErrorReadOnly,
+	RemoveError: () => require_remove.RemoveError,
+	RemoveErrorBusy: () => require_remove.RemoveErrorBusy,
+	RemoveErrorDirectoryNotEmpty: () => require_remove.RemoveErrorDirectoryNotEmpty,
+	RemoveErrorInvalidArgument: () => require_remove.RemoveErrorInvalidArgument,
+	RemoveErrorIsDirectory: () => require_remove.RemoveErrorIsDirectory,
+	RemoveErrorNotDirectory: () => require_remove.RemoveErrorNotDirectory,
+	RemoveErrorNotFound: () => require_remove.RemoveErrorNotFound,
+	RemoveErrorPermissionDenied: () => require_remove.RemoveErrorPermissionDenied,
+	RemoveErrorReadOnly: () => require_remove.RemoveErrorReadOnly,
+	RenameError: () => require_rename.RenameError,
+	RenameErrorAlreadyExists: () => require_rename.RenameErrorAlreadyExists,
+	RenameErrorBusy: () => require_rename.RenameErrorBusy,
+	RenameErrorCrossDevice: () => require_rename.RenameErrorCrossDevice,
+	RenameErrorDirectoryNotEmpty: () => require_rename.RenameErrorDirectoryNotEmpty,
+	RenameErrorInvalidArgument: () => require_rename.RenameErrorInvalidArgument,
+	RenameErrorIsDirectory: () => require_rename.RenameErrorIsDirectory,
+	RenameErrorNotDirectory: () => require_rename.RenameErrorNotDirectory,
+	RenameErrorNotFound: () => require_rename.RenameErrorNotFound,
+	RenameErrorPermissionDenied: () => require_rename.RenameErrorPermissionDenied,
+	RenameErrorReadOnly: () => require_rename.RenameErrorReadOnly,
+	SetModeError: () => require_setMode.SetModeError,
+	SetModeErrorInvalidArgument: () => require_setMode.SetModeErrorInvalidArgument,
+	SetModeErrorNotDirectory: () => require_setMode.SetModeErrorNotDirectory,
+	SetModeErrorNotFound: () => require_setMode.SetModeErrorNotFound,
+	SetModeErrorPermissionDenied: () => require_setMode.SetModeErrorPermissionDenied,
+	SetModeErrorReadOnly: () => require_setMode.SetModeErrorReadOnly,
+	SetOwnerError: () => require_setOwner.SetOwnerError,
+	SetOwnerErrorInvalidArgument: () => require_setOwner.SetOwnerErrorInvalidArgument,
+	SetOwnerErrorNotDirectory: () => require_setOwner.SetOwnerErrorNotDirectory,
+	SetOwnerErrorNotFound: () => require_setOwner.SetOwnerErrorNotFound,
+	SetOwnerErrorPermissionDenied: () => require_setOwner.SetOwnerErrorPermissionDenied,
+	SetOwnerErrorReadOnly: () => require_setOwner.SetOwnerErrorReadOnly,
+	SetTimeError: () => require_setTime.SetTimeError,
+	SetTimeErrorInvalidArgument: () => require_setTime.SetTimeErrorInvalidArgument,
+	SetTimeErrorNotDirectory: () => require_setTime.SetTimeErrorNotDirectory,
+	SetTimeErrorNotFound: () => require_setTime.SetTimeErrorNotFound,
+	SetTimeErrorPermissionDenied: () => require_setTime.SetTimeErrorPermissionDenied,
+	SetTimeErrorReadOnly: () => require_setTime.SetTimeErrorReadOnly,
+	StatError: () => require_stat.StatError,
+	StatErrorBusy: () => require_stat.StatErrorBusy,
+	StatErrorNotDirectory: () => require_stat.StatErrorNotDirectory,
+	StatErrorNotFound: () => require_stat.StatErrorNotFound,
+	StatErrorPermissionDenied: () => require_stat.StatErrorPermissionDenied,
+	StatErrorTooManyOpenFiles: () => require_stat.StatErrorTooManyOpenFiles,
+	SymlinkError: () => require_symlink.SymlinkError,
+	SymlinkErrorAlreadyExists: () => require_symlink.SymlinkErrorAlreadyExists,
+	SymlinkErrorBusy: () => require_symlink.SymlinkErrorBusy,
+	SymlinkErrorInvalidArgument: () => require_symlink.SymlinkErrorInvalidArgument,
+	SymlinkErrorNotDirectory: () => require_symlink.SymlinkErrorNotDirectory,
+	SymlinkErrorNotFound: () => require_symlink.SymlinkErrorNotFound,
+	SymlinkErrorPermissionDenied: () => require_symlink.SymlinkErrorPermissionDenied,
+	SymlinkErrorReadOnly: () => require_symlink.SymlinkErrorReadOnly,
+	SymlinkErrorTooManyOpenFiles: () => require_symlink.SymlinkErrorTooManyOpenFiles,
+	TruncateError: () => require_truncate.TruncateError,
+	TruncateErrorBusy: () => require_truncate.TruncateErrorBusy,
+	TruncateErrorInvalidArgument: () => require_truncate.TruncateErrorInvalidArgument,
+	TruncateErrorIsDirectory: () => require_truncate.TruncateErrorIsDirectory,
+	TruncateErrorNoSpace: () => require_truncate.TruncateErrorNoSpace,
+	TruncateErrorNotDirectory: () => require_truncate.TruncateErrorNotDirectory,
+	TruncateErrorNotFound: () => require_truncate.TruncateErrorNotFound,
+	TruncateErrorPermissionDenied: () => require_truncate.TruncateErrorPermissionDenied,
+	TruncateErrorReadOnly: () => require_truncate.TruncateErrorReadOnly,
+	TruncateErrorTooManyOpenFiles: () => require_truncate.TruncateErrorTooManyOpenFiles,
+	WalkDirectoryError: () => require_walkDirectory.WalkDirectoryError,
+	WalkDirectoryErrorBusy: () => require_walkDirectory.WalkDirectoryErrorBusy,
+	WalkDirectoryErrorNotDirectory: () => require_walkDirectory.WalkDirectoryErrorNotDirectory,
+	WalkDirectoryErrorNotFound: () => require_walkDirectory.WalkDirectoryErrorNotFound,
+	WalkDirectoryErrorPermissionDenied: () => require_walkDirectory.WalkDirectoryErrorPermissionDenied,
+	WalkDirectoryErrorTooManyOpenFiles: () => require_walkDirectory.WalkDirectoryErrorTooManyOpenFiles,
+	WriteFileError: () => require_writeFile.WriteFileError,
+	WriteFileErrorBusy: () => require_writeFile.WriteFileErrorBusy,
+	WriteFileErrorInvalidArgument: () => require_writeFile.WriteFileErrorInvalidArgument,
+	WriteFileErrorIsDirectory: () => require_writeFile.WriteFileErrorIsDirectory,
+	WriteFileErrorNoSpace: () => require_writeFile.WriteFileErrorNoSpace,
+	WriteFileErrorNotDirectory: () => require_writeFile.WriteFileErrorNotDirectory,
+	WriteFileErrorNotFound: () => require_writeFile.WriteFileErrorNotFound,
+	WriteFileErrorPermissionDenied: () => require_writeFile.WriteFileErrorPermissionDenied,
+	WriteFileErrorReadOnly: () => require_writeFile.WriteFileErrorReadOnly,
+	WriteFileErrorTooManyOpenFiles: () => require_writeFile.WriteFileErrorTooManyOpenFiles,
+	WriteJsonFileError: () => require_writeJsonFile.WriteJsonFileError,
+	WriteJsonFileErrorBusy: () => require_writeJsonFile.WriteJsonFileErrorBusy,
+	WriteJsonFileErrorInvalidArgument: () => require_writeJsonFile.WriteJsonFileErrorInvalidArgument,
+	WriteJsonFileErrorIsDirectory: () => require_writeJsonFile.WriteJsonFileErrorIsDirectory,
+	WriteJsonFileErrorNoSpace: () => require_writeJsonFile.WriteJsonFileErrorNoSpace,
+	WriteJsonFileErrorNotDirectory: () => require_writeJsonFile.WriteJsonFileErrorNotDirectory,
+	WriteJsonFileErrorNotFound: () => require_writeJsonFile.WriteJsonFileErrorNotFound,
+	WriteJsonFileErrorPermissionDenied: () => require_writeJsonFile.WriteJsonFileErrorPermissionDenied,
+	WriteJsonFileErrorReadOnly: () => require_writeJsonFile.WriteJsonFileErrorReadOnly,
+	WriteJsonFileErrorTooManyOpenFiles: () => require_writeJsonFile.WriteJsonFileErrorTooManyOpenFiles,
+	WriteTextFileError: () => require_writeTextFile.WriteTextFileError,
+	WriteTextFileErrorBusy: () => require_writeTextFile.WriteTextFileErrorBusy,
+	WriteTextFileErrorInvalidArgument: () => require_writeTextFile.WriteTextFileErrorInvalidArgument,
+	WriteTextFileErrorIsDirectory: () => require_writeTextFile.WriteTextFileErrorIsDirectory,
+	WriteTextFileErrorNoSpace: () => require_writeTextFile.WriteTextFileErrorNoSpace,
+	WriteTextFileErrorNotDirectory: () => require_writeTextFile.WriteTextFileErrorNotDirectory,
+	WriteTextFileErrorNotFound: () => require_writeTextFile.WriteTextFileErrorNotFound,
+	WriteTextFileErrorPermissionDenied: () => require_writeTextFile.WriteTextFileErrorPermissionDenied,
+	WriteTextFileErrorReadOnly: () => require_writeTextFile.WriteTextFileErrorReadOnly,
+	WriteTextFileErrorTooManyOpenFiles: () => require_writeTextFile.WriteTextFileErrorTooManyOpenFiles,
 	appendFile: () => require_appendFile.appendFile,
 	appendTextFile: () => require_appendTextFile.appendTextFile,
 	copy: () => require_copy.copy,
@@ -79,6 +332,259 @@ var file_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	writeTextFile: () => require_writeTextFile.writeTextFile
 });
 //#endregion
+exports.AppendFileError = require_appendFile.AppendFileError;
+exports.AppendFileErrorBusy = require_appendFile.AppendFileErrorBusy;
+exports.AppendFileErrorInvalidArgument = require_appendFile.AppendFileErrorInvalidArgument;
+exports.AppendFileErrorIsDirectory = require_appendFile.AppendFileErrorIsDirectory;
+exports.AppendFileErrorNoSpace = require_appendFile.AppendFileErrorNoSpace;
+exports.AppendFileErrorNotDirectory = require_appendFile.AppendFileErrorNotDirectory;
+exports.AppendFileErrorNotFound = require_appendFile.AppendFileErrorNotFound;
+exports.AppendFileErrorPermissionDenied = require_appendFile.AppendFileErrorPermissionDenied;
+exports.AppendFileErrorReadOnly = require_appendFile.AppendFileErrorReadOnly;
+exports.AppendFileErrorTooManyOpenFiles = require_appendFile.AppendFileErrorTooManyOpenFiles;
+exports.AppendTextFileError = require_appendTextFile.AppendTextFileError;
+exports.AppendTextFileErrorBusy = require_appendTextFile.AppendTextFileErrorBusy;
+exports.AppendTextFileErrorInvalidArgument = require_appendTextFile.AppendTextFileErrorInvalidArgument;
+exports.AppendTextFileErrorIsDirectory = require_appendTextFile.AppendTextFileErrorIsDirectory;
+exports.AppendTextFileErrorNoSpace = require_appendTextFile.AppendTextFileErrorNoSpace;
+exports.AppendTextFileErrorNotDirectory = require_appendTextFile.AppendTextFileErrorNotDirectory;
+exports.AppendTextFileErrorNotFound = require_appendTextFile.AppendTextFileErrorNotFound;
+exports.AppendTextFileErrorPermissionDenied = require_appendTextFile.AppendTextFileErrorPermissionDenied;
+exports.AppendTextFileErrorReadOnly = require_appendTextFile.AppendTextFileErrorReadOnly;
+exports.AppendTextFileErrorTooManyOpenFiles = require_appendTextFile.AppendTextFileErrorTooManyOpenFiles;
+exports.CopyError = require_copy.CopyError;
+exports.CopyErrorAlreadyExists = require_copy.CopyErrorAlreadyExists;
+exports.CopyErrorBusy = require_copy.CopyErrorBusy;
+exports.CopyErrorInvalidArgument = require_copy.CopyErrorInvalidArgument;
+exports.CopyErrorNoSpace = require_copy.CopyErrorNoSpace;
+exports.CopyErrorNotDirectory = require_copy.CopyErrorNotDirectory;
+exports.CopyErrorNotFound = require_copy.CopyErrorNotFound;
+exports.CopyErrorPermissionDenied = require_copy.CopyErrorPermissionDenied;
+exports.CopyErrorReadOnly = require_copy.CopyErrorReadOnly;
+exports.CopyErrorTooManyOpenFiles = require_copy.CopyErrorTooManyOpenFiles;
+exports.EnsureDirectoryError = require_ensureDirectory.EnsureDirectoryError;
+exports.EnsureDirectoryErrorBusy = require_ensureDirectory.EnsureDirectoryErrorBusy;
+exports.EnsureDirectoryErrorInvalidArgument = require_ensureDirectory.EnsureDirectoryErrorInvalidArgument;
+exports.EnsureDirectoryErrorNoSpace = require_ensureDirectory.EnsureDirectoryErrorNoSpace;
+exports.EnsureDirectoryErrorNotDirectory = require_ensureDirectory.EnsureDirectoryErrorNotDirectory;
+exports.EnsureDirectoryErrorPermissionDenied = require_ensureDirectory.EnsureDirectoryErrorPermissionDenied;
+exports.EnsureDirectoryErrorReadOnly = require_ensureDirectory.EnsureDirectoryErrorReadOnly;
+exports.EnsureDirectoryErrorTooManyOpenFiles = require_ensureDirectory.EnsureDirectoryErrorTooManyOpenFiles;
+exports.EnsureFileError = require_ensureFile.EnsureFileError;
+exports.EnsureFileErrorBusy = require_ensureFile.EnsureFileErrorBusy;
+exports.EnsureFileErrorInvalidArgument = require_ensureFile.EnsureFileErrorInvalidArgument;
+exports.EnsureFileErrorIsDirectory = require_ensureFile.EnsureFileErrorIsDirectory;
+exports.EnsureFileErrorNoSpace = require_ensureFile.EnsureFileErrorNoSpace;
+exports.EnsureFileErrorNotDirectory = require_ensureFile.EnsureFileErrorNotDirectory;
+exports.EnsureFileErrorPermissionDenied = require_ensureFile.EnsureFileErrorPermissionDenied;
+exports.EnsureFileErrorReadOnly = require_ensureFile.EnsureFileErrorReadOnly;
+exports.EnsureFileErrorTooManyOpenFiles = require_ensureFile.EnsureFileErrorTooManyOpenFiles;
+exports.ExistsError = require_exists.ExistsError;
+exports.ExistsErrorNotDirectory = require_exists.ExistsErrorNotDirectory;
+exports.ExistsErrorNotFound = require_exists.ExistsErrorNotFound;
+exports.ExistsErrorPermissionDenied = require_exists.ExistsErrorPermissionDenied;
+exports.ExistsErrorTooManyOpenFiles = require_exists.ExistsErrorTooManyOpenFiles;
+exports.LinkError = require_link.LinkError;
+exports.LinkErrorAlreadyExists = require_link.LinkErrorAlreadyExists;
+exports.LinkErrorBusy = require_link.LinkErrorBusy;
+exports.LinkErrorCrossDevice = require_link.LinkErrorCrossDevice;
+exports.LinkErrorInvalidArgument = require_link.LinkErrorInvalidArgument;
+exports.LinkErrorNoSpace = require_link.LinkErrorNoSpace;
+exports.LinkErrorNotDirectory = require_link.LinkErrorNotDirectory;
+exports.LinkErrorNotFound = require_link.LinkErrorNotFound;
+exports.LinkErrorPermissionDenied = require_link.LinkErrorPermissionDenied;
+exports.LinkErrorReadOnly = require_link.LinkErrorReadOnly;
+exports.LinkErrorTooManyOpenFiles = require_link.LinkErrorTooManyOpenFiles;
+exports.LinkStatError = require_linkStat.LinkStatError;
+exports.LinkStatErrorBusy = require_linkStat.LinkStatErrorBusy;
+exports.LinkStatErrorNotDirectory = require_linkStat.LinkStatErrorNotDirectory;
+exports.LinkStatErrorNotFound = require_linkStat.LinkStatErrorNotFound;
+exports.LinkStatErrorPermissionDenied = require_linkStat.LinkStatErrorPermissionDenied;
+exports.LinkStatErrorTooManyOpenFiles = require_linkStat.LinkStatErrorTooManyOpenFiles;
+exports.MakeDirectoryError = require_makeDirectory.MakeDirectoryError;
+exports.MakeDirectoryErrorAlreadyExists = require_makeDirectory.MakeDirectoryErrorAlreadyExists;
+exports.MakeDirectoryErrorBusy = require_makeDirectory.MakeDirectoryErrorBusy;
+exports.MakeDirectoryErrorInvalidArgument = require_makeDirectory.MakeDirectoryErrorInvalidArgument;
+exports.MakeDirectoryErrorNoSpace = require_makeDirectory.MakeDirectoryErrorNoSpace;
+exports.MakeDirectoryErrorNotDirectory = require_makeDirectory.MakeDirectoryErrorNotDirectory;
+exports.MakeDirectoryErrorNotFound = require_makeDirectory.MakeDirectoryErrorNotFound;
+exports.MakeDirectoryErrorPermissionDenied = require_makeDirectory.MakeDirectoryErrorPermissionDenied;
+exports.MakeDirectoryErrorReadOnly = require_makeDirectory.MakeDirectoryErrorReadOnly;
+exports.MakeDirectoryErrorTooManyOpenFiles = require_makeDirectory.MakeDirectoryErrorTooManyOpenFiles;
+exports.MakeTemporaryDirectoryError = require_makeTemporaryDirectory.MakeTemporaryDirectoryError;
+exports.MakeTemporaryDirectoryErrorInvalidArgument = require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorInvalidArgument;
+exports.MakeTemporaryDirectoryErrorNoSpace = require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorNoSpace;
+exports.MakeTemporaryDirectoryErrorNotDirectory = require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorNotDirectory;
+exports.MakeTemporaryDirectoryErrorPermissionDenied = require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorPermissionDenied;
+exports.MakeTemporaryDirectoryErrorReadOnly = require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorReadOnly;
+exports.MakeTemporaryDirectoryErrorTooManyOpenFiles = require_makeTemporaryDirectory.MakeTemporaryDirectoryErrorTooManyOpenFiles;
+exports.MakeTemporaryFileError = require_makeTemporaryFile.MakeTemporaryFileError;
+exports.MakeTemporaryFileErrorAlreadyExists = require_makeTemporaryFile.MakeTemporaryFileErrorAlreadyExists;
+exports.MakeTemporaryFileErrorInvalidArgument = require_makeTemporaryFile.MakeTemporaryFileErrorInvalidArgument;
+exports.MakeTemporaryFileErrorNoSpace = require_makeTemporaryFile.MakeTemporaryFileErrorNoSpace;
+exports.MakeTemporaryFileErrorNotDirectory = require_makeTemporaryFile.MakeTemporaryFileErrorNotDirectory;
+exports.MakeTemporaryFileErrorPermissionDenied = require_makeTemporaryFile.MakeTemporaryFileErrorPermissionDenied;
+exports.MakeTemporaryFileErrorReadOnly = require_makeTemporaryFile.MakeTemporaryFileErrorReadOnly;
+exports.MakeTemporaryFileErrorTooManyOpenFiles = require_makeTemporaryFile.MakeTemporaryFileErrorTooManyOpenFiles;
+exports.MoveError = require_move.MoveError;
+exports.MoveErrorAlreadyExists = require_move.MoveErrorAlreadyExists;
+exports.MoveErrorBusy = require_move.MoveErrorBusy;
+exports.MoveErrorCrossDevice = require_move.MoveErrorCrossDevice;
+exports.MoveErrorDirectoryNotEmpty = require_move.MoveErrorDirectoryNotEmpty;
+exports.MoveErrorInvalidArgument = require_move.MoveErrorInvalidArgument;
+exports.MoveErrorIsDirectory = require_move.MoveErrorIsDirectory;
+exports.MoveErrorNotDirectory = require_move.MoveErrorNotDirectory;
+exports.MoveErrorNotFound = require_move.MoveErrorNotFound;
+exports.MoveErrorPermissionDenied = require_move.MoveErrorPermissionDenied;
+exports.MoveErrorReadOnly = require_move.MoveErrorReadOnly;
+exports.ReadDirectoryError = require_readDirectory.ReadDirectoryError;
+exports.ReadDirectoryErrorBusy = require_readDirectory.ReadDirectoryErrorBusy;
+exports.ReadDirectoryErrorNotDirectory = require_readDirectory.ReadDirectoryErrorNotDirectory;
+exports.ReadDirectoryErrorNotFound = require_readDirectory.ReadDirectoryErrorNotFound;
+exports.ReadDirectoryErrorPermissionDenied = require_readDirectory.ReadDirectoryErrorPermissionDenied;
+exports.ReadDirectoryErrorTooManyOpenFiles = require_readDirectory.ReadDirectoryErrorTooManyOpenFiles;
+exports.ReadFileError = require_readFile.ReadFileError;
+exports.ReadFileErrorBusy = require_readFile.ReadFileErrorBusy;
+exports.ReadFileErrorIsDirectory = require_readFile.ReadFileErrorIsDirectory;
+exports.ReadFileErrorNotDirectory = require_readFile.ReadFileErrorNotDirectory;
+exports.ReadFileErrorNotFound = require_readFile.ReadFileErrorNotFound;
+exports.ReadFileErrorPermissionDenied = require_readFile.ReadFileErrorPermissionDenied;
+exports.ReadFileErrorTooManyOpenFiles = require_readFile.ReadFileErrorTooManyOpenFiles;
+exports.ReadJsonFileError = require_readJsonFile.ReadJsonFileError;
+exports.ReadJsonFileErrorBusy = require_readJsonFile.ReadJsonFileErrorBusy;
+exports.ReadJsonFileErrorIsDirectory = require_readJsonFile.ReadJsonFileErrorIsDirectory;
+exports.ReadJsonFileErrorNotDirectory = require_readJsonFile.ReadJsonFileErrorNotDirectory;
+exports.ReadJsonFileErrorNotFound = require_readJsonFile.ReadJsonFileErrorNotFound;
+exports.ReadJsonFileErrorPermissionDenied = require_readJsonFile.ReadJsonFileErrorPermissionDenied;
+exports.ReadJsonFileErrorTooManyOpenFiles = require_readJsonFile.ReadJsonFileErrorTooManyOpenFiles;
+exports.ReadLinkError = require_readLink.ReadLinkError;
+exports.ReadLinkErrorInvalidArgument = require_readLink.ReadLinkErrorInvalidArgument;
+exports.ReadLinkErrorNotDirectory = require_readLink.ReadLinkErrorNotDirectory;
+exports.ReadLinkErrorNotFound = require_readLink.ReadLinkErrorNotFound;
+exports.ReadLinkErrorPermissionDenied = require_readLink.ReadLinkErrorPermissionDenied;
+exports.ReadLinkErrorTooManyOpenFiles = require_readLink.ReadLinkErrorTooManyOpenFiles;
+exports.ReadTextFileError = require_readTextFile.ReadTextFileError;
+exports.ReadTextFileErrorBusy = require_readTextFile.ReadTextFileErrorBusy;
+exports.ReadTextFileErrorIsDirectory = require_readTextFile.ReadTextFileErrorIsDirectory;
+exports.ReadTextFileErrorNotDirectory = require_readTextFile.ReadTextFileErrorNotDirectory;
+exports.ReadTextFileErrorNotFound = require_readTextFile.ReadTextFileErrorNotFound;
+exports.ReadTextFileErrorPermissionDenied = require_readTextFile.ReadTextFileErrorPermissionDenied;
+exports.ReadTextFileErrorTooManyOpenFiles = require_readTextFile.ReadTextFileErrorTooManyOpenFiles;
+exports.RealPathError = require_realPath.RealPathError;
+exports.RealPathErrorNotDirectory = require_realPath.RealPathErrorNotDirectory;
+exports.RealPathErrorNotFound = require_realPath.RealPathErrorNotFound;
+exports.RealPathErrorPermissionDenied = require_realPath.RealPathErrorPermissionDenied;
+exports.RealPathErrorTooManyOpenFiles = require_realPath.RealPathErrorTooManyOpenFiles;
+exports.RelocateError = require_relocate.RelocateError;
+exports.RelocateErrorAlreadyExists = require_relocate.RelocateErrorAlreadyExists;
+exports.RelocateErrorBusy = require_relocate.RelocateErrorBusy;
+exports.RelocateErrorCrossDevice = require_relocate.RelocateErrorCrossDevice;
+exports.RelocateErrorDirectoryNotEmpty = require_relocate.RelocateErrorDirectoryNotEmpty;
+exports.RelocateErrorInvalidArgument = require_relocate.RelocateErrorInvalidArgument;
+exports.RelocateErrorIsDirectory = require_relocate.RelocateErrorIsDirectory;
+exports.RelocateErrorNotDirectory = require_relocate.RelocateErrorNotDirectory;
+exports.RelocateErrorNotFound = require_relocate.RelocateErrorNotFound;
+exports.RelocateErrorPermissionDenied = require_relocate.RelocateErrorPermissionDenied;
+exports.RelocateErrorReadOnly = require_relocate.RelocateErrorReadOnly;
+exports.RemoveError = require_remove.RemoveError;
+exports.RemoveErrorBusy = require_remove.RemoveErrorBusy;
+exports.RemoveErrorDirectoryNotEmpty = require_remove.RemoveErrorDirectoryNotEmpty;
+exports.RemoveErrorInvalidArgument = require_remove.RemoveErrorInvalidArgument;
+exports.RemoveErrorIsDirectory = require_remove.RemoveErrorIsDirectory;
+exports.RemoveErrorNotDirectory = require_remove.RemoveErrorNotDirectory;
+exports.RemoveErrorNotFound = require_remove.RemoveErrorNotFound;
+exports.RemoveErrorPermissionDenied = require_remove.RemoveErrorPermissionDenied;
+exports.RemoveErrorReadOnly = require_remove.RemoveErrorReadOnly;
+exports.RenameError = require_rename.RenameError;
+exports.RenameErrorAlreadyExists = require_rename.RenameErrorAlreadyExists;
+exports.RenameErrorBusy = require_rename.RenameErrorBusy;
+exports.RenameErrorCrossDevice = require_rename.RenameErrorCrossDevice;
+exports.RenameErrorDirectoryNotEmpty = require_rename.RenameErrorDirectoryNotEmpty;
+exports.RenameErrorInvalidArgument = require_rename.RenameErrorInvalidArgument;
+exports.RenameErrorIsDirectory = require_rename.RenameErrorIsDirectory;
+exports.RenameErrorNotDirectory = require_rename.RenameErrorNotDirectory;
+exports.RenameErrorNotFound = require_rename.RenameErrorNotFound;
+exports.RenameErrorPermissionDenied = require_rename.RenameErrorPermissionDenied;
+exports.RenameErrorReadOnly = require_rename.RenameErrorReadOnly;
+exports.SetModeError = require_setMode.SetModeError;
+exports.SetModeErrorInvalidArgument = require_setMode.SetModeErrorInvalidArgument;
+exports.SetModeErrorNotDirectory = require_setMode.SetModeErrorNotDirectory;
+exports.SetModeErrorNotFound = require_setMode.SetModeErrorNotFound;
+exports.SetModeErrorPermissionDenied = require_setMode.SetModeErrorPermissionDenied;
+exports.SetModeErrorReadOnly = require_setMode.SetModeErrorReadOnly;
+exports.SetOwnerError = require_setOwner.SetOwnerError;
+exports.SetOwnerErrorInvalidArgument = require_setOwner.SetOwnerErrorInvalidArgument;
+exports.SetOwnerErrorNotDirectory = require_setOwner.SetOwnerErrorNotDirectory;
+exports.SetOwnerErrorNotFound = require_setOwner.SetOwnerErrorNotFound;
+exports.SetOwnerErrorPermissionDenied = require_setOwner.SetOwnerErrorPermissionDenied;
+exports.SetOwnerErrorReadOnly = require_setOwner.SetOwnerErrorReadOnly;
+exports.SetTimeError = require_setTime.SetTimeError;
+exports.SetTimeErrorInvalidArgument = require_setTime.SetTimeErrorInvalidArgument;
+exports.SetTimeErrorNotDirectory = require_setTime.SetTimeErrorNotDirectory;
+exports.SetTimeErrorNotFound = require_setTime.SetTimeErrorNotFound;
+exports.SetTimeErrorPermissionDenied = require_setTime.SetTimeErrorPermissionDenied;
+exports.SetTimeErrorReadOnly = require_setTime.SetTimeErrorReadOnly;
+exports.StatError = require_stat.StatError;
+exports.StatErrorBusy = require_stat.StatErrorBusy;
+exports.StatErrorNotDirectory = require_stat.StatErrorNotDirectory;
+exports.StatErrorNotFound = require_stat.StatErrorNotFound;
+exports.StatErrorPermissionDenied = require_stat.StatErrorPermissionDenied;
+exports.StatErrorTooManyOpenFiles = require_stat.StatErrorTooManyOpenFiles;
+exports.SymlinkError = require_symlink.SymlinkError;
+exports.SymlinkErrorAlreadyExists = require_symlink.SymlinkErrorAlreadyExists;
+exports.SymlinkErrorBusy = require_symlink.SymlinkErrorBusy;
+exports.SymlinkErrorInvalidArgument = require_symlink.SymlinkErrorInvalidArgument;
+exports.SymlinkErrorNotDirectory = require_symlink.SymlinkErrorNotDirectory;
+exports.SymlinkErrorNotFound = require_symlink.SymlinkErrorNotFound;
+exports.SymlinkErrorPermissionDenied = require_symlink.SymlinkErrorPermissionDenied;
+exports.SymlinkErrorReadOnly = require_symlink.SymlinkErrorReadOnly;
+exports.SymlinkErrorTooManyOpenFiles = require_symlink.SymlinkErrorTooManyOpenFiles;
+exports.TruncateError = require_truncate.TruncateError;
+exports.TruncateErrorBusy = require_truncate.TruncateErrorBusy;
+exports.TruncateErrorInvalidArgument = require_truncate.TruncateErrorInvalidArgument;
+exports.TruncateErrorIsDirectory = require_truncate.TruncateErrorIsDirectory;
+exports.TruncateErrorNoSpace = require_truncate.TruncateErrorNoSpace;
+exports.TruncateErrorNotDirectory = require_truncate.TruncateErrorNotDirectory;
+exports.TruncateErrorNotFound = require_truncate.TruncateErrorNotFound;
+exports.TruncateErrorPermissionDenied = require_truncate.TruncateErrorPermissionDenied;
+exports.TruncateErrorReadOnly = require_truncate.TruncateErrorReadOnly;
+exports.TruncateErrorTooManyOpenFiles = require_truncate.TruncateErrorTooManyOpenFiles;
+exports.WalkDirectoryError = require_walkDirectory.WalkDirectoryError;
+exports.WalkDirectoryErrorBusy = require_walkDirectory.WalkDirectoryErrorBusy;
+exports.WalkDirectoryErrorNotDirectory = require_walkDirectory.WalkDirectoryErrorNotDirectory;
+exports.WalkDirectoryErrorNotFound = require_walkDirectory.WalkDirectoryErrorNotFound;
+exports.WalkDirectoryErrorPermissionDenied = require_walkDirectory.WalkDirectoryErrorPermissionDenied;
+exports.WalkDirectoryErrorTooManyOpenFiles = require_walkDirectory.WalkDirectoryErrorTooManyOpenFiles;
+exports.WriteFileError = require_writeFile.WriteFileError;
+exports.WriteFileErrorBusy = require_writeFile.WriteFileErrorBusy;
+exports.WriteFileErrorInvalidArgument = require_writeFile.WriteFileErrorInvalidArgument;
+exports.WriteFileErrorIsDirectory = require_writeFile.WriteFileErrorIsDirectory;
+exports.WriteFileErrorNoSpace = require_writeFile.WriteFileErrorNoSpace;
+exports.WriteFileErrorNotDirectory = require_writeFile.WriteFileErrorNotDirectory;
+exports.WriteFileErrorNotFound = require_writeFile.WriteFileErrorNotFound;
+exports.WriteFileErrorPermissionDenied = require_writeFile.WriteFileErrorPermissionDenied;
+exports.WriteFileErrorReadOnly = require_writeFile.WriteFileErrorReadOnly;
+exports.WriteFileErrorTooManyOpenFiles = require_writeFile.WriteFileErrorTooManyOpenFiles;
+exports.WriteJsonFileError = require_writeJsonFile.WriteJsonFileError;
+exports.WriteJsonFileErrorBusy = require_writeJsonFile.WriteJsonFileErrorBusy;
+exports.WriteJsonFileErrorInvalidArgument = require_writeJsonFile.WriteJsonFileErrorInvalidArgument;
+exports.WriteJsonFileErrorIsDirectory = require_writeJsonFile.WriteJsonFileErrorIsDirectory;
+exports.WriteJsonFileErrorNoSpace = require_writeJsonFile.WriteJsonFileErrorNoSpace;
+exports.WriteJsonFileErrorNotDirectory = require_writeJsonFile.WriteJsonFileErrorNotDirectory;
+exports.WriteJsonFileErrorNotFound = require_writeJsonFile.WriteJsonFileErrorNotFound;
+exports.WriteJsonFileErrorPermissionDenied = require_writeJsonFile.WriteJsonFileErrorPermissionDenied;
+exports.WriteJsonFileErrorReadOnly = require_writeJsonFile.WriteJsonFileErrorReadOnly;
+exports.WriteJsonFileErrorTooManyOpenFiles = require_writeJsonFile.WriteJsonFileErrorTooManyOpenFiles;
+exports.WriteTextFileError = require_writeTextFile.WriteTextFileError;
+exports.WriteTextFileErrorBusy = require_writeTextFile.WriteTextFileErrorBusy;
+exports.WriteTextFileErrorInvalidArgument = require_writeTextFile.WriteTextFileErrorInvalidArgument;
+exports.WriteTextFileErrorIsDirectory = require_writeTextFile.WriteTextFileErrorIsDirectory;
+exports.WriteTextFileErrorNoSpace = require_writeTextFile.WriteTextFileErrorNoSpace;
+exports.WriteTextFileErrorNotDirectory = require_writeTextFile.WriteTextFileErrorNotDirectory;
+exports.WriteTextFileErrorNotFound = require_writeTextFile.WriteTextFileErrorNotFound;
+exports.WriteTextFileErrorPermissionDenied = require_writeTextFile.WriteTextFileErrorPermissionDenied;
+exports.WriteTextFileErrorReadOnly = require_writeTextFile.WriteTextFileErrorReadOnly;
+exports.WriteTextFileErrorTooManyOpenFiles = require_writeTextFile.WriteTextFileErrorTooManyOpenFiles;
 exports.appendFile = require_appendFile.appendFile;
 exports.appendTextFile = require_appendTextFile.appendTextFile;
 exports.copy = require_copy.copy;