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

package/dist/file/ensureDirectory.d.ts

@@ -1,10 +1,36 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type EnsureDirectoryResult = FileSystemEither<DEither.Right<"ensure-directory", void> | DEither.Left<"ensure-directory-permission-denied", unknown> | DEither.Left<"ensure-directory-not-directory", unknown> | DEither.Left<"ensure-directory-no-space", unknown> | DEither.Left<"ensure-directory-read-only", unknown> | DEither.Left<"ensure-directory-invalid-argument", unknown> | DEither.Left<"ensure-directory-too-many-open-files", unknown> | DEither.Left<"ensure-directory-busy", unknown> | DEither.Left<"ensure-directory-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const EnsureDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-permission-denied", unknown>>, unknown>;
+declare class EnsureDirectoryErrorPermissionDenied extends EnsureDirectoryErrorPermissionDenied_base {
+}
+declare const EnsureDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-not-directory", unknown>>, unknown>;
+declare class EnsureDirectoryErrorNotDirectory extends EnsureDirectoryErrorNotDirectory_base {
+}
+declare const EnsureDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-no-space", unknown>>, unknown>;
+declare class EnsureDirectoryErrorNoSpace extends EnsureDirectoryErrorNoSpace_base {
+}
+declare const EnsureDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-read-only", unknown>>, unknown>;
+declare class EnsureDirectoryErrorReadOnly extends EnsureDirectoryErrorReadOnly_base {
+}
+declare const EnsureDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-invalid-argument", unknown>>, unknown>;
+declare class EnsureDirectoryErrorInvalidArgument extends EnsureDirectoryErrorInvalidArgument_base {
+}
+declare const EnsureDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-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-ensure-directory-too-many-open-files", unknown>>, unknown>;
+declare class EnsureDirectoryErrorTooManyOpenFiles extends EnsureDirectoryErrorTooManyOpenFiles_base {
+}
+declare const EnsureDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-busy", unknown>>, unknown>;
+declare class EnsureDirectoryErrorBusy extends EnsureDirectoryErrorBusy_base {
+}
+declare const EnsureDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-error", unknown>>, unknown>;
+declare class EnsureDirectoryError extends EnsureDirectoryError_base {
+}
+export type EnsureDirectoryErrors = (EnsureDirectoryErrorPermissionDenied | EnsureDirectoryErrorNotDirectory | EnsureDirectoryErrorNoSpace | EnsureDirectoryErrorReadOnly | EnsureDirectoryErrorInvalidArgument | EnsureDirectoryErrorTooManyOpenFiles | EnsureDirectoryErrorBusy | EnsureDirectoryError);
+export type EnsureDirectoryResult = (DEither.Right<"file-system-ensure-directory", void> | DEither.Left<"file-system-ensure-directory-error", EnsureDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         ensureDirectory(path: string & DPath.Path): Promise<EnsureDirectoryResult>;
     }
 }
 export declare const ensureDirectory: (path: string & DPath.Path) => Promise<EnsureDirectoryResult>;
+export {};

package/dist/file/ensureDirectory.mjs

@@ -1,29 +1,40 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/ensureDirectory.ts
+var EnsureDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-permission-denied", Error) {};
+var EnsureDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-not-directory", Error) {};
+var EnsureDirectoryErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-no-space", Error) {};
+var EnsureDirectoryErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-read-only", Error) {};
+var EnsureDirectoryErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-invalid-argument", Error) {};
+var EnsureDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-too-many-open-files", Error) {};
+var EnsureDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-busy", Error) {};
+var EnsureDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-error", Error) {};
 function handleNodeEnsureDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-ensure-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-ensure-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-ensure-directory-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-ensure-directory-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-ensure-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-ensure-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-ensure-directory-busy", error);
+	let ensureDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureDirectoryError = new EnsureDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") ensureDirectoryError = new EnsureDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureDirectoryError = new EnsureDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureDirectoryError = new EnsureDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureDirectoryError = new EnsureDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureDirectoryError = new EnsureDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureDirectoryError = new EnsureDirectoryErrorBusy(error);
 	}
-	return DEither.left("file-system-ensure-directory-error", error);
+	if (ensureDirectoryError === void 0) ensureDirectoryError = new EnsureDirectoryError(error);
+	return DEither.left("file-system-ensure-directory-error", ensureDirectoryError);
 }
 function handleDenoEnsureDirectoryError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-ensure-directory-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-ensure-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-ensure-directory-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-ensure-directory-busy", error);
-	return DEither.left("file-system-ensure-directory-error", error);
+	let ensureDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureDirectoryError = new EnsureDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureDirectoryError = new EnsureDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureDirectoryError = new EnsureDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureDirectoryError = new EnsureDirectoryErrorBusy(error);
+	if (ensureDirectoryError === void 0) ensureDirectoryError = new EnsureDirectoryError(error);
+	return DEither.left("file-system-ensure-directory-error", ensureDirectoryError);
 }
 const ensureDirectory = implementFunction("ensureDirectory", {
-	NODE: async (path) => {
-		return (await nodeFileSystem.value).mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleNodeEnsureDirectoryError);
-	},
+	NODE: async (path) => nodeFileSystem.value.mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleNodeEnsureDirectoryError),
 	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
 });
 //#endregion

package/dist/file/ensureFile.cjs

@@ -1,33 +1,46 @@
 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/ensureFile.ts
+var EnsureFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-permission-denied", Error) {};
+var EnsureFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-is-directory", Error) {};
+var EnsureFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-not-directory", Error) {};
+var EnsureFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-no-space", Error) {};
+var EnsureFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-read-only", Error) {};
+var EnsureFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-invalid-argument", Error) {};
+var EnsureFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-too-many-open-files", Error) {};
+var EnsureFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-busy", Error) {};
+var EnsureFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-error", Error) {};
 function handleNodeEnsureFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-ensure-file-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-ensure-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-ensure-file-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-ensure-file-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-ensure-file-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-ensure-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-ensure-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-ensure-file-busy", error);
+	let ensureFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureFileError = new EnsureFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") ensureFileError = new EnsureFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") ensureFileError = new EnsureFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureFileError = new EnsureFileErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureFileError = new EnsureFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureFileError = new EnsureFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureFileError = new EnsureFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureFileError = new EnsureFileErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-ensure-file-error", error);
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return _duplojs_lang_either.left("file-system-ensure-file-error", ensureFileError);
 }
 function handleDenoEnsureFileError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-ensure-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-ensure-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-ensure-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-ensure-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-ensure-file-busy", error);
-	return _duplojs_lang_either.left("file-system-ensure-file-error", error);
+	let ensureFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureFileError = new EnsureFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) ensureFileError = new EnsureFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureFileError = new EnsureFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureFileError = new EnsureFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureFileError = new EnsureFileErrorBusy(error);
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return _duplojs_lang_either.left("file-system-ensure-file-error", ensureFileError);
 }
 const ensureFile = require_implementor.implementFunction("ensureFile", {
-	NODE: async (path) => {
-		return (await require_implementor.nodeFileSystem.value).open(path, "a").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleNodeEnsureFileError);
-	},
+	NODE: async (path) => require_implementor.nodeFileSystem.value.open(path, "a").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleNodeEnsureFileError),
 	DENO: (path) => Deno.open(path, {
 		write: true,
 		create: true,

package/dist/file/ensureFile.d.ts

@@ -1,10 +1,39 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type EnsureFileResult = FileSystemEither<DEither.Right<"ensure-file", void> | DEither.Left<"ensure-file-permission-denied", unknown> | DEither.Left<"ensure-file-is-directory", unknown> | DEither.Left<"ensure-file-not-directory", unknown> | DEither.Left<"ensure-file-no-space", unknown> | DEither.Left<"ensure-file-read-only", unknown> | DEither.Left<"ensure-file-invalid-argument", unknown> | DEither.Left<"ensure-file-too-many-open-files", unknown> | DEither.Left<"ensure-file-busy", unknown> | DEither.Left<"ensure-file-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const EnsureFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-permission-denied", unknown>>, unknown>;
+declare class EnsureFileErrorPermissionDenied extends EnsureFileErrorPermissionDenied_base {
+}
+declare const EnsureFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-is-directory", unknown>>, unknown>;
+declare class EnsureFileErrorIsDirectory extends EnsureFileErrorIsDirectory_base {
+}
+declare const EnsureFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-not-directory", unknown>>, unknown>;
+declare class EnsureFileErrorNotDirectory extends EnsureFileErrorNotDirectory_base {
+}
+declare const EnsureFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-no-space", unknown>>, unknown>;
+declare class EnsureFileErrorNoSpace extends EnsureFileErrorNoSpace_base {
+}
+declare const EnsureFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-read-only", unknown>>, unknown>;
+declare class EnsureFileErrorReadOnly extends EnsureFileErrorReadOnly_base {
+}
+declare const EnsureFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-invalid-argument", unknown>>, unknown>;
+declare class EnsureFileErrorInvalidArgument extends EnsureFileErrorInvalidArgument_base {
+}
+declare const EnsureFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-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-ensure-file-too-many-open-files", unknown>>, unknown>;
+declare class EnsureFileErrorTooManyOpenFiles extends EnsureFileErrorTooManyOpenFiles_base {
+}
+declare const EnsureFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-busy", unknown>>, unknown>;
+declare class EnsureFileErrorBusy extends EnsureFileErrorBusy_base {
+}
+declare const EnsureFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-error", unknown>>, unknown>;
+declare class EnsureFileError extends EnsureFileError_base {
+}
+export type EnsureFileErrors = (EnsureFileErrorPermissionDenied | EnsureFileErrorIsDirectory | EnsureFileErrorNotDirectory | EnsureFileErrorNoSpace | EnsureFileErrorReadOnly | EnsureFileErrorInvalidArgument | EnsureFileErrorTooManyOpenFiles | EnsureFileErrorBusy | EnsureFileError);
+export type EnsureFileResult = (DEither.Right<"file-system-ensure-file", void> | DEither.Left<"file-system-ensure-file-error", EnsureFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         ensureFile(path: string & DPath.Path): Promise<EnsureFileResult>;
     }
 }
 export declare const ensureFile: (path: string & DPath.Path) => Promise<EnsureFileResult>;
+export {};

package/dist/file/ensureFile.mjs

@@ -1,31 +1,43 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/ensureFile.ts
+var EnsureFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-permission-denied", Error) {};
+var EnsureFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-is-directory", Error) {};
+var EnsureFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-not-directory", Error) {};
+var EnsureFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-no-space", Error) {};
+var EnsureFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-read-only", Error) {};
+var EnsureFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-invalid-argument", Error) {};
+var EnsureFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-too-many-open-files", Error) {};
+var EnsureFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-busy", Error) {};
+var EnsureFileError = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-error", Error) {};
 function handleNodeEnsureFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-ensure-file-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-ensure-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-ensure-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-ensure-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-ensure-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-ensure-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-ensure-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-ensure-file-busy", error);
+	let ensureFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureFileError = new EnsureFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") ensureFileError = new EnsureFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") ensureFileError = new EnsureFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureFileError = new EnsureFileErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureFileError = new EnsureFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureFileError = new EnsureFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureFileError = new EnsureFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureFileError = new EnsureFileErrorBusy(error);
 	}
-	return DEither.left("file-system-ensure-file-error", error);
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return DEither.left("file-system-ensure-file-error", ensureFileError);
 }
 function handleDenoEnsureFileError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-ensure-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-ensure-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-ensure-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-ensure-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-ensure-file-busy", error);
-	return DEither.left("file-system-ensure-file-error", error);
+	let ensureFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureFileError = new EnsureFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) ensureFileError = new EnsureFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureFileError = new EnsureFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureFileError = new EnsureFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureFileError = new EnsureFileErrorBusy(error);
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return DEither.left("file-system-ensure-file-error", ensureFileError);
 }
 const ensureFile = implementFunction("ensureFile", {
-	NODE: async (path) => {
-		return (await nodeFileSystem.value).open(path, "a").then((fh) => fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleNodeEnsureFileError);
-	},
+	NODE: async (path) => nodeFileSystem.value.open(path, "a").then((fh) => fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleNodeEnsureFileError),
 	DENO: (path) => Deno.open(path, {
 		write: true,
 		create: true,

package/dist/file/exists.cjs

@@ -1,29 +1,38 @@
 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/exists.ts
+var ExistsErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-not-found", Error) {};
+var ExistsErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-permission-denied", Error) {};
+var ExistsErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-not-directory", Error) {};
+var ExistsErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-too-many-open-files", Error) {};
+var ExistsError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-error", Error) {};
 function handleNodeExistsError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-exists-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-exists-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-exists-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-exists-too-many-open-files", error);
+	let existsError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") existsError = new ExistsErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") existsError = new ExistsErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") existsError = new ExistsErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") existsError = new ExistsErrorTooManyOpenFiles(error);
 	}
-	return _duplojs_lang_either.left("file-system-exists-error", error);
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return _duplojs_lang_either.left("file-system-exists-error", existsError);
 }
 function handleDenoExistsError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-exists-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-exists-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-exists-not-directory", error);
-	return _duplojs_lang_either.left("file-system-exists-error", error);
+	let existsError = void 0;
+	if (error instanceof Deno.errors.NotFound) existsError = new ExistsErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) existsError = new ExistsErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) existsError = new ExistsErrorNotDirectory(error);
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return _duplojs_lang_either.left("file-system-exists-error", existsError);
 }
 const exists = require_implementor.implementFunction("exists", {
-	NODE: async (path) => {
-		return (await require_implementor.nodeFileSystem.value).access(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleNodeExistsError);
-	},
+	NODE: async (path) => require_implementor.nodeFileSystem.value.access(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleNodeExistsError),
 	DENO: (path) => Deno.stat(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleDenoExistsError),
-	BUN: (path) => Bun.file(path).exists().then((value) => value ? _duplojs_lang_either.right("file-system-exists") : _duplojs_lang_either.left("file-system-exists-not-found", /* @__PURE__ */ new Error("Path does not exist"))).catch(handleNodeExistsError)
+	BUN: (path) => Bun.file(path).exists().then((value) => value ? _duplojs_lang_either.right("file-system-exists") : _duplojs_lang_either.left("file-system-exists-error", new ExistsErrorNotFound(/* @__PURE__ */ new Error("Path does not exist")))).catch(handleNodeExistsError)
 });
 //#endregion
 exports.exists = exists;

package/dist/file/exists.d.ts

@@ -1,10 +1,27 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type ExistsResult = FileSystemEither<DEither.Right<"exists", void> | DEither.Left<"exists-not-found", unknown> | DEither.Left<"exists-permission-denied", unknown> | DEither.Left<"exists-not-directory", unknown> | DEither.Left<"exists-too-many-open-files", unknown> | DEither.Left<"exists-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const ExistsErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-not-found", unknown>>, unknown>;
+declare class ExistsErrorNotFound extends ExistsErrorNotFound_base {
+}
+declare const ExistsErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-permission-denied", unknown>>, unknown>;
+declare class ExistsErrorPermissionDenied extends ExistsErrorPermissionDenied_base {
+}
+declare const ExistsErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-not-directory", unknown>>, unknown>;
+declare class ExistsErrorNotDirectory extends ExistsErrorNotDirectory_base {
+}
+declare const ExistsErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-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-exists-too-many-open-files", unknown>>, unknown>;
+declare class ExistsErrorTooManyOpenFiles extends ExistsErrorTooManyOpenFiles_base {
+}
+declare const ExistsError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-error", unknown>>, unknown>;
+declare class ExistsError extends ExistsError_base {
+}
+export type ExistsErrors = (ExistsErrorNotFound | ExistsErrorPermissionDenied | ExistsErrorNotDirectory | ExistsErrorTooManyOpenFiles | ExistsError);
+export type ExistsResult = (DEither.Right<"file-system-exists", void> | DEither.Left<"file-system-exists-error", ExistsErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         exists(path: string & DPath.Path): Promise<ExistsResult>;
     }
 }
 export declare const exists: (path: string & DPath.Path) => Promise<ExistsResult>;
+export {};

package/dist/file/exists.mjs

@@ -1,27 +1,35 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/exists.ts
+var ExistsErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-exists-not-found", Error) {};
+var ExistsErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-exists-permission-denied", Error) {};
+var ExistsErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-exists-not-directory", Error) {};
+var ExistsErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-exists-too-many-open-files", Error) {};
+var ExistsError = class extends DCommon.DuploJSError.parentClass("file-system-exists-error", Error) {};
 function handleNodeExistsError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-exists-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-exists-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-exists-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-exists-too-many-open-files", error);
+	let existsError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") existsError = new ExistsErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") existsError = new ExistsErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") existsError = new ExistsErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") existsError = new ExistsErrorTooManyOpenFiles(error);
 	}
-	return DEither.left("file-system-exists-error", error);
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return DEither.left("file-system-exists-error", existsError);
 }
 function handleDenoExistsError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-exists-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-exists-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-exists-not-directory", error);
-	return DEither.left("file-system-exists-error", error);
+	let existsError = void 0;
+	if (error instanceof Deno.errors.NotFound) existsError = new ExistsErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) existsError = new ExistsErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) existsError = new ExistsErrorNotDirectory(error);
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return DEither.left("file-system-exists-error", existsError);
 }
 const exists = implementFunction("exists", {
-	NODE: async (path) => {
-		return (await nodeFileSystem.value).access(path).then(() => DEither.right("file-system-exists")).catch(handleNodeExistsError);
-	},
+	NODE: async (path) => nodeFileSystem.value.access(path).then(() => DEither.right("file-system-exists")).catch(handleNodeExistsError),
 	DENO: (path) => Deno.stat(path).then(() => DEither.right("file-system-exists")).catch(handleDenoExistsError),
-	BUN: (path) => Bun.file(path).exists().then((value) => value ? DEither.right("file-system-exists") : DEither.left("file-system-exists-not-found", /* @__PURE__ */ new Error("Path does not exist"))).catch(handleNodeExistsError)
+	BUN: (path) => Bun.file(path).exists().then((value) => value ? DEither.right("file-system-exists") : DEither.left("file-system-exists-error", new ExistsErrorNotFound(/* @__PURE__ */ new Error("Path does not exist")))).catch(handleNodeExistsError)
 });
 //#endregion
 export { exists };

package/dist/file/fileInterface.cjs

@@ -69,6 +69,8 @@ function createFileInterface(path) {
 function isFileInterface(input) {
 	return fileInterfaceKind.has(input);
 }
+const isFileInterfaceFromUnknown = isFileInterface;
 //#endregion
 exports.createFileInterface = createFileInterface;
 exports.isFileInterface = isFileInterface;
+exports.isFileInterfaceFromUnknown = isFileInterfaceFromUnknown;

package/dist/file/fileInterface.d.ts

@@ -4,6 +4,7 @@ import { MoveResult } from './move';
 import { RemoveResult } from './remove';
 import { StatResult } from './stat';
 import { RelocateResult } from './relocate';
+import { EntryPath } from './unknownEntryInterface';
 import type * as DKind from "@duplojs/lang/kind";
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
@@ -11,11 +12,11 @@ declare const fileInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/
 type FileInterfaceRenameResult = Exclude<RenameResult, DEither.Right> | DEither.Right<"file-system-rename", FileInterface>;
 type FileInterfaceRelocateResult = Exclude<RelocateResult, DEither.Right> | DEither.Right<"file-system-relocate", FileInterface>;
 type FileInterfaceMoveResult = Exclude<MoveResult, DEither.Right> | DEither.Right<"file-system-move", FileInterface>;
-export interface FileInterface extends DKind.Kind<typeof fileInterfaceKind> {
-    path: string & DPath.Path;
-    getName(): (string & DPath.Segment) | null;
+export interface FileInterface<GenericPath extends EntryPath = EntryPath> extends DKind.Kind<typeof fileInterfaceKind> {
+    path: GenericPath & DPath.Path;
+    getName(): (string & DPath.Segment & DPath.Path) | null;
     getMimeType(): string | null;
-    getExtension(params?: DPath.GetExtensionNameParams): (string & DPath.Segment) | null;
+    getExtension(params?: DPath.GetExtensionNameParams): (string & DPath.Segment & DPath.Path) | null;
     getParentPath(): (string & DPath.Path) | null;
     rename(newName: string & DPath.Segment): Promise<FileInterfaceRenameResult>;
     relocate(parentPath: string & DPath.Path): Promise<FileInterfaceRelocateResult>;
@@ -25,6 +26,7 @@ export interface FileInterface extends DKind.Kind<typeof fileInterfaceKind> {
     stat(): Promise<StatResult>;
     isFile(): Promise<boolean>;
 }
-export declare function createFileInterface(path: string & DPath.Path): FileInterface;
-export declare function isFileInterface(input: unknown): input is FileInterface;
+export declare function createFileInterface<GenericPath extends EntryPath = EntryPath>(path: GenericPath): FileInterface<GenericPath>;
+export declare function isFileInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, FileInterface>;
+export declare const isFileInterfaceFromUnknown: (input: unknown) => input is FileInterface;
 export {};

package/dist/file/fileInterface.mjs

@@ -65,5 +65,6 @@ function createFileInterface(path) {
 function isFileInterface(input) {
 	return fileInterfaceKind.has(input);
 }
+const isFileInterfaceFromUnknown = isFileInterface;
 //#endregion
-export { createFileInterface, isFileInterface };
+export { createFileInterface, isFileInterface, isFileInterfaceFromUnknown };

package/dist/file/folderInterface.cjs

@@ -69,6 +69,8 @@ function createFolderInterface(path) {
 function isFolderInterface(input) {
 	return folderInterfaceKind.has(input);
 }
+const isFolderInterfaceFromUnknown = isFolderInterface;
 //#endregion
 exports.createFolderInterface = createFolderInterface;
 exports.isFolderInterface = isFolderInterface;
+exports.isFolderInterfaceFromUnknown = isFolderInterfaceFromUnknown;

package/dist/file/folderInterface.d.ts

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

package/dist/file/folderInterface.mjs

@@ -65,5 +65,6 @@ function createFolderInterface(path) {
 function isFolderInterface(input) {
 	return folderInterfaceKind.has(input);
 }
+const isFolderInterfaceFromUnknown = isFolderInterface;
 //#endregion
-export { createFolderInterface, isFolderInterface };
+export { createFolderInterface, isFolderInterface, isFolderInterfaceFromUnknown };

package/dist/file/index.cjs

@@ -47,8 +47,11 @@ var file_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	ensureFile: () => require_ensureFile.ensureFile,
 	exists: () => require_exists.exists,
 	isFileInterface: () => require_fileInterface.isFileInterface,
+	isFileInterfaceFromUnknown: () => require_fileInterface.isFileInterfaceFromUnknown,
 	isFolderInterface: () => require_folderInterface.isFolderInterface,
+	isFolderInterfaceFromUnknown: () => require_folderInterface.isFolderInterfaceFromUnknown,
 	isUnknownEntryInterface: () => require_unknownEntryInterface.isUnknownEntryInterface,
+	isUnknownEntryInterfaceFromUnknown: () => require_unknownEntryInterface.isUnknownEntryInterfaceFromUnknown,
 	link: () => require_link.link,
 	linkStat: () => require_linkStat.linkStat,
 	makeDirectory: () => require_makeDirectory.makeDirectory,
@@ -93,8 +96,11 @@ Object.defineProperty(exports, "file_exports", {
 	}
 });
 exports.isFileInterface = require_fileInterface.isFileInterface;
+exports.isFileInterfaceFromUnknown = require_fileInterface.isFileInterfaceFromUnknown;
 exports.isFolderInterface = require_folderInterface.isFolderInterface;
+exports.isFolderInterfaceFromUnknown = require_folderInterface.isFolderInterfaceFromUnknown;
 exports.isUnknownEntryInterface = require_unknownEntryInterface.isUnknownEntryInterface;
+exports.isUnknownEntryInterfaceFromUnknown = require_unknownEntryInterface.isUnknownEntryInterfaceFromUnknown;
 exports.link = require_link.link;
 exports.linkStat = require_linkStat.linkStat;
 exports.makeDirectory = require_makeDirectory.makeDirectory;

package/dist/file/index.d.ts

@@ -28,7 +28,6 @@ export * from './setTime';
 export * from './stat';
 export * from './symlink';
 export * from './truncate';
-export type * from './types';
 export * from './unknownEntryInterface';
 export * from './walkDirectory';
 export * from './writeFile';