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

package/dist/file/makeTemporaryDirectory.d.ts

@@ -1,25 +1,25 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 declare const MakeTemporaryDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-permission-denied", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryErrorPermissionDenied extends MakeTemporaryDirectoryErrorPermissionDenied_base {
+export declare class MakeTemporaryDirectoryErrorPermissionDenied extends MakeTemporaryDirectoryErrorPermissionDenied_base {
 }
 declare const MakeTemporaryDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-not-directory", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryErrorNotDirectory extends MakeTemporaryDirectoryErrorNotDirectory_base {
+export declare class MakeTemporaryDirectoryErrorNotDirectory extends MakeTemporaryDirectoryErrorNotDirectory_base {
 }
 declare const MakeTemporaryDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-no-space", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryErrorNoSpace extends MakeTemporaryDirectoryErrorNoSpace_base {
+export declare class MakeTemporaryDirectoryErrorNoSpace extends MakeTemporaryDirectoryErrorNoSpace_base {
 }
 declare const MakeTemporaryDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-read-only", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryErrorReadOnly extends MakeTemporaryDirectoryErrorReadOnly_base {
+export declare class MakeTemporaryDirectoryErrorReadOnly extends MakeTemporaryDirectoryErrorReadOnly_base {
 }
 declare const MakeTemporaryDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-invalid-argument", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryErrorInvalidArgument extends MakeTemporaryDirectoryErrorInvalidArgument_base {
+export declare class MakeTemporaryDirectoryErrorInvalidArgument extends MakeTemporaryDirectoryErrorInvalidArgument_base {
 }
 declare const MakeTemporaryDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-too-many-open-files", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryErrorTooManyOpenFiles extends MakeTemporaryDirectoryErrorTooManyOpenFiles_base {
+export declare class MakeTemporaryDirectoryErrorTooManyOpenFiles extends MakeTemporaryDirectoryErrorTooManyOpenFiles_base {
 }
 declare const MakeTemporaryDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-error", unknown>>, unknown>;
-declare class MakeTemporaryDirectoryError extends MakeTemporaryDirectoryError_base {
+export declare class MakeTemporaryDirectoryError extends MakeTemporaryDirectoryError_base {
 }
 export type MakeTemporaryDirectoryErrors = (MakeTemporaryDirectoryErrorPermissionDenied | MakeTemporaryDirectoryErrorNotDirectory | MakeTemporaryDirectoryErrorNoSpace | MakeTemporaryDirectoryErrorReadOnly | MakeTemporaryDirectoryErrorInvalidArgument | MakeTemporaryDirectoryErrorTooManyOpenFiles | MakeTemporaryDirectoryError);
 export type MakeTemporaryDirectoryResult = (DEither.Right<"file-system-make-temporary-directory", string> | DEither.Left<"file-system-make-temporary-directory-error", MakeTemporaryDirectoryErrors>);

package/dist/file/makeTemporaryDirectory.mjs

@@ -35,4 +35,4 @@ const makeTemporaryDirectory = implementFunction("makeTemporaryDirectory", {
 	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
 });
 //#endregion
-export { makeTemporaryDirectory };
+export { MakeTemporaryDirectoryError, MakeTemporaryDirectoryErrorInvalidArgument, MakeTemporaryDirectoryErrorNoSpace, MakeTemporaryDirectoryErrorNotDirectory, MakeTemporaryDirectoryErrorPermissionDenied, MakeTemporaryDirectoryErrorReadOnly, MakeTemporaryDirectoryErrorTooManyOpenFiles, makeTemporaryDirectory };

package/dist/file/makeTemporaryFile.cjs

@@ -51,4 +51,12 @@ const makeTemporaryFile = require_implementor.implementFunction("makeTemporaryFi
 	}).then((value) => _duplojs_lang_either.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
 });
 //#endregion
+exports.MakeTemporaryFileError = MakeTemporaryFileError;
+exports.MakeTemporaryFileErrorAlreadyExists = MakeTemporaryFileErrorAlreadyExists;
+exports.MakeTemporaryFileErrorInvalidArgument = MakeTemporaryFileErrorInvalidArgument;
+exports.MakeTemporaryFileErrorNoSpace = MakeTemporaryFileErrorNoSpace;
+exports.MakeTemporaryFileErrorNotDirectory = MakeTemporaryFileErrorNotDirectory;
+exports.MakeTemporaryFileErrorPermissionDenied = MakeTemporaryFileErrorPermissionDenied;
+exports.MakeTemporaryFileErrorReadOnly = MakeTemporaryFileErrorReadOnly;
+exports.MakeTemporaryFileErrorTooManyOpenFiles = MakeTemporaryFileErrorTooManyOpenFiles;
 exports.makeTemporaryFile = makeTemporaryFile;

package/dist/file/makeTemporaryFile.d.ts

@@ -2,28 +2,28 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
 declare const MakeTemporaryFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-permission-denied", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorPermissionDenied extends MakeTemporaryFileErrorPermissionDenied_base {
+export declare class MakeTemporaryFileErrorPermissionDenied extends MakeTemporaryFileErrorPermissionDenied_base {
 }
 declare const MakeTemporaryFileErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-already-exists", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorAlreadyExists extends MakeTemporaryFileErrorAlreadyExists_base {
+export declare class MakeTemporaryFileErrorAlreadyExists extends MakeTemporaryFileErrorAlreadyExists_base {
 }
 declare const MakeTemporaryFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-not-directory", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorNotDirectory extends MakeTemporaryFileErrorNotDirectory_base {
+export declare class MakeTemporaryFileErrorNotDirectory extends MakeTemporaryFileErrorNotDirectory_base {
 }
 declare const MakeTemporaryFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-no-space", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorNoSpace extends MakeTemporaryFileErrorNoSpace_base {
+export declare class MakeTemporaryFileErrorNoSpace extends MakeTemporaryFileErrorNoSpace_base {
 }
 declare const MakeTemporaryFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-read-only", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorReadOnly extends MakeTemporaryFileErrorReadOnly_base {
+export declare class MakeTemporaryFileErrorReadOnly extends MakeTemporaryFileErrorReadOnly_base {
 }
 declare const MakeTemporaryFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-invalid-argument", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorInvalidArgument extends MakeTemporaryFileErrorInvalidArgument_base {
+export declare class MakeTemporaryFileErrorInvalidArgument extends MakeTemporaryFileErrorInvalidArgument_base {
 }
 declare const MakeTemporaryFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-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-make-temporary-file-too-many-open-files", unknown>>, unknown>;
-declare class MakeTemporaryFileErrorTooManyOpenFiles extends MakeTemporaryFileErrorTooManyOpenFiles_base {
+export declare class MakeTemporaryFileErrorTooManyOpenFiles extends MakeTemporaryFileErrorTooManyOpenFiles_base {
 }
 declare const MakeTemporaryFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-error", unknown>>, unknown>;
-declare class MakeTemporaryFileError extends MakeTemporaryFileError_base {
+export declare class MakeTemporaryFileError extends MakeTemporaryFileError_base {
 }
 export type MakeTemporaryFileErrors = (MakeTemporaryFileErrorPermissionDenied | MakeTemporaryFileErrorAlreadyExists | MakeTemporaryFileErrorNotDirectory | MakeTemporaryFileErrorNoSpace | MakeTemporaryFileErrorReadOnly | MakeTemporaryFileErrorInvalidArgument | MakeTemporaryFileErrorTooManyOpenFiles | MakeTemporaryFileError);
 export type MakeTemporaryFileResult = (DEither.Right<"file-system-make-temporary-file", string> | DEither.Left<"file-system-make-temporary-file-error", MakeTemporaryFileErrors>);

package/dist/file/makeTemporaryFile.mjs

@@ -47,4 +47,4 @@ const makeTemporaryFile = implementFunction("makeTemporaryFile", {
 	}).then((value) => DEither.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
 });
 //#endregion
-export { makeTemporaryFile };
+export { MakeTemporaryFileError, MakeTemporaryFileErrorAlreadyExists, MakeTemporaryFileErrorInvalidArgument, MakeTemporaryFileErrorNoSpace, MakeTemporaryFileErrorNotDirectory, MakeTemporaryFileErrorPermissionDenied, MakeTemporaryFileErrorReadOnly, MakeTemporaryFileErrorTooManyOpenFiles, makeTemporaryFile };

package/dist/file/move.cjs

@@ -57,4 +57,15 @@ function move(...args) {
 	return moveImplementation(...args);
 }
 //#endregion
+exports.MoveError = MoveError;
+exports.MoveErrorAlreadyExists = MoveErrorAlreadyExists;
+exports.MoveErrorBusy = MoveErrorBusy;
+exports.MoveErrorCrossDevice = MoveErrorCrossDevice;
+exports.MoveErrorDirectoryNotEmpty = MoveErrorDirectoryNotEmpty;
+exports.MoveErrorInvalidArgument = MoveErrorInvalidArgument;
+exports.MoveErrorIsDirectory = MoveErrorIsDirectory;
+exports.MoveErrorNotDirectory = MoveErrorNotDirectory;
+exports.MoveErrorNotFound = MoveErrorNotFound;
+exports.MoveErrorPermissionDenied = MoveErrorPermissionDenied;
+exports.MoveErrorReadOnly = MoveErrorReadOnly;
 exports.move = move;

package/dist/file/move.d.ts

@@ -2,45 +2,45 @@ import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 declare const MoveErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-not-found", unknown>>, unknown>;
-declare class MoveErrorNotFound extends MoveErrorNotFound_base {
+export declare class MoveErrorNotFound extends MoveErrorNotFound_base {
 }
 declare const MoveErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-permission-denied", unknown>>, unknown>;
-declare class MoveErrorPermissionDenied extends MoveErrorPermissionDenied_base {
+export declare class MoveErrorPermissionDenied extends MoveErrorPermissionDenied_base {
 }
 declare const MoveErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-already-exists", unknown>>, unknown>;
-declare class MoveErrorAlreadyExists extends MoveErrorAlreadyExists_base {
+export declare class MoveErrorAlreadyExists extends MoveErrorAlreadyExists_base {
 }
 declare const MoveErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-is-directory", unknown>>, unknown>;
-declare class MoveErrorIsDirectory extends MoveErrorIsDirectory_base {
+export declare class MoveErrorIsDirectory extends MoveErrorIsDirectory_base {
 }
 declare const MoveErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-not-directory", unknown>>, unknown>;
-declare class MoveErrorNotDirectory extends MoveErrorNotDirectory_base {
+export declare class MoveErrorNotDirectory extends MoveErrorNotDirectory_base {
 }
 declare const MoveErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-directory-not-empty", unknown>>, unknown>;
-declare class MoveErrorDirectoryNotEmpty extends MoveErrorDirectoryNotEmpty_base {
+export declare class MoveErrorDirectoryNotEmpty extends MoveErrorDirectoryNotEmpty_base {
 }
 declare const MoveErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-read-only", unknown>>, unknown>;
-declare class MoveErrorReadOnly extends MoveErrorReadOnly_base {
+export declare class MoveErrorReadOnly extends MoveErrorReadOnly_base {
 }
 declare const MoveErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-invalid-argument", unknown>>, unknown>;
-declare class MoveErrorInvalidArgument extends MoveErrorInvalidArgument_base {
+export declare class MoveErrorInvalidArgument extends MoveErrorInvalidArgument_base {
 }
 declare const MoveErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-busy", unknown>>, unknown>;
-declare class MoveErrorBusy extends MoveErrorBusy_base {
+export declare class MoveErrorBusy extends MoveErrorBusy_base {
 }
 declare const MoveErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-cross-device", unknown>>, unknown>;
-declare class MoveErrorCrossDevice extends MoveErrorCrossDevice_base {
+export declare class MoveErrorCrossDevice extends MoveErrorCrossDevice_base {
 }
 declare const MoveError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-error", unknown>>, unknown>;
-declare class MoveError extends MoveError_base {
+export declare class MoveError extends MoveError_base {
 }
 export type MoveErrors = (MoveErrorNotFound | MoveErrorPermissionDenied | MoveErrorAlreadyExists | MoveErrorIsDirectory | MoveErrorNotDirectory | MoveErrorDirectoryNotEmpty | MoveErrorReadOnly | MoveErrorInvalidArgument | MoveErrorBusy | MoveErrorCrossDevice | MoveError);
 export type MoveResult = (DEither.Right<"file-system-move", void> | DEither.Left<"file-system-move-error", MoveErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        move(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<MoveResult>;
+        move(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<MoveResult>;
     }
 }
-export declare function move(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<MoveResult>;
-export declare function move(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<MoveResult>;
+export declare function move(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<MoveResult>;
+export declare function move(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<MoveResult>;
 export {};

package/dist/file/move.mjs

@@ -54,4 +54,4 @@ function move(...args) {
 	return moveImplementation(...args);
 }
 //#endregion
-export { move };
+export { MoveError, MoveErrorAlreadyExists, MoveErrorBusy, MoveErrorCrossDevice, MoveErrorDirectoryNotEmpty, MoveErrorInvalidArgument, MoveErrorIsDirectory, MoveErrorNotDirectory, MoveErrorNotFound, MoveErrorPermissionDenied, MoveErrorReadOnly, move };

package/dist/file/readDirectory.cjs

@@ -35,4 +35,10 @@ const readDirectory = require_implementor.implementFunction("readDirectory", { N
 	}).then((value) => _duplojs_lang_array.map(value, ({ name, parentPath }) => _duplojs_lang_path.resolveFrom(require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow(), [_duplojs_lang_path.normalize(`${parentPath}/${name}`)]))) : require_implementor.nodeFileSystem.value.readdir(path, { recursive: params?.recursive }).then((value) => _duplojs_lang_array.map(value, (subPath) => _duplojs_lang_path.normalize(subPath)))).then(_duplojs_lang_common.innerPipe((paths) => params?.matcher ? _duplojs_lang_array.filter(paths, params.matcher) : paths, (value) => _duplojs_lang_either.right("file-system-read-directory", value))).catch(handleNodeReadDirectoryError);
 } });
 //#endregion
+exports.ReadDirectoryError = ReadDirectoryError;
+exports.ReadDirectoryErrorBusy = ReadDirectoryErrorBusy;
+exports.ReadDirectoryErrorNotDirectory = ReadDirectoryErrorNotDirectory;
+exports.ReadDirectoryErrorNotFound = ReadDirectoryErrorNotFound;
+exports.ReadDirectoryErrorPermissionDenied = ReadDirectoryErrorPermissionDenied;
+exports.ReadDirectoryErrorTooManyOpenFiles = ReadDirectoryErrorTooManyOpenFiles;
 exports.readDirectory = readDirectory;

package/dist/file/readDirectory.d.ts

@@ -2,22 +2,22 @@ import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 declare const ReadDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-not-found", unknown>>, unknown>;
-declare class ReadDirectoryErrorNotFound extends ReadDirectoryErrorNotFound_base {
+export declare class ReadDirectoryErrorNotFound extends ReadDirectoryErrorNotFound_base {
 }
 declare const ReadDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-permission-denied", unknown>>, unknown>;
-declare class ReadDirectoryErrorPermissionDenied extends ReadDirectoryErrorPermissionDenied_base {
+export declare class ReadDirectoryErrorPermissionDenied extends ReadDirectoryErrorPermissionDenied_base {
 }
 declare const ReadDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-not-directory", unknown>>, unknown>;
-declare class ReadDirectoryErrorNotDirectory extends ReadDirectoryErrorNotDirectory_base {
+export declare class ReadDirectoryErrorNotDirectory extends ReadDirectoryErrorNotDirectory_base {
 }
 declare const ReadDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-directory-too-many-open-files", unknown>>, unknown>;
-declare class ReadDirectoryErrorTooManyOpenFiles extends ReadDirectoryErrorTooManyOpenFiles_base {
+export declare class ReadDirectoryErrorTooManyOpenFiles extends ReadDirectoryErrorTooManyOpenFiles_base {
 }
 declare const ReadDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-busy", unknown>>, unknown>;
-declare class ReadDirectoryErrorBusy extends ReadDirectoryErrorBusy_base {
+export declare class ReadDirectoryErrorBusy extends ReadDirectoryErrorBusy_base {
 }
 declare const ReadDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-error", unknown>>, unknown>;
-declare class ReadDirectoryError extends ReadDirectoryError_base {
+export declare class ReadDirectoryError extends ReadDirectoryError_base {
 }
 export type ReadDirectoryErrors = (ReadDirectoryErrorNotFound | ReadDirectoryErrorPermissionDenied | ReadDirectoryErrorNotDirectory | ReadDirectoryErrorTooManyOpenFiles | ReadDirectoryErrorBusy | ReadDirectoryError);
 interface ReadDirectoryParams {
@@ -28,8 +28,8 @@ interface ReadDirectoryParams {
 export type ReadDirectoryResult<GenericParams extends ReadDirectoryParams = ReadDirectoryParams> = (DEither.Right<"file-system-read-directory", readonly (string & DPath.Path & (DCommon.IsEqual<GenericParams["absolute"], true> extends true ? DPath.Absolute : unknown))[]> | DEither.Left<"file-system-read-directory-error", ReadDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        readDirectory<const GenericParams extends ReadDirectoryParams = {}>(path: string & DPath.Path, params?: GenericParams): Promise<ReadDirectoryResult<GenericParams>>;
+        readDirectory<const GenericParams extends ReadDirectoryParams = {}>(path: DPath.AnyPath, params?: GenericParams): Promise<ReadDirectoryResult<GenericParams>>;
     }
 }
-export declare const readDirectory: <const GenericParams extends ReadDirectoryParams = {}>(path: string & DPath.Path, params?: GenericParams) => Promise<ReadDirectoryResult<GenericParams>>;
+export declare const readDirectory: <const GenericParams extends ReadDirectoryParams = {}>(path: DPath.AnyPath, params?: GenericParams) => Promise<ReadDirectoryResult<GenericParams>>;
 export {};

package/dist/file/readDirectory.mjs

@@ -30,4 +30,4 @@ const readDirectory = implementFunction("readDirectory", { NODE: (path, params)
 	}).then((value) => DArray.map(value, ({ name, parentPath }) => DPath.resolveFrom(getCurrentWorkDirectoryOrThrow(), [DPath.normalize(`${parentPath}/${name}`)]))) : nodeFileSystem.value.readdir(path, { recursive: params?.recursive }).then((value) => DArray.map(value, (subPath) => DPath.normalize(subPath)))).then(DCommon.innerPipe((paths) => params?.matcher ? DArray.filter(paths, params.matcher) : paths, (value) => DEither.right("file-system-read-directory", value))).catch(handleNodeReadDirectoryError);
 } });
 //#endregion
-export { readDirectory };
+export { ReadDirectoryError, ReadDirectoryErrorBusy, ReadDirectoryErrorNotDirectory, ReadDirectoryErrorNotFound, ReadDirectoryErrorPermissionDenied, ReadDirectoryErrorTooManyOpenFiles, readDirectory };

package/dist/file/readFile.cjs

@@ -41,4 +41,11 @@ const readFile = require_implementor.implementFunction("readFile", {
 	BUN: (path) => Bun.file(path).bytes().then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleNodeReadFileError)
 });
 //#endregion
+exports.ReadFileError = ReadFileError;
+exports.ReadFileErrorBusy = ReadFileErrorBusy;
+exports.ReadFileErrorIsDirectory = ReadFileErrorIsDirectory;
+exports.ReadFileErrorNotDirectory = ReadFileErrorNotDirectory;
+exports.ReadFileErrorNotFound = ReadFileErrorNotFound;
+exports.ReadFileErrorPermissionDenied = ReadFileErrorPermissionDenied;
+exports.ReadFileErrorTooManyOpenFiles = ReadFileErrorTooManyOpenFiles;
 exports.readFile = readFile;

package/dist/file/readFile.d.ts

@@ -2,32 +2,32 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import * as DCommon from "@duplojs/lang/common";
 declare const ReadFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-not-found", unknown>>, unknown>;
-declare class ReadFileErrorNotFound extends ReadFileErrorNotFound_base {
+export declare class ReadFileErrorNotFound extends ReadFileErrorNotFound_base {
 }
 declare const ReadFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-permission-denied", unknown>>, unknown>;
-declare class ReadFileErrorPermissionDenied extends ReadFileErrorPermissionDenied_base {
+export declare class ReadFileErrorPermissionDenied extends ReadFileErrorPermissionDenied_base {
 }
 declare const ReadFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-is-directory", unknown>>, unknown>;
-declare class ReadFileErrorIsDirectory extends ReadFileErrorIsDirectory_base {
+export declare class ReadFileErrorIsDirectory extends ReadFileErrorIsDirectory_base {
 }
 declare const ReadFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-not-directory", unknown>>, unknown>;
-declare class ReadFileErrorNotDirectory extends ReadFileErrorNotDirectory_base {
+export declare class ReadFileErrorNotDirectory extends ReadFileErrorNotDirectory_base {
 }
 declare const ReadFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-file-too-many-open-files", unknown>>, unknown>;
-declare class ReadFileErrorTooManyOpenFiles extends ReadFileErrorTooManyOpenFiles_base {
+export declare class ReadFileErrorTooManyOpenFiles extends ReadFileErrorTooManyOpenFiles_base {
 }
 declare const ReadFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-busy", unknown>>, unknown>;
-declare class ReadFileErrorBusy extends ReadFileErrorBusy_base {
+export declare class ReadFileErrorBusy extends ReadFileErrorBusy_base {
 }
 declare const ReadFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-error", unknown>>, unknown>;
-declare class ReadFileError extends ReadFileError_base {
+export declare class ReadFileError extends ReadFileError_base {
 }
 export type ReadFileErrors = (ReadFileErrorNotFound | ReadFileErrorPermissionDenied | ReadFileErrorIsDirectory | ReadFileErrorNotDirectory | ReadFileErrorTooManyOpenFiles | ReadFileErrorBusy | ReadFileError);
 export type ReadFileResult = (DEither.Right<"file-system-read-file", Uint8Array> | DEither.Left<"file-system-read-file-error", ReadFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        readFile(path: string & DPath.Path): Promise<ReadFileResult>;
+        readFile(path: DPath.AnyPath): Promise<ReadFileResult>;
     }
 }
-export declare const readFile: (path: string & DPath.Path) => Promise<ReadFileResult>;
+export declare const readFile: (path: DPath.AnyPath) => Promise<ReadFileResult>;
 export {};

package/dist/file/readFile.mjs

@@ -38,4 +38,4 @@ const readFile = implementFunction("readFile", {
 	BUN: (path) => Bun.file(path).bytes().then((value) => DEither.right("file-system-read-file", value)).catch(handleNodeReadFileError)
 });
 //#endregion
-export { readFile };
+export { ReadFileError, ReadFileErrorBusy, ReadFileErrorIsDirectory, ReadFileErrorNotDirectory, ReadFileErrorNotFound, ReadFileErrorPermissionDenied, ReadFileErrorTooManyOpenFiles, readFile };

package/dist/file/readJsonFile.cjs

@@ -41,4 +41,11 @@ const readJsonFile = require_implementor.implementFunction("readJsonFile", {
 	BUN: (path) => Bun.file(path).text().then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError)
 });
 //#endregion
+exports.ReadJsonFileError = ReadJsonFileError;
+exports.ReadJsonFileErrorBusy = ReadJsonFileErrorBusy;
+exports.ReadJsonFileErrorIsDirectory = ReadJsonFileErrorIsDirectory;
+exports.ReadJsonFileErrorNotDirectory = ReadJsonFileErrorNotDirectory;
+exports.ReadJsonFileErrorNotFound = ReadJsonFileErrorNotFound;
+exports.ReadJsonFileErrorPermissionDenied = ReadJsonFileErrorPermissionDenied;
+exports.ReadJsonFileErrorTooManyOpenFiles = ReadJsonFileErrorTooManyOpenFiles;
 exports.readJsonFile = readJsonFile;

package/dist/file/readJsonFile.d.ts

@@ -2,32 +2,32 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 declare const ReadJsonFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-not-found", unknown>>, unknown>;
-declare class ReadJsonFileErrorNotFound extends ReadJsonFileErrorNotFound_base {
+export declare class ReadJsonFileErrorNotFound extends ReadJsonFileErrorNotFound_base {
 }
 declare const ReadJsonFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-permission-denied", unknown>>, unknown>;
-declare class ReadJsonFileErrorPermissionDenied extends ReadJsonFileErrorPermissionDenied_base {
+export declare class ReadJsonFileErrorPermissionDenied extends ReadJsonFileErrorPermissionDenied_base {
 }
 declare const ReadJsonFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-is-directory", unknown>>, unknown>;
-declare class ReadJsonFileErrorIsDirectory extends ReadJsonFileErrorIsDirectory_base {
+export declare class ReadJsonFileErrorIsDirectory extends ReadJsonFileErrorIsDirectory_base {
 }
 declare const ReadJsonFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-not-directory", unknown>>, unknown>;
-declare class ReadJsonFileErrorNotDirectory extends ReadJsonFileErrorNotDirectory_base {
+export declare class ReadJsonFileErrorNotDirectory extends ReadJsonFileErrorNotDirectory_base {
 }
 declare const ReadJsonFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-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-read-json-file-too-many-open-files", unknown>>, unknown>;
-declare class ReadJsonFileErrorTooManyOpenFiles extends ReadJsonFileErrorTooManyOpenFiles_base {
+export declare class ReadJsonFileErrorTooManyOpenFiles extends ReadJsonFileErrorTooManyOpenFiles_base {
 }
 declare const ReadJsonFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-busy", unknown>>, unknown>;
-declare class ReadJsonFileErrorBusy extends ReadJsonFileErrorBusy_base {
+export declare class ReadJsonFileErrorBusy extends ReadJsonFileErrorBusy_base {
 }
 declare const ReadJsonFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-error", unknown>>, unknown>;
-declare class ReadJsonFileError extends ReadJsonFileError_base {
+export declare class ReadJsonFileError extends ReadJsonFileError_base {
 }
 export type ReadJsonFileErrors = (ReadJsonFileErrorNotFound | ReadJsonFileErrorPermissionDenied | ReadJsonFileErrorIsDirectory | ReadJsonFileErrorNotDirectory | ReadJsonFileErrorTooManyOpenFiles | ReadJsonFileErrorBusy | ReadJsonFileError);
 export type ReadJsonFileResult = (DEither.Right<"file-system-read-json-file", DCommon.Json> | DEither.Left<"file-system-read-json-file-error", ReadJsonFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        readJsonFile(path: string & DPath.Path): Promise<ReadJsonFileResult>;
+        readJsonFile(path: DPath.AnyPath): Promise<ReadJsonFileResult>;
     }
 }
-export declare const readJsonFile: (path: string & DPath.Path) => Promise<ReadJsonFileResult>;
+export declare const readJsonFile: (path: DPath.AnyPath) => Promise<ReadJsonFileResult>;
 export {};

package/dist/file/readJsonFile.mjs

@@ -38,4 +38,4 @@ const readJsonFile = implementFunction("readJsonFile", {
 	BUN: (path) => Bun.file(path).text().then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError)
 });
 //#endregion
-export { readJsonFile };
+export { ReadJsonFileError, ReadJsonFileErrorBusy, ReadJsonFileErrorIsDirectory, ReadJsonFileErrorNotDirectory, ReadJsonFileErrorNotFound, ReadJsonFileErrorPermissionDenied, ReadJsonFileErrorTooManyOpenFiles, readJsonFile };

package/dist/file/readLink.cjs

@@ -37,4 +37,10 @@ const readLink = require_implementor.implementFunction("readLink", {
 	DENO: (path) => Deno.readLink(path).then((value) => _duplojs_lang_either.right("file-system-read-link", value)).catch(handleDenoReadLinkError)
 });
 //#endregion
+exports.ReadLinkError = ReadLinkError;
+exports.ReadLinkErrorInvalidArgument = ReadLinkErrorInvalidArgument;
+exports.ReadLinkErrorNotDirectory = ReadLinkErrorNotDirectory;
+exports.ReadLinkErrorNotFound = ReadLinkErrorNotFound;
+exports.ReadLinkErrorPermissionDenied = ReadLinkErrorPermissionDenied;
+exports.ReadLinkErrorTooManyOpenFiles = ReadLinkErrorTooManyOpenFiles;
 exports.readLink = readLink;

package/dist/file/readLink.d.ts

@@ -2,29 +2,29 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import * as DCommon from "@duplojs/lang/common";
 declare const ReadLinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-not-found", unknown>>, unknown>;
-declare class ReadLinkErrorNotFound extends ReadLinkErrorNotFound_base {
+export declare class ReadLinkErrorNotFound extends ReadLinkErrorNotFound_base {
 }
 declare const ReadLinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-permission-denied", unknown>>, unknown>;
-declare class ReadLinkErrorPermissionDenied extends ReadLinkErrorPermissionDenied_base {
+export declare class ReadLinkErrorPermissionDenied extends ReadLinkErrorPermissionDenied_base {
 }
 declare const ReadLinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-invalid-argument", unknown>>, unknown>;
-declare class ReadLinkErrorInvalidArgument extends ReadLinkErrorInvalidArgument_base {
+export declare class ReadLinkErrorInvalidArgument extends ReadLinkErrorInvalidArgument_base {
 }
 declare const ReadLinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-not-directory", unknown>>, unknown>;
-declare class ReadLinkErrorNotDirectory extends ReadLinkErrorNotDirectory_base {
+export declare class ReadLinkErrorNotDirectory extends ReadLinkErrorNotDirectory_base {
 }
 declare const ReadLinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-too-many-open-files", unknown>>, unknown>;
-declare class ReadLinkErrorTooManyOpenFiles extends ReadLinkErrorTooManyOpenFiles_base {
+export declare class ReadLinkErrorTooManyOpenFiles extends ReadLinkErrorTooManyOpenFiles_base {
 }
 declare const ReadLinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-error", unknown>>, unknown>;
-declare class ReadLinkError extends ReadLinkError_base {
+export declare class ReadLinkError extends ReadLinkError_base {
 }
 export type ReadLinkErrors = (ReadLinkErrorNotFound | ReadLinkErrorPermissionDenied | ReadLinkErrorInvalidArgument | ReadLinkErrorNotDirectory | ReadLinkErrorTooManyOpenFiles | ReadLinkError);
 export type ReadLinkResult = (DEither.Right<"file-system-read-link", string> | DEither.Left<"file-system-read-link-error", ReadLinkErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        readLink(path: string & DPath.Path): Promise<ReadLinkResult>;
+        readLink(path: DPath.AnyPath): Promise<ReadLinkResult>;
     }
 }
-export declare const readLink: (path: string & DPath.Path) => Promise<ReadLinkResult>;
+export declare const readLink: (path: DPath.AnyPath) => Promise<ReadLinkResult>;
 export {};

package/dist/file/readLink.mjs

@@ -34,4 +34,4 @@ const readLink = implementFunction("readLink", {
 	DENO: (path) => Deno.readLink(path).then((value) => DEither.right("file-system-read-link", value)).catch(handleDenoReadLinkError)
 });
 //#endregion
-export { readLink };
+export { ReadLinkError, ReadLinkErrorInvalidArgument, ReadLinkErrorNotDirectory, ReadLinkErrorNotFound, ReadLinkErrorPermissionDenied, ReadLinkErrorTooManyOpenFiles, readLink };

package/dist/file/readTextFile.cjs

@@ -41,4 +41,11 @@ const readTextFile = require_implementor.implementFunction("readTextFile", {
 	BUN: (path) => Bun.file(path).text().then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError)
 });
 //#endregion
+exports.ReadTextFileError = ReadTextFileError;
+exports.ReadTextFileErrorBusy = ReadTextFileErrorBusy;
+exports.ReadTextFileErrorIsDirectory = ReadTextFileErrorIsDirectory;
+exports.ReadTextFileErrorNotDirectory = ReadTextFileErrorNotDirectory;
+exports.ReadTextFileErrorNotFound = ReadTextFileErrorNotFound;
+exports.ReadTextFileErrorPermissionDenied = ReadTextFileErrorPermissionDenied;
+exports.ReadTextFileErrorTooManyOpenFiles = ReadTextFileErrorTooManyOpenFiles;
 exports.readTextFile = readTextFile;

package/dist/file/readTextFile.d.ts

@@ -2,32 +2,32 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 declare const ReadTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-text-file-not-found", unknown>>, unknown>;
-declare class ReadTextFileErrorNotFound extends ReadTextFileErrorNotFound_base {
+export declare class ReadTextFileErrorNotFound extends ReadTextFileErrorNotFound_base {
 }
 declare const ReadTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-text-file-permission-denied", unknown>>, unknown>;
-declare class ReadTextFileErrorPermissionDenied extends ReadTextFileErrorPermissionDenied_base {
+export declare class ReadTextFileErrorPermissionDenied extends ReadTextFileErrorPermissionDenied_base {
 }
 declare const ReadTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-text-file-is-directory", unknown>>, unknown>;
-declare class ReadTextFileErrorIsDirectory extends ReadTextFileErrorIsDirectory_base {
+export declare class ReadTextFileErrorIsDirectory extends ReadTextFileErrorIsDirectory_base {
 }
 declare const ReadTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-text-file-not-directory", unknown>>, unknown>;
-declare class ReadTextFileErrorNotDirectory extends ReadTextFileErrorNotDirectory_base {
+export declare class ReadTextFileErrorNotDirectory extends ReadTextFileErrorNotDirectory_base {
 }
 declare const ReadTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-text-file-too-many-open-files", unknown>>, unknown>;
-declare class ReadTextFileErrorTooManyOpenFiles extends ReadTextFileErrorTooManyOpenFiles_base {
+export declare class ReadTextFileErrorTooManyOpenFiles extends ReadTextFileErrorTooManyOpenFiles_base {
 }
 declare const ReadTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-busy", unknown>>, unknown>;
-declare class ReadTextFileErrorBusy extends ReadTextFileErrorBusy_base {
+export declare class ReadTextFileErrorBusy extends ReadTextFileErrorBusy_base {
 }
 declare const ReadTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-error", unknown>>, unknown>;
-declare class ReadTextFileError extends ReadTextFileError_base {
+export declare class ReadTextFileError extends ReadTextFileError_base {
 }
 export type ReadTextFileErrors = (ReadTextFileErrorNotFound | ReadTextFileErrorPermissionDenied | ReadTextFileErrorIsDirectory | ReadTextFileErrorNotDirectory | ReadTextFileErrorTooManyOpenFiles | ReadTextFileErrorBusy | ReadTextFileError);
 export type ReadTextFileResult = (DEither.Right<"file-system-read-text-file", string> | DEither.Left<"file-system-read-text-file-error", ReadTextFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        readTextFile(path: string & DPath.Path): Promise<ReadTextFileResult>;
+        readTextFile(path: DPath.AnyPath): Promise<ReadTextFileResult>;
     }
 }
-export declare const readTextFile: (path: string & DPath.Path) => Promise<ReadTextFileResult>;
+export declare const readTextFile: (path: DPath.AnyPath) => Promise<ReadTextFileResult>;
 export {};

package/dist/file/readTextFile.mjs

@@ -38,4 +38,4 @@ const readTextFile = implementFunction("readTextFile", {
 	BUN: (path) => Bun.file(path).text().then((value) => DEither.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError)
 });
 //#endregion
-export { readTextFile };
+export { ReadTextFileError, ReadTextFileErrorBusy, ReadTextFileErrorIsDirectory, ReadTextFileErrorNotDirectory, ReadTextFileErrorNotFound, ReadTextFileErrorPermissionDenied, ReadTextFileErrorTooManyOpenFiles, readTextFile };

package/dist/file/realPath.cjs

@@ -34,4 +34,9 @@ const realPath = require_implementor.implementFunction("realPath", {
 	DENO: (path) => Deno.realPath(path).then((value) => _duplojs_lang_either.right("file-system-real-path", value)).catch(handleDenoRealPathError)
 });
 //#endregion
+exports.RealPathError = RealPathError;
+exports.RealPathErrorNotDirectory = RealPathErrorNotDirectory;
+exports.RealPathErrorNotFound = RealPathErrorNotFound;
+exports.RealPathErrorPermissionDenied = RealPathErrorPermissionDenied;
+exports.RealPathErrorTooManyOpenFiles = RealPathErrorTooManyOpenFiles;
 exports.realPath = realPath;

package/dist/file/realPath.d.ts

@@ -2,26 +2,26 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 declare const RealPathErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-not-found", unknown>>, unknown>;
-declare class RealPathErrorNotFound extends RealPathErrorNotFound_base {
+export declare class RealPathErrorNotFound extends RealPathErrorNotFound_base {
 }
 declare const RealPathErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-permission-denied", unknown>>, unknown>;
-declare class RealPathErrorPermissionDenied extends RealPathErrorPermissionDenied_base {
+export declare class RealPathErrorPermissionDenied extends RealPathErrorPermissionDenied_base {
 }
 declare const RealPathErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-not-directory", unknown>>, unknown>;
-declare class RealPathErrorNotDirectory extends RealPathErrorNotDirectory_base {
+export declare class RealPathErrorNotDirectory extends RealPathErrorNotDirectory_base {
 }
 declare const RealPathErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-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-real-path-too-many-open-files", unknown>>, unknown>;
-declare class RealPathErrorTooManyOpenFiles extends RealPathErrorTooManyOpenFiles_base {
+export declare class RealPathErrorTooManyOpenFiles extends RealPathErrorTooManyOpenFiles_base {
 }
 declare const RealPathError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-error", unknown>>, unknown>;
-declare class RealPathError extends RealPathError_base {
+export declare class RealPathError extends RealPathError_base {
 }
 export type RealPathErrors = (RealPathErrorNotFound | RealPathErrorPermissionDenied | RealPathErrorNotDirectory | RealPathErrorTooManyOpenFiles | RealPathError);
 export type RealPathResult = (DEither.Right<"file-system-real-path", string> | DEither.Left<"file-system-real-path-error", RealPathErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        realPath(path: string & DPath.Path): Promise<RealPathResult>;
+        realPath(path: DPath.AnyPath): Promise<RealPathResult>;
     }
 }
-export declare const realPath: (path: string & DPath.Path) => Promise<RealPathResult>;
+export declare const realPath: (path: DPath.AnyPath) => Promise<RealPathResult>;
 export {};

package/dist/file/realPath.mjs

@@ -31,4 +31,4 @@ const realPath = implementFunction("realPath", {
 	DENO: (path) => Deno.realPath(path).then((value) => DEither.right("file-system-real-path", value)).catch(handleDenoRealPathError)
 });
 //#endregion
-export { realPath };
+export { RealPathError, RealPathErrorNotDirectory, RealPathErrorNotFound, RealPathErrorPermissionDenied, RealPathErrorTooManyOpenFiles, realPath };