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

package/dist/file/index.mjs

@@ -8,11 +8,11 @@ import { exists } from "./exists.mjs";
 import { move } from "./move.mjs";
 import { remove } from "./remove.mjs";
 import { relocate } from "./relocate.mjs";
-import { createFileInterface, isFileInterface } from "./fileInterface.mjs";
+import { createFileInterface, isFileInterface, isFileInterfaceFromUnknown } from "./fileInterface.mjs";
 import { readDirectory } from "./readDirectory.mjs";
-import { createUnknownEntryInterface, isUnknownEntryInterface } from "./unknownEntryInterface.mjs";
+import { createUnknownEntryInterface, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown } from "./unknownEntryInterface.mjs";
 import { walkDirectory } from "./walkDirectory.mjs";
-import { createFolderInterface, isFolderInterface } from "./folderInterface.mjs";
+import { createFolderInterface, isFolderInterface, isFolderInterfaceFromUnknown } from "./folderInterface.mjs";
 import { createEntryInterface } from "./createEntryInterface.mjs";
 import { ensureDirectory } from "./ensureDirectory.mjs";
 import { ensureFile } from "./ensureFile.mjs";
@@ -47,8 +47,11 @@ var file_exports = /* @__PURE__ */ __exportAll({
 	ensureFile: () => ensureFile,
 	exists: () => exists,
 	isFileInterface: () => isFileInterface,
+	isFileInterfaceFromUnknown: () => isFileInterfaceFromUnknown,
 	isFolderInterface: () => isFolderInterface,
+	isFolderInterfaceFromUnknown: () => isFolderInterfaceFromUnknown,
 	isUnknownEntryInterface: () => isUnknownEntryInterface,
+	isUnknownEntryInterfaceFromUnknown: () => isUnknownEntryInterfaceFromUnknown,
 	link: () => link,
 	linkStat: () => linkStat,
 	makeDirectory: () => makeDirectory,
@@ -76,4 +79,4 @@ var file_exports = /* @__PURE__ */ __exportAll({
 	writeTextFile: () => writeTextFile
 });
 //#endregion
-export { appendFile, appendTextFile, copy, createEntryInterface, createFileInterface, createFolderInterface, createUnknownEntryInterface, ensureDirectory, ensureFile, exists, file_exports, isFileInterface, isFolderInterface, isUnknownEntryInterface, link, linkStat, makeDirectory, makeTemporaryDirectory, makeTemporaryFile, move, readDirectory, readFile, readJsonFile, readLink, readTextFile, realPath, relocate, remove, rename, setMode, setOwner, setTime, stat, symlink, truncate, walkDirectory, writeFile, writeJsonFile, writeTextFile };
+export { appendFile, appendTextFile, copy, createEntryInterface, createFileInterface, createFolderInterface, createUnknownEntryInterface, ensureDirectory, ensureFile, exists, file_exports, isFileInterface, isFileInterfaceFromUnknown, isFolderInterface, isFolderInterfaceFromUnknown, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown, link, linkStat, makeDirectory, makeTemporaryDirectory, makeTemporaryFile, move, readDirectory, readFile, readJsonFile, readLink, readTextFile, realPath, relocate, remove, rename, setMode, setOwner, setTime, stat, symlink, truncate, walkDirectory, writeFile, writeJsonFile, writeTextFile };

package/dist/file/link.cjs

@@ -1,36 +1,51 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 //#region scripts/file/link.ts
+var LinkErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-not-found", Error) {};
+var LinkErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-permission-denied", Error) {};
+var LinkErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-already-exists", Error) {};
+var LinkErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-not-directory", Error) {};
+var LinkErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-no-space", Error) {};
+var LinkErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-read-only", Error) {};
+var LinkErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-invalid-argument", Error) {};
+var LinkErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-too-many-open-files", Error) {};
+var LinkErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-busy", Error) {};
+var LinkErrorCrossDevice = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-cross-device", Error) {};
+var LinkError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-error", Error) {};
 function handleNodeLinkError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-link-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-link-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-link-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-link-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-link-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-link-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-link-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-link-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-link-busy", error);
-		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-link-cross-device", error);
+	let linkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkError = new LinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkError = new LinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") linkError = new LinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") linkError = new LinkErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") linkError = new LinkErrorNoSpace(error);
+		else if (error.code === "EROFS") linkError = new LinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") linkError = new LinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkError = new LinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkError = new LinkErrorBusy(error);
+		else if (error.code === "EXDEV") linkError = new LinkErrorCrossDevice(error);
 	}
-	return _duplojs_lang_either.left("file-system-link-error", error);
+	if (linkError === void 0) linkError = new LinkError(error);
+	return _duplojs_lang_either.left("file-system-link-error", linkError);
 }
 function handleDenoLinkError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-link-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-link-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-link-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-link-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-link-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-link-busy", error);
-	return _duplojs_lang_either.left("file-system-link-error", error);
+	let linkError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkError = new LinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkError = new LinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) linkError = new LinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkError = new LinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) linkError = new LinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) linkError = new LinkErrorBusy(error);
+	if (linkError === void 0) linkError = new LinkError(error);
+	return _duplojs_lang_either.left("file-system-link-error", linkError);
 }
 const linkImplementation = require_implementor.implementFunction("link", {
-	NODE: async (existingPath, newPath) => {
-		return (await require_implementor.nodeFileSystem.value).link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleNodeLinkError);
-	},
+	NODE: async (existingPath, newPath) => require_implementor.nodeFileSystem.value.link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleNodeLinkError),
 	DENO: (existingPath, newPath) => Deno.link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleDenoLinkError)
 });
 function link(...args) {

package/dist/file/link.d.ts

@@ -1,7 +1,41 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type LinkResult = FileSystemEither<DEither.Right<"link", void> | DEither.Left<"link-not-found", unknown> | DEither.Left<"link-permission-denied", unknown> | DEither.Left<"link-already-exists", unknown> | DEither.Left<"link-not-directory", unknown> | DEither.Left<"link-no-space", unknown> | DEither.Left<"link-read-only", unknown> | DEither.Left<"link-invalid-argument", unknown> | DEither.Left<"link-too-many-open-files", unknown> | DEither.Left<"link-busy", unknown> | DEither.Left<"link-cross-device", unknown> | DEither.Left<"link-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const LinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-not-found", unknown>>, unknown>;
+declare class LinkErrorNotFound extends LinkErrorNotFound_base {
+}
+declare const LinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-permission-denied", unknown>>, unknown>;
+declare class LinkErrorPermissionDenied extends LinkErrorPermissionDenied_base {
+}
+declare const LinkErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-already-exists", unknown>>, unknown>;
+declare class LinkErrorAlreadyExists extends LinkErrorAlreadyExists_base {
+}
+declare const LinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-not-directory", unknown>>, unknown>;
+declare class LinkErrorNotDirectory extends LinkErrorNotDirectory_base {
+}
+declare const LinkErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-no-space", unknown>>, unknown>;
+declare class LinkErrorNoSpace extends LinkErrorNoSpace_base {
+}
+declare const LinkErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-read-only", unknown>>, unknown>;
+declare class LinkErrorReadOnly extends LinkErrorReadOnly_base {
+}
+declare const LinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-invalid-argument", unknown>>, unknown>;
+declare class LinkErrorInvalidArgument extends LinkErrorInvalidArgument_base {
+}
+declare const LinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-too-many-open-files", unknown>>, unknown>;
+declare class LinkErrorTooManyOpenFiles extends LinkErrorTooManyOpenFiles_base {
+}
+declare const LinkErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-busy", unknown>>, unknown>;
+declare class LinkErrorBusy extends LinkErrorBusy_base {
+}
+declare const LinkErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-cross-device", unknown>>, unknown>;
+declare class LinkErrorCrossDevice extends LinkErrorCrossDevice_base {
+}
+declare const LinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-error", unknown>>, unknown>;
+declare class LinkError extends LinkError_base {
+}
+export type LinkErrors = (LinkErrorNotFound | LinkErrorPermissionDenied | LinkErrorAlreadyExists | LinkErrorNotDirectory | LinkErrorNoSpace | LinkErrorReadOnly | LinkErrorInvalidArgument | LinkErrorTooManyOpenFiles | LinkErrorBusy | LinkErrorCrossDevice | LinkError);
+export type LinkResult = (DEither.Right<"file-system-link", void> | DEither.Left<"file-system-link-error", LinkErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         link(existingPath: string & DPath.Path, newPath: string & DPath.Path): Promise<LinkResult>;
@@ -9,3 +43,4 @@ declare module '../implementor' {
 }
 export declare function link(newPath: string & DPath.Path): (existingPath: string & DPath.Path) => Promise<LinkResult>;
 export declare function link(existingPath: string & DPath.Path, newPath: string & DPath.Path): Promise<LinkResult>;
+export {};

package/dist/file/link.mjs

@@ -1,34 +1,48 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/link.ts
+var LinkErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-link-not-found", Error) {};
+var LinkErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-link-permission-denied", Error) {};
+var LinkErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-link-already-exists", Error) {};
+var LinkErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-link-not-directory", Error) {};
+var LinkErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-link-no-space", Error) {};
+var LinkErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-link-read-only", Error) {};
+var LinkErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-link-invalid-argument", Error) {};
+var LinkErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-link-too-many-open-files", Error) {};
+var LinkErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-link-busy", Error) {};
+var LinkErrorCrossDevice = class extends DCommon.DuploJSError.parentClass("file-system-link-cross-device", Error) {};
+var LinkError = class extends DCommon.DuploJSError.parentClass("file-system-link-error", Error) {};
 function handleNodeLinkError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-link-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-link-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-link-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-link-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-link-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-link-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-link-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-link-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-link-busy", error);
-		else if (error.code === "EXDEV") return DEither.left("file-system-link-cross-device", error);
+	let linkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkError = new LinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkError = new LinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") linkError = new LinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") linkError = new LinkErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") linkError = new LinkErrorNoSpace(error);
+		else if (error.code === "EROFS") linkError = new LinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") linkError = new LinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkError = new LinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkError = new LinkErrorBusy(error);
+		else if (error.code === "EXDEV") linkError = new LinkErrorCrossDevice(error);
 	}
-	return DEither.left("file-system-link-error", error);
+	if (linkError === void 0) linkError = new LinkError(error);
+	return DEither.left("file-system-link-error", linkError);
 }
 function handleDenoLinkError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-link-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-link-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-link-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-link-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-link-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-link-busy", error);
-	return DEither.left("file-system-link-error", error);
+	let linkError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkError = new LinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkError = new LinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) linkError = new LinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkError = new LinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) linkError = new LinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) linkError = new LinkErrorBusy(error);
+	if (linkError === void 0) linkError = new LinkError(error);
+	return DEither.left("file-system-link-error", linkError);
 }
 const linkImplementation = implementFunction("link", {
-	NODE: async (existingPath, newPath) => {
-		return (await nodeFileSystem.value).link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleNodeLinkError);
-	},
+	NODE: async (existingPath, newPath) => nodeFileSystem.value.link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleNodeLinkError),
 	DENO: (existingPath, newPath) => Deno.link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleDenoLinkError)
 });
 function link(...args) {

package/dist/file/linkStat.cjs

@@ -7,22 +7,32 @@ _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_chrono = require("@duplojs/lang/chrono");
 _duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
 //#region scripts/file/linkStat.ts
+var LinkStatErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-not-found", Error) {};
+var LinkStatErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-permission-denied", Error) {};
+var LinkStatErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-not-directory", Error) {};
+var LinkStatErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-too-many-open-files", Error) {};
+var LinkStatErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-busy", Error) {};
+var LinkStatError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-error", Error) {};
 function handleNodeLinkStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-link-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-link-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-link-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-link-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-link-stat-busy", error);
+	let linkStatError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkStatError = new LinkStatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkStatError = new LinkStatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") linkStatError = new LinkStatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkStatError = new LinkStatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkStatError = new LinkStatErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-link-stat-error", error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return _duplojs_lang_either.left("file-system-link-stat-error", linkStatError);
 }
 function handleDenoLinkStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-link-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-link-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-link-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-link-stat-busy", error);
-	return _duplojs_lang_either.left("file-system-link-stat-error", error);
+	let linkStatError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkStatError = new LinkStatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkStatError = new LinkStatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkStatError = new LinkStatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) linkStatError = new LinkStatErrorBusy(error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return _duplojs_lang_either.left("file-system-link-stat-error", linkStatError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -75,9 +85,7 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const linkStat = require_implementor.implementFunction("linkStat", {
-	NODE: async (path) => {
-		return (await require_implementor.nodeFileSystem.value).lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleNodeLinkStatError);
-	},
+	NODE: async (path) => require_implementor.nodeFileSystem.value.lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleNodeLinkStatError),
 	DENO: (path) => Deno.lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithDeno, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleDenoLinkStatError)
 });
 //#endregion

package/dist/file/linkStat.d.ts

@@ -1,11 +1,31 @@
 import { StatInfo } from './stat';
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type LinkStatResult = FileSystemEither<DEither.Right<"link-stat", StatInfo> | DEither.Left<"link-stat-not-found", unknown> | DEither.Left<"link-stat-permission-denied", unknown> | DEither.Left<"link-stat-not-directory", unknown> | DEither.Left<"link-stat-too-many-open-files", unknown> | DEither.Left<"link-stat-busy", unknown> | DEither.Left<"link-stat-error", unknown>>;
+declare const LinkStatErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-not-found", unknown>>, unknown>;
+declare class LinkStatErrorNotFound extends LinkStatErrorNotFound_base {
+}
+declare const LinkStatErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-permission-denied", unknown>>, unknown>;
+declare class LinkStatErrorPermissionDenied extends LinkStatErrorPermissionDenied_base {
+}
+declare const LinkStatErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-not-directory", unknown>>, unknown>;
+declare class LinkStatErrorNotDirectory extends LinkStatErrorNotDirectory_base {
+}
+declare const LinkStatErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-too-many-open-files", unknown>>, unknown>;
+declare class LinkStatErrorTooManyOpenFiles extends LinkStatErrorTooManyOpenFiles_base {
+}
+declare const LinkStatErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-busy", unknown>>, unknown>;
+declare class LinkStatErrorBusy extends LinkStatErrorBusy_base {
+}
+declare const LinkStatError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-error", unknown>>, unknown>;
+declare class LinkStatError extends LinkStatError_base {
+}
+export type LinkStatErrors = (LinkStatErrorNotFound | LinkStatErrorPermissionDenied | LinkStatErrorNotDirectory | LinkStatErrorTooManyOpenFiles | LinkStatErrorBusy | LinkStatError);
+export type LinkStatResult = (DEither.Right<"file-system-link-stat", StatInfo> | DEither.Left<"file-system-link-stat-error", LinkStatErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         linkStat(path: string & DPath.Path): Promise<LinkStatResult>;
     }
 }
 export declare const linkStat: (path: string & DPath.Path) => Promise<LinkStatResult>;
+export {};

package/dist/file/linkStat.mjs

@@ -3,22 +3,32 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DChrono from "@duplojs/lang/chrono";
 //#region scripts/file/linkStat.ts
+var LinkStatErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-not-found", Error) {};
+var LinkStatErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-permission-denied", Error) {};
+var LinkStatErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-not-directory", Error) {};
+var LinkStatErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-too-many-open-files", Error) {};
+var LinkStatErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-busy", Error) {};
+var LinkStatError = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-error", Error) {};
 function handleNodeLinkStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-link-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-link-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-link-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-link-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-link-stat-busy", error);
+	let linkStatError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkStatError = new LinkStatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkStatError = new LinkStatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") linkStatError = new LinkStatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkStatError = new LinkStatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkStatError = new LinkStatErrorBusy(error);
 	}
-	return DEither.left("file-system-link-stat-error", error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return DEither.left("file-system-link-stat-error", linkStatError);
 }
 function handleDenoLinkStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-link-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-link-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-link-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-link-stat-busy", error);
-	return DEither.left("file-system-link-stat-error", error);
+	let linkStatError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkStatError = new LinkStatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkStatError = new LinkStatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkStatError = new LinkStatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) linkStatError = new LinkStatErrorBusy(error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return DEither.left("file-system-link-stat-error", linkStatError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -71,9 +81,7 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const linkStat = implementFunction("linkStat", {
-	NODE: async (path) => {
-		return (await nodeFileSystem.value).lstat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-link-stat", value))).catch(handleNodeLinkStatError);
-	},
+	NODE: async (path) => nodeFileSystem.value.lstat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-link-stat", value))).catch(handleNodeLinkStatError),
 	DENO: (path) => Deno.lstat(path).then(DCommon.innerPipe(createStatInfoWithDeno, (value) => DEither.right("file-system-link-stat", value))).catch(handleDenoLinkStatError)
 });
 //#endregion

package/dist/file/makeDirectory.cjs

@@ -1,35 +1,49 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 //#region scripts/file/makeDirectory.ts
+var MakeDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-not-found", Error) {};
+var MakeDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-permission-denied", Error) {};
+var MakeDirectoryErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-already-exists", Error) {};
+var MakeDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-not-directory", Error) {};
+var MakeDirectoryErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-no-space", Error) {};
+var MakeDirectoryErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-read-only", Error) {};
+var MakeDirectoryErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-invalid-argument", Error) {};
+var MakeDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-too-many-open-files", Error) {};
+var MakeDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-busy", Error) {};
+var MakeDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-error", Error) {};
 function handleNodeMakeDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-make-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-directory-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-make-directory-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-directory-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-directory-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-make-directory-busy", error);
+	let makeDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeDirectoryError = new MakeDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeDirectoryError = new MakeDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeDirectoryError = new MakeDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") makeDirectoryError = new MakeDirectoryErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-make-directory-error", error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-directory-error", makeDirectoryError);
 }
 function handleDenoMakeDirectoryError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-make-directory-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-directory-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-make-directory-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-directory-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-make-directory-busy", error);
-	return _duplojs_lang_either.left("file-system-make-directory-error", error);
+	let makeDirectoryError = void 0;
+	if (error instanceof Deno.errors.NotFound) makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) makeDirectoryError = new MakeDirectoryErrorBusy(error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-directory-error", makeDirectoryError);
 }
 const makeDirectory = require_implementor.implementFunction("makeDirectory", {
-	NODE: async (path, params) => {
-		return (await require_implementor.nodeFileSystem.value).mkdir(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError);
-	},
+	NODE: async (path, params) => require_implementor.nodeFileSystem.value.mkdir(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError),
 	DENO: (path, params) => Deno.mkdir(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-make-directory")).catch(handleDenoMakeDirectoryError)
 });
 //#endregion

package/dist/file/makeDirectory.d.ts

@@ -1,10 +1,41 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
 interface MakeDirectoryParams {
     recursive?: boolean;
 }
-export type MakeDirectoryResult = FileSystemEither<DEither.Right<"make-directory", void> | DEither.Left<"make-directory-not-found", unknown> | DEither.Left<"make-directory-permission-denied", unknown> | DEither.Left<"make-directory-already-exists", unknown> | DEither.Left<"make-directory-not-directory", unknown> | DEither.Left<"make-directory-no-space", unknown> | DEither.Left<"make-directory-read-only", unknown> | DEither.Left<"make-directory-invalid-argument", unknown> | DEither.Left<"make-directory-too-many-open-files", unknown> | DEither.Left<"make-directory-busy", unknown> | DEither.Left<"make-directory-error", unknown>>;
+declare const MakeDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-not-found", unknown>>, unknown>;
+declare class MakeDirectoryErrorNotFound extends MakeDirectoryErrorNotFound_base {
+}
+declare const MakeDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-permission-denied", unknown>>, unknown>;
+declare class MakeDirectoryErrorPermissionDenied extends MakeDirectoryErrorPermissionDenied_base {
+}
+declare const MakeDirectoryErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-already-exists", unknown>>, unknown>;
+declare class MakeDirectoryErrorAlreadyExists extends MakeDirectoryErrorAlreadyExists_base {
+}
+declare const MakeDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-not-directory", unknown>>, unknown>;
+declare class MakeDirectoryErrorNotDirectory extends MakeDirectoryErrorNotDirectory_base {
+}
+declare const MakeDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-no-space", unknown>>, unknown>;
+declare class MakeDirectoryErrorNoSpace extends MakeDirectoryErrorNoSpace_base {
+}
+declare const MakeDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-read-only", unknown>>, unknown>;
+declare class MakeDirectoryErrorReadOnly extends MakeDirectoryErrorReadOnly_base {
+}
+declare const MakeDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-invalid-argument", unknown>>, unknown>;
+declare class MakeDirectoryErrorInvalidArgument extends MakeDirectoryErrorInvalidArgument_base {
+}
+declare const MakeDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-too-many-open-files", unknown>>, unknown>;
+declare class MakeDirectoryErrorTooManyOpenFiles extends MakeDirectoryErrorTooManyOpenFiles_base {
+}
+declare const MakeDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-busy", unknown>>, unknown>;
+declare class MakeDirectoryErrorBusy extends MakeDirectoryErrorBusy_base {
+}
+declare const MakeDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-error", unknown>>, unknown>;
+declare class MakeDirectoryError extends MakeDirectoryError_base {
+}
+export type MakeDirectoryErrors = (MakeDirectoryErrorNotFound | MakeDirectoryErrorPermissionDenied | MakeDirectoryErrorAlreadyExists | MakeDirectoryErrorNotDirectory | MakeDirectoryErrorNoSpace | MakeDirectoryErrorReadOnly | MakeDirectoryErrorInvalidArgument | MakeDirectoryErrorTooManyOpenFiles | MakeDirectoryErrorBusy | MakeDirectoryError);
+export type MakeDirectoryResult = (DEither.Right<"file-system-make-directory", void> | DEither.Left<"file-system-make-directory-error", MakeDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         makeDirectory(path: string & DPath.Path, params?: MakeDirectoryParams): Promise<MakeDirectoryResult>;