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

package/dist/file/setMode.cjs

@@ -5,22 +5,32 @@ _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/setMode.ts
+var SetModeErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-not-found", Error) {};
+var SetModeErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-permission-denied", Error) {};
+var SetModeErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-not-directory", Error) {};
+var SetModeErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-read-only", Error) {};
+var SetModeErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-invalid-argument", Error) {};
+var SetModeError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-error", Error) {};
 function handleNodeSetModeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-mode-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-mode-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-mode-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-mode-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-mode-invalid-argument", error);
+	let setModeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setModeError = new SetModeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setModeError = new SetModeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setModeError = new SetModeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setModeError = new SetModeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setModeError = new SetModeErrorInvalidArgument(error);
 	}
-	return _duplojs_lang_either.left("file-system-set-mode-error", error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", setModeError);
 }
 function handleDenoSetModeError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-mode-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-mode-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-mode-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-mode-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-set-mode-error", error);
+	let setModeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setModeError = new SetModeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setModeError = new SetModeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setModeError = new SetModeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setModeError = new SetModeErrorInvalidArgument(error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", setModeError);
 }
 function calculatePermissions(permissions) {
 	if (!permissions) return 0;
@@ -35,9 +45,7 @@ function toMode(mode) {
 	return special * 512 + user * 64 + group * 8 + other;
 }
 const setModeImplementation = require_implementor.implementFunction("setMode", {
-	NODE: async (path, mode) => {
-		return (await require_implementor.nodeFileSystem.value).chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleNodeSetModeError);
-	},
+	NODE: async (path, mode) => require_implementor.nodeFileSystem.value.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleNodeSetModeError),
 	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleDenoSetModeError)
 });
 function setMode(...args) {

package/dist/file/setMode.d.ts

@@ -1,4 +1,4 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 interface Permissions {
@@ -15,7 +15,26 @@ interface ModeObject {
     sticky?: boolean;
 }
 type SetMode = ModeObject | number;
-export type SetModeResult = FileSystemEither<DEither.Right<"set-mode", void> | DEither.Left<"set-mode-not-found", unknown> | DEither.Left<"set-mode-permission-denied", unknown> | DEither.Left<"set-mode-not-directory", unknown> | DEither.Left<"set-mode-read-only", unknown> | DEither.Left<"set-mode-invalid-argument", unknown> | DEither.Left<"set-mode-error", unknown>>;
+declare const SetModeErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-not-found", unknown>>, unknown>;
+declare class SetModeErrorNotFound extends SetModeErrorNotFound_base {
+}
+declare const SetModeErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-permission-denied", unknown>>, unknown>;
+declare class SetModeErrorPermissionDenied extends SetModeErrorPermissionDenied_base {
+}
+declare const SetModeErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-not-directory", unknown>>, unknown>;
+declare class SetModeErrorNotDirectory extends SetModeErrorNotDirectory_base {
+}
+declare const SetModeErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-read-only", unknown>>, unknown>;
+declare class SetModeErrorReadOnly extends SetModeErrorReadOnly_base {
+}
+declare const SetModeErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-invalid-argument", unknown>>, unknown>;
+declare class SetModeErrorInvalidArgument extends SetModeErrorInvalidArgument_base {
+}
+declare const SetModeError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-error", unknown>>, unknown>;
+declare class SetModeError extends SetModeError_base {
+}
+export type SetModeErrors = (SetModeErrorNotFound | SetModeErrorPermissionDenied | SetModeErrorNotDirectory | SetModeErrorReadOnly | SetModeErrorInvalidArgument | SetModeError);
+export type SetModeResult = (DEither.Right<"file-system-set-mode", void> | DEither.Left<"file-system-set-mode-error", SetModeErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         setMode(path: string & DPath.Path, mode: SetMode): Promise<SetModeResult>;

package/dist/file/setMode.mjs

@@ -2,22 +2,32 @@ import { implementFunction, nodeFileSystem } from "../implementor.mjs";
 import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/setMode.ts
+var SetModeErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-not-found", Error) {};
+var SetModeErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-permission-denied", Error) {};
+var SetModeErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-not-directory", Error) {};
+var SetModeErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-read-only", Error) {};
+var SetModeErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-invalid-argument", Error) {};
+var SetModeError = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-error", Error) {};
 function handleNodeSetModeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-set-mode-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-mode-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-mode-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-set-mode-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-set-mode-invalid-argument", error);
+	let setModeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setModeError = new SetModeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setModeError = new SetModeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setModeError = new SetModeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setModeError = new SetModeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setModeError = new SetModeErrorInvalidArgument(error);
 	}
-	return DEither.left("file-system-set-mode-error", error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return DEither.left("file-system-set-mode-error", setModeError);
 }
 function handleDenoSetModeError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-mode-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-mode-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-mode-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-mode-invalid-argument", error);
-	return DEither.left("file-system-set-mode-error", error);
+	let setModeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setModeError = new SetModeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setModeError = new SetModeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setModeError = new SetModeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setModeError = new SetModeErrorInvalidArgument(error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return DEither.left("file-system-set-mode-error", setModeError);
 }
 function calculatePermissions(permissions) {
 	if (!permissions) return 0;
@@ -32,9 +42,7 @@ function toMode(mode) {
 	return special * 512 + user * 64 + group * 8 + other;
 }
 const setModeImplementation = implementFunction("setMode", {
-	NODE: async (path, mode) => {
-		return (await nodeFileSystem.value).chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleNodeSetModeError);
-	},
+	NODE: async (path, mode) => nodeFileSystem.value.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleNodeSetModeError),
 	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleDenoSetModeError)
 });
 function setMode(...args) {

package/dist/file/setOwner.cjs

@@ -1,29 +1,39 @@
 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/setOwner.ts
+var SetOwnerErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-not-found", Error) {};
+var SetOwnerErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-permission-denied", Error) {};
+var SetOwnerErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-not-directory", Error) {};
+var SetOwnerErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-read-only", Error) {};
+var SetOwnerErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-invalid-argument", Error) {};
+var SetOwnerError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-error", Error) {};
 function handleNodeSetOwnerError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-owner-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-owner-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-owner-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-owner-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-owner-invalid-argument", error);
+	let setOwnerError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setOwnerError = new SetOwnerErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setOwnerError = new SetOwnerErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setOwnerError = new SetOwnerErrorNotDirectory(error);
+		else if (error.code === "EROFS") setOwnerError = new SetOwnerErrorReadOnly(error);
+		else if (error.code === "EINVAL") setOwnerError = new SetOwnerErrorInvalidArgument(error);
 	}
-	return _duplojs_lang_either.left("file-system-set-owner-error", error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", setOwnerError);
 }
 function handleDenoSetOwnerError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-owner-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-owner-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-owner-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-owner-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-set-owner-error", error);
+	let setOwnerError = void 0;
+	if (error instanceof Deno.errors.NotFound) setOwnerError = new SetOwnerErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setOwnerError = new SetOwnerErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setOwnerError = new SetOwnerErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", setOwnerError);
 }
 const setOwnerImplementation = require_implementor.implementFunction("setOwner", {
-	NODE: async (path, { userId, groupId }) => {
-		return (await require_implementor.nodeFileSystem.value).chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleNodeSetOwnerError);
-	},
+	NODE: async (path, { userId, groupId }) => require_implementor.nodeFileSystem.value.chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleNodeSetOwnerError),
 	DENO: (path, { userId, groupId }) => Deno.chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleDenoSetOwnerError)
 });
 function setOwner(...args) {

package/dist/file/setOwner.d.ts

@@ -1,11 +1,30 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 export interface SetOwnerParams {
     userId: number;
     groupId: number;
 }
-export type SetOwnerResult = FileSystemEither<DEither.Right<"set-owner", void> | DEither.Left<"set-owner-not-found", unknown> | DEither.Left<"set-owner-permission-denied", unknown> | DEither.Left<"set-owner-not-directory", unknown> | DEither.Left<"set-owner-read-only", unknown> | DEither.Left<"set-owner-invalid-argument", unknown> | DEither.Left<"set-owner-error", unknown>>;
+declare const SetOwnerErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-not-found", unknown>>, unknown>;
+declare class SetOwnerErrorNotFound extends SetOwnerErrorNotFound_base {
+}
+declare const SetOwnerErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-permission-denied", unknown>>, unknown>;
+declare class SetOwnerErrorPermissionDenied extends SetOwnerErrorPermissionDenied_base {
+}
+declare const SetOwnerErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-not-directory", unknown>>, unknown>;
+declare class SetOwnerErrorNotDirectory extends SetOwnerErrorNotDirectory_base {
+}
+declare const SetOwnerErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-read-only", unknown>>, unknown>;
+declare class SetOwnerErrorReadOnly extends SetOwnerErrorReadOnly_base {
+}
+declare const SetOwnerErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-invalid-argument", unknown>>, unknown>;
+declare class SetOwnerErrorInvalidArgument extends SetOwnerErrorInvalidArgument_base {
+}
+declare const SetOwnerError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-error", unknown>>, unknown>;
+declare class SetOwnerError extends SetOwnerError_base {
+}
+export type SetOwnerErrors = (SetOwnerErrorNotFound | SetOwnerErrorPermissionDenied | SetOwnerErrorNotDirectory | SetOwnerErrorReadOnly | SetOwnerErrorInvalidArgument | SetOwnerError);
+export type SetOwnerResult = (DEither.Right<"file-system-set-owner", void> | DEither.Left<"file-system-set-owner-error", SetOwnerErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         setOwner(path: string & DPath.Path, params: SetOwnerParams): Promise<SetOwnerResult>;
@@ -13,3 +32,4 @@ declare module '../implementor' {
 }
 export declare function setOwner(params: SetOwnerParams): (path: string & DPath.Path) => Promise<SetOwnerResult>;
 export declare function setOwner(path: string & DPath.Path, params: SetOwnerParams): Promise<SetOwnerResult>;
+export {};

package/dist/file/setOwner.mjs

@@ -1,27 +1,36 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/setOwner.ts
+var SetOwnerErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-not-found", Error) {};
+var SetOwnerErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-permission-denied", Error) {};
+var SetOwnerErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-not-directory", Error) {};
+var SetOwnerErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-read-only", Error) {};
+var SetOwnerErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-invalid-argument", Error) {};
+var SetOwnerError = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-error", Error) {};
 function handleNodeSetOwnerError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-set-owner-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-owner-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-owner-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-set-owner-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-set-owner-invalid-argument", error);
+	let setOwnerError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setOwnerError = new SetOwnerErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setOwnerError = new SetOwnerErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setOwnerError = new SetOwnerErrorNotDirectory(error);
+		else if (error.code === "EROFS") setOwnerError = new SetOwnerErrorReadOnly(error);
+		else if (error.code === "EINVAL") setOwnerError = new SetOwnerErrorInvalidArgument(error);
 	}
-	return DEither.left("file-system-set-owner-error", error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return DEither.left("file-system-set-owner-error", setOwnerError);
 }
 function handleDenoSetOwnerError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-owner-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-owner-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-owner-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-owner-invalid-argument", error);
-	return DEither.left("file-system-set-owner-error", error);
+	let setOwnerError = void 0;
+	if (error instanceof Deno.errors.NotFound) setOwnerError = new SetOwnerErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setOwnerError = new SetOwnerErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setOwnerError = new SetOwnerErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return DEither.left("file-system-set-owner-error", setOwnerError);
 }
 const setOwnerImplementation = implementFunction("setOwner", {
-	NODE: async (path, { userId, groupId }) => {
-		return (await nodeFileSystem.value).chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleNodeSetOwnerError);
-	},
+	NODE: async (path, { userId, groupId }) => nodeFileSystem.value.chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleNodeSetOwnerError),
 	DENO: (path, { userId, groupId }) => Deno.chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleDenoSetOwnerError)
 });
 function setOwner(...args) {

package/dist/file/setTime.cjs

@@ -1,31 +1,41 @@
 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);
 let _duplojs_lang_chrono = require("@duplojs/lang/chrono");
 _duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
 //#region scripts/file/setTime.ts
+var SetTimeErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-not-found", Error) {};
+var SetTimeErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-permission-denied", Error) {};
+var SetTimeErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-not-directory", Error) {};
+var SetTimeErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-read-only", Error) {};
+var SetTimeErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-invalid-argument", Error) {};
+var SetTimeError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-error", Error) {};
 function handleNodeSetTimeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-time-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-time-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-time-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-time-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-time-invalid-argument", error);
+	let setTimeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setTimeError = new SetTimeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setTimeError = new SetTimeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setTimeError = new SetTimeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setTimeError = new SetTimeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setTimeError = new SetTimeErrorInvalidArgument(error);
 	}
-	return _duplojs_lang_either.left("file-system-set-time-error", error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return _duplojs_lang_either.left("file-system-set-time-error", setTimeError);
 }
 function handleDenoSetTimeError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-time-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-time-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-time-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-time-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-set-time-error", error);
+	let setTimeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setTimeError = new SetTimeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setTimeError = new SetTimeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setTimeError = new SetTimeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setTimeError = new SetTimeErrorInvalidArgument(error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return _duplojs_lang_either.left("file-system-set-time-error", setTimeError);
 }
 const setTimeImplementation = require_implementor.implementFunction("setTime", {
-	NODE: async (path, { accessTime, modifiedTime }) => {
-		return (await require_implementor.nodeFileSystem.value).utimes(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleNodeSetTimeError);
-	},
+	NODE: async (path, { accessTime, modifiedTime }) => require_implementor.nodeFileSystem.value.utimes(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleNodeSetTimeError),
 	DENO: (path, { accessTime, modifiedTime }) => Deno.utime(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleDenoSetTimeError)
 });
 function setTime(...args) {

package/dist/file/setTime.d.ts

@@ -1,12 +1,31 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import * as DChrono from "@duplojs/lang/chrono";
 import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
 interface SetTimeParams {
     accessTime: DChrono.TheDate;
     modifiedTime: DChrono.TheDate;
 }
-export type SetTimeResult = FileSystemEither<DEither.Right<"set-time", void> | DEither.Left<"set-time-not-found", unknown> | DEither.Left<"set-time-permission-denied", unknown> | DEither.Left<"set-time-not-directory", unknown> | DEither.Left<"set-time-read-only", unknown> | DEither.Left<"set-time-invalid-argument", unknown> | DEither.Left<"set-time-error", unknown>>;
+declare const SetTimeErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-not-found", unknown>>, unknown>;
+declare class SetTimeErrorNotFound extends SetTimeErrorNotFound_base {
+}
+declare const SetTimeErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-permission-denied", unknown>>, unknown>;
+declare class SetTimeErrorPermissionDenied extends SetTimeErrorPermissionDenied_base {
+}
+declare const SetTimeErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-not-directory", unknown>>, unknown>;
+declare class SetTimeErrorNotDirectory extends SetTimeErrorNotDirectory_base {
+}
+declare const SetTimeErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-read-only", unknown>>, unknown>;
+declare class SetTimeErrorReadOnly extends SetTimeErrorReadOnly_base {
+}
+declare const SetTimeErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-invalid-argument", unknown>>, unknown>;
+declare class SetTimeErrorInvalidArgument extends SetTimeErrorInvalidArgument_base {
+}
+declare const SetTimeError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-error", unknown>>, unknown>;
+declare class SetTimeError extends SetTimeError_base {
+}
+export type SetTimeErrors = (SetTimeErrorNotFound | SetTimeErrorPermissionDenied | SetTimeErrorNotDirectory | SetTimeErrorReadOnly | SetTimeErrorInvalidArgument | SetTimeError);
+export type SetTimeResult = (DEither.Right<"file-system-set-time", void> | DEither.Left<"file-system-set-time-error", SetTimeErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         setTime(path: string & DPath.Path, params: SetTimeParams): Promise<SetTimeResult>;

package/dist/file/setTime.mjs

@@ -1,28 +1,37 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DChrono from "@duplojs/lang/chrono";
 //#region scripts/file/setTime.ts
+var SetTimeErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-time-not-found", Error) {};
+var SetTimeErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-time-permission-denied", Error) {};
+var SetTimeErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-time-not-directory", Error) {};
+var SetTimeErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-time-read-only", Error) {};
+var SetTimeErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-time-invalid-argument", Error) {};
+var SetTimeError = class extends DCommon.DuploJSError.parentClass("file-system-set-time-error", Error) {};
 function handleNodeSetTimeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-set-time-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-time-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-time-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-set-time-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-set-time-invalid-argument", error);
+	let setTimeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setTimeError = new SetTimeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setTimeError = new SetTimeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setTimeError = new SetTimeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setTimeError = new SetTimeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setTimeError = new SetTimeErrorInvalidArgument(error);
 	}
-	return DEither.left("file-system-set-time-error", error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return DEither.left("file-system-set-time-error", setTimeError);
 }
 function handleDenoSetTimeError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-time-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-time-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-time-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-time-invalid-argument", error);
-	return DEither.left("file-system-set-time-error", error);
+	let setTimeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setTimeError = new SetTimeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setTimeError = new SetTimeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setTimeError = new SetTimeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setTimeError = new SetTimeErrorInvalidArgument(error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return DEither.left("file-system-set-time-error", setTimeError);
 }
 const setTimeImplementation = implementFunction("setTime", {
-	NODE: async (path, { accessTime, modifiedTime }) => {
-		return (await nodeFileSystem.value).utimes(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleNodeSetTimeError);
-	},
+	NODE: async (path, { accessTime, modifiedTime }) => nodeFileSystem.value.utimes(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleNodeSetTimeError),
 	DENO: (path, { accessTime, modifiedTime }) => Deno.utime(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleDenoSetTimeError)
 });
 function setTime(...args) {

package/dist/file/stat.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/stat.ts
+var StatErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-not-found", Error) {};
+var StatErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-permission-denied", Error) {};
+var StatErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-not-directory", Error) {};
+var StatErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-too-many-open-files", Error) {};
+var StatErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-busy", Error) {};
+var StatError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-error", Error) {};
 function handleNodeStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-stat-busy", error);
+	let statError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") statError = new StatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") statError = new StatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") statError = new StatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") statError = new StatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") statError = new StatErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-stat-error", error);
+	if (statError === void 0) statError = new StatError(error);
+	return _duplojs_lang_either.left("file-system-stat-error", statError);
 }
 function handleDenoStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-stat-busy", error);
-	return _duplojs_lang_either.left("file-system-stat-error", error);
+	let statError = void 0;
+	if (error instanceof Deno.errors.NotFound) statError = new StatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) statError = new StatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) statError = new StatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) statError = new StatErrorBusy(error);
+	if (statError === void 0) statError = new StatError(error);
+	return _duplojs_lang_either.left("file-system-stat-error", statError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -75,9 +85,7 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const stat = require_implementor.implementFunction("stat", {
-	NODE: async (path) => {
-		return (await require_implementor.nodeFileSystem.value).stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError);
-	},
+	NODE: async (path) => require_implementor.nodeFileSystem.value.stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError),
 	DENO: (path) => Deno.stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithDeno, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleDenoStatError),
 	BUN: (path) => Bun.file(path).stat().then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError)
 });

package/dist/file/stat.d.ts

@@ -1,4 +1,4 @@
-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";
 import * as DChrono from "@duplojs/lang/chrono";
@@ -33,10 +33,30 @@ export interface StatInfo {
     isFifo: boolean | null;
     isSocket: boolean | null;
 }
-export type StatResult = FileSystemEither<DEither.Right<"stat", StatInfo> | DEither.Left<"stat-not-found", unknown> | DEither.Left<"stat-permission-denied", unknown> | DEither.Left<"stat-not-directory", unknown> | DEither.Left<"stat-too-many-open-files", unknown> | DEither.Left<"stat-busy", unknown> | DEither.Left<"stat-error", unknown>>;
+declare const StatErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-not-found", unknown>>, unknown>;
+declare class StatErrorNotFound extends StatErrorNotFound_base {
+}
+declare const StatErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-permission-denied", unknown>>, unknown>;
+declare class StatErrorPermissionDenied extends StatErrorPermissionDenied_base {
+}
+declare const StatErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-not-directory", unknown>>, unknown>;
+declare class StatErrorNotDirectory extends StatErrorNotDirectory_base {
+}
+declare const StatErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-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-stat-too-many-open-files", unknown>>, unknown>;
+declare class StatErrorTooManyOpenFiles extends StatErrorTooManyOpenFiles_base {
+}
+declare const StatErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-busy", unknown>>, unknown>;
+declare class StatErrorBusy extends StatErrorBusy_base {
+}
+declare const StatError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-error", unknown>>, unknown>;
+declare class StatError extends StatError_base {
+}
+export type StatErrors = (StatErrorNotFound | StatErrorPermissionDenied | StatErrorNotDirectory | StatErrorTooManyOpenFiles | StatErrorBusy | StatError);
+export type StatResult = (DEither.Right<"file-system-stat", StatInfo> | DEither.Left<"file-system-stat-error", StatErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         stat(path: string & DPath.Path): Promise<StatResult>;
     }
 }
 export declare const stat: (path: string & DPath.Path) => Promise<StatResult>;
+export {};