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

package/dist/file/appendFile.cjs

@@ -54,4 +54,14 @@ function appendFile(...args) {
 	return appendFileImplementation(...args);
 }
 //#endregion
+exports.AppendFileError = AppendFileError;
+exports.AppendFileErrorBusy = AppendFileErrorBusy;
+exports.AppendFileErrorInvalidArgument = AppendFileErrorInvalidArgument;
+exports.AppendFileErrorIsDirectory = AppendFileErrorIsDirectory;
+exports.AppendFileErrorNoSpace = AppendFileErrorNoSpace;
+exports.AppendFileErrorNotDirectory = AppendFileErrorNotDirectory;
+exports.AppendFileErrorNotFound = AppendFileErrorNotFound;
+exports.AppendFileErrorPermissionDenied = AppendFileErrorPermissionDenied;
+exports.AppendFileErrorReadOnly = AppendFileErrorReadOnly;
+exports.AppendFileErrorTooManyOpenFiles = AppendFileErrorTooManyOpenFiles;
 exports.appendFile = appendFile;

package/dist/file/appendFile.d.ts

@@ -2,42 +2,42 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import * as DCommon from "@duplojs/lang/common";
 declare const AppendFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-found", unknown>>, unknown>;
-declare class AppendFileErrorNotFound extends AppendFileErrorNotFound_base {
+export declare class AppendFileErrorNotFound extends AppendFileErrorNotFound_base {
 }
 declare const AppendFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-permission-denied", unknown>>, unknown>;
-declare class AppendFileErrorPermissionDenied extends AppendFileErrorPermissionDenied_base {
+export declare class AppendFileErrorPermissionDenied extends AppendFileErrorPermissionDenied_base {
 }
 declare const AppendFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-is-directory", unknown>>, unknown>;
-declare class AppendFileErrorIsDirectory extends AppendFileErrorIsDirectory_base {
+export declare class AppendFileErrorIsDirectory extends AppendFileErrorIsDirectory_base {
 }
 declare const AppendFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-directory", unknown>>, unknown>;
-declare class AppendFileErrorNotDirectory extends AppendFileErrorNotDirectory_base {
+export declare class AppendFileErrorNotDirectory extends AppendFileErrorNotDirectory_base {
 }
 declare const AppendFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-no-space", unknown>>, unknown>;
-declare class AppendFileErrorNoSpace extends AppendFileErrorNoSpace_base {
+export declare class AppendFileErrorNoSpace extends AppendFileErrorNoSpace_base {
 }
 declare const AppendFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-read-only", unknown>>, unknown>;
-declare class AppendFileErrorReadOnly extends AppendFileErrorReadOnly_base {
+export declare class AppendFileErrorReadOnly extends AppendFileErrorReadOnly_base {
 }
 declare const AppendFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-invalid-argument", unknown>>, unknown>;
-declare class AppendFileErrorInvalidArgument extends AppendFileErrorInvalidArgument_base {
+export declare class AppendFileErrorInvalidArgument extends AppendFileErrorInvalidArgument_base {
 }
 declare const AppendFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-file-too-many-open-files", unknown>>, unknown>;
-declare class AppendFileErrorTooManyOpenFiles extends AppendFileErrorTooManyOpenFiles_base {
+export declare class AppendFileErrorTooManyOpenFiles extends AppendFileErrorTooManyOpenFiles_base {
 }
 declare const AppendFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-busy", unknown>>, unknown>;
-declare class AppendFileErrorBusy extends AppendFileErrorBusy_base {
+export declare class AppendFileErrorBusy extends AppendFileErrorBusy_base {
 }
 declare const AppendFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-error", unknown>>, unknown>;
-declare class AppendFileError extends AppendFileError_base {
+export declare class AppendFileError extends AppendFileError_base {
 }
 export type AppendFileErrors = (AppendFileErrorNotFound | AppendFileErrorPermissionDenied | AppendFileErrorIsDirectory | AppendFileErrorNotDirectory | AppendFileErrorNoSpace | AppendFileErrorReadOnly | AppendFileErrorInvalidArgument | AppendFileErrorTooManyOpenFiles | AppendFileErrorBusy | AppendFileError);
 export type AppendFileResult = (DEither.Right<"file-system-append-file", void> | DEither.Left<"file-system-append-file-error", AppendFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
+        appendFile(path: DPath.AnyPath, data: Uint8Array): Promise<AppendFileResult>;
     }
 }
-export declare function appendFile(data: Uint8Array): (path: string & DPath.Path) => Promise<AppendFileResult>;
-export declare function appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
+export declare function appendFile(data: Uint8Array): (path: DPath.AnyPath) => Promise<AppendFileResult>;
+export declare function appendFile(path: DPath.AnyPath, data: Uint8Array): Promise<AppendFileResult>;
 export {};

package/dist/file/appendFile.mjs

@@ -51,4 +51,4 @@ function appendFile(...args) {
 	return appendFileImplementation(...args);
 }
 //#endregion
-export { appendFile };
+export { AppendFileError, AppendFileErrorBusy, AppendFileErrorInvalidArgument, AppendFileErrorIsDirectory, AppendFileErrorNoSpace, AppendFileErrorNotDirectory, AppendFileErrorNotFound, AppendFileErrorPermissionDenied, AppendFileErrorReadOnly, AppendFileErrorTooManyOpenFiles, appendFile };

package/dist/file/appendTextFile.cjs

@@ -54,4 +54,14 @@ function appendTextFile(...args) {
 	return appendTextFileImplementation(...args);
 }
 //#endregion
+exports.AppendTextFileError = AppendTextFileError;
+exports.AppendTextFileErrorBusy = AppendTextFileErrorBusy;
+exports.AppendTextFileErrorInvalidArgument = AppendTextFileErrorInvalidArgument;
+exports.AppendTextFileErrorIsDirectory = AppendTextFileErrorIsDirectory;
+exports.AppendTextFileErrorNoSpace = AppendTextFileErrorNoSpace;
+exports.AppendTextFileErrorNotDirectory = AppendTextFileErrorNotDirectory;
+exports.AppendTextFileErrorNotFound = AppendTextFileErrorNotFound;
+exports.AppendTextFileErrorPermissionDenied = AppendTextFileErrorPermissionDenied;
+exports.AppendTextFileErrorReadOnly = AppendTextFileErrorReadOnly;
+exports.AppendTextFileErrorTooManyOpenFiles = AppendTextFileErrorTooManyOpenFiles;
 exports.appendTextFile = appendTextFile;

package/dist/file/appendTextFile.d.ts

@@ -2,42 +2,42 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import * as DCommon from "@duplojs/lang/common";
 declare const AppendTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-not-found", unknown>>, unknown>;
-declare class AppendTextFileErrorNotFound extends AppendTextFileErrorNotFound_base {
+export declare class AppendTextFileErrorNotFound extends AppendTextFileErrorNotFound_base {
 }
 declare const AppendTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-permission-denied", unknown>>, unknown>;
-declare class AppendTextFileErrorPermissionDenied extends AppendTextFileErrorPermissionDenied_base {
+export declare class AppendTextFileErrorPermissionDenied extends AppendTextFileErrorPermissionDenied_base {
 }
 declare const AppendTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-is-directory", unknown>>, unknown>;
-declare class AppendTextFileErrorIsDirectory extends AppendTextFileErrorIsDirectory_base {
+export declare class AppendTextFileErrorIsDirectory extends AppendTextFileErrorIsDirectory_base {
 }
 declare const AppendTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-not-directory", unknown>>, unknown>;
-declare class AppendTextFileErrorNotDirectory extends AppendTextFileErrorNotDirectory_base {
+export declare class AppendTextFileErrorNotDirectory extends AppendTextFileErrorNotDirectory_base {
 }
 declare const AppendTextFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-no-space", unknown>>, unknown>;
-declare class AppendTextFileErrorNoSpace extends AppendTextFileErrorNoSpace_base {
+export declare class AppendTextFileErrorNoSpace extends AppendTextFileErrorNoSpace_base {
 }
 declare const AppendTextFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-read-only", unknown>>, unknown>;
-declare class AppendTextFileErrorReadOnly extends AppendTextFileErrorReadOnly_base {
+export declare class AppendTextFileErrorReadOnly extends AppendTextFileErrorReadOnly_base {
 }
 declare const AppendTextFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-invalid-argument", unknown>>, unknown>;
-declare class AppendTextFileErrorInvalidArgument extends AppendTextFileErrorInvalidArgument_base {
+export declare class AppendTextFileErrorInvalidArgument extends AppendTextFileErrorInvalidArgument_base {
 }
 declare const AppendTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-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-append-text-file-too-many-open-files", unknown>>, unknown>;
-declare class AppendTextFileErrorTooManyOpenFiles extends AppendTextFileErrorTooManyOpenFiles_base {
+export declare class AppendTextFileErrorTooManyOpenFiles extends AppendTextFileErrorTooManyOpenFiles_base {
 }
 declare const AppendTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-busy", unknown>>, unknown>;
-declare class AppendTextFileErrorBusy extends AppendTextFileErrorBusy_base {
+export declare class AppendTextFileErrorBusy extends AppendTextFileErrorBusy_base {
 }
 declare const AppendTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-error", unknown>>, unknown>;
-declare class AppendTextFileError extends AppendTextFileError_base {
+export declare class AppendTextFileError extends AppendTextFileError_base {
 }
 export type AppendTextFileErrors = (AppendTextFileErrorNotFound | AppendTextFileErrorPermissionDenied | AppendTextFileErrorIsDirectory | AppendTextFileErrorNotDirectory | AppendTextFileErrorNoSpace | AppendTextFileErrorReadOnly | AppendTextFileErrorInvalidArgument | AppendTextFileErrorTooManyOpenFiles | AppendTextFileErrorBusy | AppendTextFileError);
 export type AppendTextFileResult = (DEither.Right<"file-system-append-text-file", void> | DEither.Left<"file-system-append-text-file-error", AppendTextFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        appendTextFile(path: string & DPath.Path, data: string): Promise<AppendTextFileResult>;
+        appendTextFile(path: DPath.AnyPath, data: string): Promise<AppendTextFileResult>;
     }
 }
-export declare function appendTextFile(data: string): (path: string & DPath.Path) => Promise<AppendTextFileResult>;
-export declare function appendTextFile(path: string & DPath.Path, data: string): Promise<AppendTextFileResult>;
+export declare function appendTextFile(data: string): (path: DPath.AnyPath) => Promise<AppendTextFileResult>;
+export declare function appendTextFile(path: DPath.AnyPath, data: string): Promise<AppendTextFileResult>;
 export {};

package/dist/file/appendTextFile.mjs

@@ -51,4 +51,4 @@ function appendTextFile(...args) {
 	return appendTextFileImplementation(...args);
 }
 //#endregion
-export { appendTextFile };
+export { AppendTextFileError, AppendTextFileErrorBusy, AppendTextFileErrorInvalidArgument, AppendTextFileErrorIsDirectory, AppendTextFileErrorNoSpace, AppendTextFileErrorNotDirectory, AppendTextFileErrorNotFound, AppendTextFileErrorPermissionDenied, AppendTextFileErrorReadOnly, AppendTextFileErrorTooManyOpenFiles, appendTextFile };

package/dist/file/copy.cjs

@@ -40,4 +40,14 @@ function copy(...args) {
 	return copyImplementation(...args);
 }
 //#endregion
+exports.CopyError = CopyError;
+exports.CopyErrorAlreadyExists = CopyErrorAlreadyExists;
+exports.CopyErrorBusy = CopyErrorBusy;
+exports.CopyErrorInvalidArgument = CopyErrorInvalidArgument;
+exports.CopyErrorNoSpace = CopyErrorNoSpace;
+exports.CopyErrorNotDirectory = CopyErrorNotDirectory;
+exports.CopyErrorNotFound = CopyErrorNotFound;
+exports.CopyErrorPermissionDenied = CopyErrorPermissionDenied;
+exports.CopyErrorReadOnly = CopyErrorReadOnly;
+exports.CopyErrorTooManyOpenFiles = CopyErrorTooManyOpenFiles;
 exports.copy = copy;

package/dist/file/copy.d.ts

@@ -2,42 +2,42 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import * as DCommon from "@duplojs/lang/common";
 declare const CopyErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-not-found", unknown>>, unknown>;
-declare class CopyErrorNotFound extends CopyErrorNotFound_base {
+export declare class CopyErrorNotFound extends CopyErrorNotFound_base {
 }
 declare const CopyErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-permission-denied", unknown>>, unknown>;
-declare class CopyErrorPermissionDenied extends CopyErrorPermissionDenied_base {
+export declare class CopyErrorPermissionDenied extends CopyErrorPermissionDenied_base {
 }
 declare const CopyErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-already-exists", unknown>>, unknown>;
-declare class CopyErrorAlreadyExists extends CopyErrorAlreadyExists_base {
+export declare class CopyErrorAlreadyExists extends CopyErrorAlreadyExists_base {
 }
 declare const CopyErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-not-directory", unknown>>, unknown>;
-declare class CopyErrorNotDirectory extends CopyErrorNotDirectory_base {
+export declare class CopyErrorNotDirectory extends CopyErrorNotDirectory_base {
 }
 declare const CopyErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-no-space", unknown>>, unknown>;
-declare class CopyErrorNoSpace extends CopyErrorNoSpace_base {
+export declare class CopyErrorNoSpace extends CopyErrorNoSpace_base {
 }
 declare const CopyErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-read-only", unknown>>, unknown>;
-declare class CopyErrorReadOnly extends CopyErrorReadOnly_base {
+export declare class CopyErrorReadOnly extends CopyErrorReadOnly_base {
 }
 declare const CopyErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-invalid-argument", unknown>>, unknown>;
-declare class CopyErrorInvalidArgument extends CopyErrorInvalidArgument_base {
+export declare class CopyErrorInvalidArgument extends CopyErrorInvalidArgument_base {
 }
 declare const CopyErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-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-copy-too-many-open-files", unknown>>, unknown>;
-declare class CopyErrorTooManyOpenFiles extends CopyErrorTooManyOpenFiles_base {
+export declare class CopyErrorTooManyOpenFiles extends CopyErrorTooManyOpenFiles_base {
 }
 declare const CopyErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-busy", unknown>>, unknown>;
-declare class CopyErrorBusy extends CopyErrorBusy_base {
+export declare class CopyErrorBusy extends CopyErrorBusy_base {
 }
 declare const CopyError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-error", unknown>>, unknown>;
-declare class CopyError extends CopyError_base {
+export declare class CopyError extends CopyError_base {
 }
 export type CopyErrors = (CopyErrorNotFound | CopyErrorPermissionDenied | CopyErrorAlreadyExists | CopyErrorNotDirectory | CopyErrorNoSpace | CopyErrorReadOnly | CopyErrorInvalidArgument | CopyErrorTooManyOpenFiles | CopyErrorBusy | CopyError);
 export type CopyResult = (DEither.Right<"file-system-copy", void> | DEither.Left<"file-system-copy-error", CopyErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        copy(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<CopyResult>;
+        copy(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<CopyResult>;
     }
 }
-export declare function copy(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<CopyResult>;
-export declare function copy(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<CopyResult>;
+export declare function copy(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<CopyResult>;
+export declare function copy(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<CopyResult>;
 export {};

package/dist/file/copy.mjs

@@ -37,4 +37,4 @@ function copy(...args) {
 	return copyImplementation(...args);
 }
 //#endregion
-export { copy };
+export { CopyError, CopyErrorAlreadyExists, CopyErrorBusy, CopyErrorInvalidArgument, CopyErrorNoSpace, CopyErrorNotDirectory, CopyErrorNotFound, CopyErrorPermissionDenied, CopyErrorReadOnly, CopyErrorTooManyOpenFiles, copy };

package/dist/file/createEntryInterface.cjs

@@ -3,13 +3,16 @@ const require_stat = require("./stat.cjs");
 const require_fileInterface = require("./fileInterface.cjs");
 const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
 const require_folderInterface = require("./folderInterface.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
 _duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 //#region scripts/file/createEntryInterface.ts
 async function createEntryInterface(path) {
-	const result = await _duplojs_lang_either.rightAsyncPipe(require_stat.stat(path), _duplojs_lang_pattern.when(({ isFile }) => isFile, () => _duplojs_lang_either.right("file-interface", require_fileInterface.createFileInterface(path))), _duplojs_lang_pattern.when(({ isDirectory }) => isDirectory, () => _duplojs_lang_either.right("folder-interface", require_folderInterface.createFolderInterface(path))), _duplojs_lang_pattern.otherwise(() => _duplojs_lang_either.right("unknown-entry-interface", require_unknownEntryInterface.createUnknownEntryInterface(path))));
+	const entryPath = _duplojs_lang_common.cast(path);
+	const result = await _duplojs_lang_either.rightAsyncPipe(require_stat.stat(path), _duplojs_lang_pattern.when(({ isFile }) => isFile, () => _duplojs_lang_either.right("file-interface", require_fileInterface.createFileInterface(entryPath))), _duplojs_lang_pattern.when(({ isDirectory }) => isDirectory, () => _duplojs_lang_either.right("folder-interface", require_folderInterface.createFolderInterface(entryPath))), _duplojs_lang_pattern.otherwise(() => _duplojs_lang_either.right("unknown-entry-interface", require_unknownEntryInterface.createUnknownEntryInterface(entryPath))));
 	return _duplojs_lang_either.whenIsLeft(result, (value) => _duplojs_lang_either.left("create-entry-interface-error", value));
 }
 //#endregion

package/dist/file/createEntryInterface.d.ts

@@ -1,3 +1,3 @@
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export declare function createEntryInterface(path: string & DPath.Path): Promise<DEither.Right<"file-interface", import('./fileInterface').FileInterface<string & DPath.Path>> | DEither.Right<"folder-interface", import('./folderInterface').FolderInterface<string & DPath.Path>> | DEither.Right<"unknown-entry-interface", import('./unknownEntryInterface').UnknownEntryInterface<string & DPath.Path>> | DEither.Left<"create-entry-interface-error", import('./stat').StatErrors>>;
+export declare function createEntryInterface(path: DPath.AnyPath): Promise<DEither.Right<"file-interface", import('./fileInterface').FileInterface<string & DPath.Path>> | DEither.Right<"folder-interface", import('./folderInterface').FolderInterface<string & DPath.Path>> | DEither.Right<"unknown-entry-interface", import('./unknownEntryInterface').UnknownEntryInterface<string & DPath.Path>> | DEither.Left<"create-entry-interface-error", import('./stat').StatErrors>>;

package/dist/file/createEntryInterface.mjs

@@ -2,11 +2,13 @@ import { stat } from "./stat.mjs";
 import { createFileInterface } from "./fileInterface.mjs";
 import { createUnknownEntryInterface } from "./unknownEntryInterface.mjs";
 import { createFolderInterface } from "./folderInterface.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DPattern from "@duplojs/lang/pattern";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/createEntryInterface.ts
 async function createEntryInterface(path) {
-	const result = await DEither.rightAsyncPipe(stat(path), DPattern.when(({ isFile }) => isFile, () => DEither.right("file-interface", createFileInterface(path))), DPattern.when(({ isDirectory }) => isDirectory, () => DEither.right("folder-interface", createFolderInterface(path))), DPattern.otherwise(() => DEither.right("unknown-entry-interface", createUnknownEntryInterface(path))));
+	const entryPath = DCommon.cast(path);
+	const result = await DEither.rightAsyncPipe(stat(path), DPattern.when(({ isFile }) => isFile, () => DEither.right("file-interface", createFileInterface(entryPath))), DPattern.when(({ isDirectory }) => isDirectory, () => DEither.right("folder-interface", createFolderInterface(entryPath))), DPattern.otherwise(() => DEither.right("unknown-entry-interface", createUnknownEntryInterface(entryPath))));
 	return DEither.whenIsLeft(result, (value) => DEither.left("create-entry-interface-error", value));
 }
 //#endregion

package/dist/file/ensureDirectory.cjs

@@ -41,4 +41,12 @@ const ensureDirectory = require_implementor.implementFunction("ensureDirectory",
 	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
 });
 //#endregion
+exports.EnsureDirectoryError = EnsureDirectoryError;
+exports.EnsureDirectoryErrorBusy = EnsureDirectoryErrorBusy;
+exports.EnsureDirectoryErrorInvalidArgument = EnsureDirectoryErrorInvalidArgument;
+exports.EnsureDirectoryErrorNoSpace = EnsureDirectoryErrorNoSpace;
+exports.EnsureDirectoryErrorNotDirectory = EnsureDirectoryErrorNotDirectory;
+exports.EnsureDirectoryErrorPermissionDenied = EnsureDirectoryErrorPermissionDenied;
+exports.EnsureDirectoryErrorReadOnly = EnsureDirectoryErrorReadOnly;
+exports.EnsureDirectoryErrorTooManyOpenFiles = EnsureDirectoryErrorTooManyOpenFiles;
 exports.ensureDirectory = ensureDirectory;

package/dist/file/ensureDirectory.d.ts

@@ -2,35 +2,35 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 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>;
+        ensureDirectory(path: DPath.AnyPath): Promise<EnsureDirectoryResult>;
     }
 }
-export declare const ensureDirectory: (path: string & DPath.Path) => Promise<EnsureDirectoryResult>;
+export declare const ensureDirectory: (path: DPath.AnyPath) => Promise<EnsureDirectoryResult>;
 export {};

package/dist/file/ensureDirectory.mjs

@@ -38,4 +38,4 @@ const ensureDirectory = implementFunction("ensureDirectory", {
 	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
 });
 //#endregion
-export { ensureDirectory };
+export { EnsureDirectoryError, EnsureDirectoryErrorBusy, EnsureDirectoryErrorInvalidArgument, EnsureDirectoryErrorNoSpace, EnsureDirectoryErrorNotDirectory, EnsureDirectoryErrorPermissionDenied, EnsureDirectoryErrorReadOnly, EnsureDirectoryErrorTooManyOpenFiles, ensureDirectory };

package/dist/file/ensureFile.cjs

@@ -48,4 +48,13 @@ const ensureFile = require_implementor.implementFunction("ensureFile", {
 	}).then((fh) => void fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleDenoEnsureFileError)
 });
 //#endregion
+exports.EnsureFileError = EnsureFileError;
+exports.EnsureFileErrorBusy = EnsureFileErrorBusy;
+exports.EnsureFileErrorInvalidArgument = EnsureFileErrorInvalidArgument;
+exports.EnsureFileErrorIsDirectory = EnsureFileErrorIsDirectory;
+exports.EnsureFileErrorNoSpace = EnsureFileErrorNoSpace;
+exports.EnsureFileErrorNotDirectory = EnsureFileErrorNotDirectory;
+exports.EnsureFileErrorPermissionDenied = EnsureFileErrorPermissionDenied;
+exports.EnsureFileErrorReadOnly = EnsureFileErrorReadOnly;
+exports.EnsureFileErrorTooManyOpenFiles = EnsureFileErrorTooManyOpenFiles;
 exports.ensureFile = ensureFile;

package/dist/file/ensureFile.d.ts

@@ -2,38 +2,38 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 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>;
+        ensureFile(path: DPath.AnyPath): Promise<EnsureFileResult>;
     }
 }
-export declare const ensureFile: (path: string & DPath.Path) => Promise<EnsureFileResult>;
+export declare const ensureFile: (path: DPath.AnyPath) => Promise<EnsureFileResult>;
 export {};

package/dist/file/ensureFile.mjs

@@ -45,4 +45,4 @@ const ensureFile = implementFunction("ensureFile", {
 	}).then((fh) => void fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleDenoEnsureFileError)
 });
 //#endregion
-export { ensureFile };
+export { EnsureFileError, EnsureFileErrorBusy, EnsureFileErrorInvalidArgument, EnsureFileErrorIsDirectory, EnsureFileErrorNoSpace, EnsureFileErrorNotDirectory, EnsureFileErrorPermissionDenied, EnsureFileErrorReadOnly, EnsureFileErrorTooManyOpenFiles, ensureFile };

package/dist/file/exists.cjs

@@ -35,4 +35,9 @@ const exists = require_implementor.implementFunction("exists", {
 	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.ExistsError = ExistsError;
+exports.ExistsErrorNotDirectory = ExistsErrorNotDirectory;
+exports.ExistsErrorNotFound = ExistsErrorNotFound;
+exports.ExistsErrorPermissionDenied = ExistsErrorPermissionDenied;
+exports.ExistsErrorTooManyOpenFiles = ExistsErrorTooManyOpenFiles;
 exports.exists = exists;

package/dist/file/exists.d.ts

@@ -2,26 +2,26 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 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>;
+        exists(path: DPath.AnyPath): Promise<ExistsResult>;
     }
 }
-export declare const exists: (path: string & DPath.Path) => Promise<ExistsResult>;
+export declare const exists: (path: DPath.AnyPath) => Promise<ExistsResult>;
 export {};

package/dist/file/exists.mjs

@@ -32,4 +32,4 @@ const exists = implementFunction("exists", {
 	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 };
+export { ExistsError, ExistsErrorNotDirectory, ExistsErrorNotFound, ExistsErrorPermissionDenied, ExistsErrorTooManyOpenFiles, exists };

package/dist/file/fileInterface.cjs

@@ -51,7 +51,7 @@ function createFileInterface(path) {
 		return _duplojs_lang_common.asyncPipe(localStat(), _duplojs_lang_either.whenHasInformationOtherwise("file-system-stat", ({ isFile }) => isFile, _duplojs_lang_common.justReturn(false)));
 	}
 	return {
-		path,
+		path: _duplojs_lang_common.cast(path),
 		getName,
 		getExtension,
 		getMimeType,

package/dist/file/fileInterface.d.ts

@@ -4,7 +4,6 @@ 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";
@@ -12,21 +11,21 @@ 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<GenericPath extends EntryPath = EntryPath> extends DKind.Kind<typeof fileInterfaceKind> {
+export interface FileInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> 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 & DPath.Path) | null;
-    getParentPath(): (string & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
     rename(newName: string & DPath.Segment): Promise<FileInterfaceRenameResult>;
-    relocate(parentPath: string & DPath.Path): Promise<FileInterfaceRelocateResult>;
-    move(newPath: string & DPath.Path): Promise<FileInterfaceMoveResult>;
+    relocate(parentPath: DPath.AnyPath): Promise<FileInterfaceRelocateResult>;
+    move(newPath: DPath.AnyPath): Promise<FileInterfaceMoveResult>;
     exists(): Promise<ExistsResult>;
     remove(): Promise<RemoveResult>;
     stat(): Promise<StatResult>;
     isFile(): Promise<boolean>;
 }
-export declare function createFileInterface<GenericPath extends EntryPath = EntryPath>(path: GenericPath): FileInterface<GenericPath>;
+export declare function createFileInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(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

@@ -47,7 +47,7 @@ function createFileInterface(path) {
 		return DCommon.asyncPipe(localStat(), DEither.whenHasInformationOtherwise("file-system-stat", ({ isFile }) => isFile, DCommon.justReturn(false)));
 	}
 	return {
-		path,
+		path: DCommon.cast(path),
 		getName,
 		getExtension,
 		getMimeType,

package/dist/file/folderInterface.cjs

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