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

package/dist/file/truncate.cjs

@@ -47,4 +47,14 @@ const truncate = require_implementor.implementFunction("truncate", {
 	DENO: (path, size) => _duplojs_lang_common.pipe(path, _duplojs_lang_common.when(_duplojs_lang_common.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleDenoTruncateError))
 });
 //#endregion
+exports.TruncateError = TruncateError;
+exports.TruncateErrorBusy = TruncateErrorBusy;
+exports.TruncateErrorInvalidArgument = TruncateErrorInvalidArgument;
+exports.TruncateErrorIsDirectory = TruncateErrorIsDirectory;
+exports.TruncateErrorNoSpace = TruncateErrorNoSpace;
+exports.TruncateErrorNotDirectory = TruncateErrorNotDirectory;
+exports.TruncateErrorNotFound = TruncateErrorNotFound;
+exports.TruncateErrorPermissionDenied = TruncateErrorPermissionDenied;
+exports.TruncateErrorReadOnly = TruncateErrorReadOnly;
+exports.TruncateErrorTooManyOpenFiles = TruncateErrorTooManyOpenFiles;
 exports.truncate = truncate;

package/dist/file/truncate.d.ts

@@ -2,41 +2,41 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 declare const TruncateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-found", unknown>>, unknown>;
-declare class TruncateErrorNotFound extends TruncateErrorNotFound_base {
+export declare class TruncateErrorNotFound extends TruncateErrorNotFound_base {
 }
 declare const TruncateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-permission-denied", unknown>>, unknown>;
-declare class TruncateErrorPermissionDenied extends TruncateErrorPermissionDenied_base {
+export declare class TruncateErrorPermissionDenied extends TruncateErrorPermissionDenied_base {
 }
 declare const TruncateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-is-directory", unknown>>, unknown>;
-declare class TruncateErrorIsDirectory extends TruncateErrorIsDirectory_base {
+export declare class TruncateErrorIsDirectory extends TruncateErrorIsDirectory_base {
 }
 declare const TruncateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-directory", unknown>>, unknown>;
-declare class TruncateErrorNotDirectory extends TruncateErrorNotDirectory_base {
+export declare class TruncateErrorNotDirectory extends TruncateErrorNotDirectory_base {
 }
 declare const TruncateErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-no-space", unknown>>, unknown>;
-declare class TruncateErrorNoSpace extends TruncateErrorNoSpace_base {
+export declare class TruncateErrorNoSpace extends TruncateErrorNoSpace_base {
 }
 declare const TruncateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-read-only", unknown>>, unknown>;
-declare class TruncateErrorReadOnly extends TruncateErrorReadOnly_base {
+export declare class TruncateErrorReadOnly extends TruncateErrorReadOnly_base {
 }
 declare const TruncateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-invalid-argument", unknown>>, unknown>;
-declare class TruncateErrorInvalidArgument extends TruncateErrorInvalidArgument_base {
+export declare class TruncateErrorInvalidArgument extends TruncateErrorInvalidArgument_base {
 }
 declare const TruncateErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-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-truncate-too-many-open-files", unknown>>, unknown>;
-declare class TruncateErrorTooManyOpenFiles extends TruncateErrorTooManyOpenFiles_base {
+export declare class TruncateErrorTooManyOpenFiles extends TruncateErrorTooManyOpenFiles_base {
 }
 declare const TruncateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-busy", unknown>>, unknown>;
-declare class TruncateErrorBusy extends TruncateErrorBusy_base {
+export declare class TruncateErrorBusy extends TruncateErrorBusy_base {
 }
 declare const TruncateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-error", unknown>>, unknown>;
-declare class TruncateError extends TruncateError_base {
+export declare class TruncateError extends TruncateError_base {
 }
 export type TruncateErrors = (TruncateErrorNotFound | TruncateErrorPermissionDenied | TruncateErrorIsDirectory | TruncateErrorNotDirectory | TruncateErrorNoSpace | TruncateErrorReadOnly | TruncateErrorInvalidArgument | TruncateErrorTooManyOpenFiles | TruncateErrorBusy | TruncateError);
 export type TruncateResult = (DEither.Right<"file-system-truncate", void> | DEither.Left<"file-system-truncate-error", TruncateErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        truncate(path: string & DPath.Path, size?: number): Promise<TruncateResult>;
+        truncate(path: DPath.AnyPath, size?: number): Promise<TruncateResult>;
     }
 }
-export declare const truncate: (path: string & DPath.Path, size?: number) => Promise<TruncateResult>;
+export declare const truncate: (path: DPath.AnyPath, size?: number) => Promise<TruncateResult>;
 export {};

package/dist/file/truncate.mjs

@@ -44,4 +44,4 @@ const truncate = implementFunction("truncate", {
 	DENO: (path, size) => DCommon.pipe(path, DCommon.when(DCommon.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => DEither.right("file-system-truncate")).catch(handleDenoTruncateError))
 });
 //#endregion
-export { truncate };
+export { TruncateError, TruncateErrorBusy, TruncateErrorInvalidArgument, TruncateErrorIsDirectory, TruncateErrorNoSpace, TruncateErrorNotDirectory, TruncateErrorNotFound, TruncateErrorPermissionDenied, TruncateErrorReadOnly, TruncateErrorTooManyOpenFiles, truncate };

package/dist/file/unknownEntryInterface.cjs

@@ -2,6 +2,8 @@ const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("../kind.cjs");
 const require_stat = require("./stat.cjs");
 const require_exists = require("./exists.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 //#region scripts/file/unknownEntryInterface.ts
@@ -20,7 +22,7 @@ function createUnknownEntryInterface(path) {
 		return require_exists.exists(path);
 	}
 	return {
-		path,
+		path: _duplojs_lang_common.cast(path),
 		getName,
 		getParentPath,
 		stat: localStat,

package/dist/file/unknownEntryInterface.d.ts

@@ -3,15 +3,15 @@ import { ExistsResult } from './exists';
 import type * as DKind from "@duplojs/lang/kind";
 import * as DPath from "@duplojs/lang/path";
 declare const unknownInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/unknownInterface", unknown>>;
-export type EntryPath = (string & (DPath.Path | DPath.Absolute | DPath.Segment));
-export interface UnknownEntryInterface<GenericPath extends EntryPath = EntryPath> extends DKind.Kind<typeof unknownInterfaceKind> {
+export type EntryPath = DPath.AnyPath;
+export interface UnknownEntryInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> extends DKind.Kind<typeof unknownInterfaceKind> {
     path: GenericPath & DPath.Path;
     getName(): (string & DPath.Segment & DPath.Path) | null;
-    getParentPath(): (string & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
     stat(): Promise<StatResult>;
     exist(): Promise<ExistsResult>;
 }
-export declare function createUnknownEntryInterface<GenericPath extends EntryPath = EntryPath>(path: GenericPath): UnknownEntryInterface<GenericPath>;
+export declare function createUnknownEntryInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(path: GenericPath): UnknownEntryInterface<GenericPath>;
 export declare function isUnknownEntryInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, UnknownEntryInterface>;
 export declare const isUnknownEntryInterfaceFromUnknown: (input: unknown) => input is UnknownEntryInterface;
 export {};

package/dist/file/unknownEntryInterface.mjs

@@ -1,6 +1,7 @@
 import { createKind } from "../kind.mjs";
 import { stat } from "./stat.mjs";
 import { exists } from "./exists.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DPath from "@duplojs/lang/path";
 //#region scripts/file/unknownEntryInterface.ts
 const unknownInterfaceKind = createKind("unknownInterface");
@@ -18,7 +19,7 @@ function createUnknownEntryInterface(path) {
 		return exists(path);
 	}
 	return {
-		path,
+		path: DCommon.cast(path),
 		getName,
 		getParentPath,
 		stat: localStat,

package/dist/file/walkDirectory.cjs

@@ -41,7 +41,17 @@ const walkDirectory = require_implementor.implementFunction("walkDirectory", { N
 	return _duplojs_lang_common.pipe(result, _duplojs_lang_generator.map((dirent) => ({
 		dirent,
 		path: _duplojs_lang_path.resolveFrom(currentWorkDirectory, [_duplojs_lang_path.normalize(`${dirent.parentPath}/${dirent.name}`)])
-	})), _duplojs_lang_generator.filter((value) => params?.matcher ? params?.matcher(value.path) : true), _duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when(({ dirent }) => dirent.isFile(), ({ path }) => require_fileInterface.createFileInterface(path)), _duplojs_lang_pattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => require_folderInterface.createFolderInterface(path)), _duplojs_lang_pattern.otherwise(({ path }) => require_unknownEntryInterface.createUnknownEntryInterface(path)))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value));
+	})), (generator) => {
+		const matcher = params?.matcher;
+		if (!matcher) return generator;
+		return _duplojs_lang_generator.filter(generator, ({ path }) => matcher(path));
+	}, _duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when(({ dirent }) => dirent.isFile(), ({ path }) => require_fileInterface.createFileInterface(path)), _duplojs_lang_pattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => require_folderInterface.createFolderInterface(path)), _duplojs_lang_pattern.otherwise(({ path }) => require_unknownEntryInterface.createUnknownEntryInterface(path)))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value));
 }).catch(handleNodeWalkDirectoryError) });
 //#endregion
+exports.WalkDirectoryError = WalkDirectoryError;
+exports.WalkDirectoryErrorBusy = WalkDirectoryErrorBusy;
+exports.WalkDirectoryErrorNotDirectory = WalkDirectoryErrorNotDirectory;
+exports.WalkDirectoryErrorNotFound = WalkDirectoryErrorNotFound;
+exports.WalkDirectoryErrorPermissionDenied = WalkDirectoryErrorPermissionDenied;
+exports.WalkDirectoryErrorTooManyOpenFiles = WalkDirectoryErrorTooManyOpenFiles;
 exports.walkDirectory = walkDirectory;

package/dist/file/walkDirectory.d.ts

@@ -5,33 +5,33 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
 declare const WalkDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-not-found", unknown>>, unknown>;
-declare class WalkDirectoryErrorNotFound extends WalkDirectoryErrorNotFound_base {
+export declare class WalkDirectoryErrorNotFound extends WalkDirectoryErrorNotFound_base {
 }
 declare const WalkDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-permission-denied", unknown>>, unknown>;
-declare class WalkDirectoryErrorPermissionDenied extends WalkDirectoryErrorPermissionDenied_base {
+export declare class WalkDirectoryErrorPermissionDenied extends WalkDirectoryErrorPermissionDenied_base {
 }
 declare const WalkDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-not-directory", unknown>>, unknown>;
-declare class WalkDirectoryErrorNotDirectory extends WalkDirectoryErrorNotDirectory_base {
+export declare class WalkDirectoryErrorNotDirectory extends WalkDirectoryErrorNotDirectory_base {
 }
 declare const WalkDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-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-walk-directory-too-many-open-files", unknown>>, unknown>;
-declare class WalkDirectoryErrorTooManyOpenFiles extends WalkDirectoryErrorTooManyOpenFiles_base {
+export declare class WalkDirectoryErrorTooManyOpenFiles extends WalkDirectoryErrorTooManyOpenFiles_base {
 }
 declare const WalkDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-busy", unknown>>, unknown>;
-declare class WalkDirectoryErrorBusy extends WalkDirectoryErrorBusy_base {
+export declare class WalkDirectoryErrorBusy extends WalkDirectoryErrorBusy_base {
 }
 declare const WalkDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-error", unknown>>, unknown>;
-declare class WalkDirectoryError extends WalkDirectoryError_base {
+export declare class WalkDirectoryError extends WalkDirectoryError_base {
 }
 export type WalkDirectoryErrors = (WalkDirectoryErrorNotFound | WalkDirectoryErrorPermissionDenied | WalkDirectoryErrorNotDirectory | WalkDirectoryErrorTooManyOpenFiles | WalkDirectoryErrorBusy | WalkDirectoryError);
 export interface WalkDirectoryParams {
     recursive?: boolean;
-    matcher?: DPath.PathMatcher;
+    matcher?: DPath.PathMatcher<string & DPath.Absolute>;
 }
 export type WalkDirectoryResult = (DEither.Right<"file-system-walk-directory", Generator<FileInterface<string & DPath.Absolute> | FolderInterface<string & DPath.Absolute> | UnknownEntryInterface<string & DPath.Absolute>>> | DEither.Left<"file-system-walk-directory-error", WalkDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        walkDirectory(path: string & DPath.Path, params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
+        walkDirectory(path: DPath.AnyPath, params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
     }
 }
-export declare const walkDirectory: (path: string & DPath.Path, params?: WalkDirectoryParams) => Promise<WalkDirectoryResult>;
+export declare const walkDirectory: (path: DPath.AnyPath, params?: WalkDirectoryParams) => Promise<WalkDirectoryResult>;
 export {};

package/dist/file/walkDirectory.mjs

@@ -35,7 +35,11 @@ const walkDirectory = implementFunction("walkDirectory", { NODE: async (path, pa
 	return DCommon.pipe(result, DGenerator.map((dirent) => ({
 		dirent,
 		path: DPath.resolveFrom(currentWorkDirectory, [DPath.normalize(`${dirent.parentPath}/${dirent.name}`)])
-	})), DGenerator.filter((value) => params?.matcher ? params?.matcher(value.path) : true), DGenerator.map(DCommon.innerPipe(DPattern.when(({ dirent }) => dirent.isFile(), ({ path }) => createFileInterface(path)), DPattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => createFolderInterface(path)), DPattern.otherwise(({ path }) => createUnknownEntryInterface(path)))), (value) => DEither.right("file-system-walk-directory", value));
+	})), (generator) => {
+		const matcher = params?.matcher;
+		if (!matcher) return generator;
+		return DGenerator.filter(generator, ({ path }) => matcher(path));
+	}, DGenerator.map(DCommon.innerPipe(DPattern.when(({ dirent }) => dirent.isFile(), ({ path }) => createFileInterface(path)), DPattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => createFolderInterface(path)), DPattern.otherwise(({ path }) => createUnknownEntryInterface(path)))), (value) => DEither.right("file-system-walk-directory", value));
 }).catch(handleNodeWalkDirectoryError) });
 //#endregion
-export { walkDirectory };
+export { WalkDirectoryError, WalkDirectoryErrorBusy, WalkDirectoryErrorNotDirectory, WalkDirectoryErrorNotFound, WalkDirectoryErrorPermissionDenied, WalkDirectoryErrorTooManyOpenFiles, walkDirectory };

package/dist/file/writeFile.cjs

@@ -55,4 +55,14 @@ function writeFile(...args) {
 	return writeFileImplementation(...args);
 }
 //#endregion
+exports.WriteFileError = WriteFileError;
+exports.WriteFileErrorBusy = WriteFileErrorBusy;
+exports.WriteFileErrorInvalidArgument = WriteFileErrorInvalidArgument;
+exports.WriteFileErrorIsDirectory = WriteFileErrorIsDirectory;
+exports.WriteFileErrorNoSpace = WriteFileErrorNoSpace;
+exports.WriteFileErrorNotDirectory = WriteFileErrorNotDirectory;
+exports.WriteFileErrorNotFound = WriteFileErrorNotFound;
+exports.WriteFileErrorPermissionDenied = WriteFileErrorPermissionDenied;
+exports.WriteFileErrorReadOnly = WriteFileErrorReadOnly;
+exports.WriteFileErrorTooManyOpenFiles = WriteFileErrorTooManyOpenFiles;
 exports.writeFile = writeFile;

package/dist/file/writeFile.d.ts

@@ -2,42 +2,42 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 declare const WriteFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-not-found", unknown>>, unknown>;
-declare class WriteFileErrorNotFound extends WriteFileErrorNotFound_base {
+export declare class WriteFileErrorNotFound extends WriteFileErrorNotFound_base {
 }
 declare const WriteFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-permission-denied", unknown>>, unknown>;
-declare class WriteFileErrorPermissionDenied extends WriteFileErrorPermissionDenied_base {
+export declare class WriteFileErrorPermissionDenied extends WriteFileErrorPermissionDenied_base {
 }
 declare const WriteFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-is-directory", unknown>>, unknown>;
-declare class WriteFileErrorIsDirectory extends WriteFileErrorIsDirectory_base {
+export declare class WriteFileErrorIsDirectory extends WriteFileErrorIsDirectory_base {
 }
 declare const WriteFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-not-directory", unknown>>, unknown>;
-declare class WriteFileErrorNotDirectory extends WriteFileErrorNotDirectory_base {
+export declare class WriteFileErrorNotDirectory extends WriteFileErrorNotDirectory_base {
 }
 declare const WriteFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-no-space", unknown>>, unknown>;
-declare class WriteFileErrorNoSpace extends WriteFileErrorNoSpace_base {
+export declare class WriteFileErrorNoSpace extends WriteFileErrorNoSpace_base {
 }
 declare const WriteFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-read-only", unknown>>, unknown>;
-declare class WriteFileErrorReadOnly extends WriteFileErrorReadOnly_base {
+export declare class WriteFileErrorReadOnly extends WriteFileErrorReadOnly_base {
 }
 declare const WriteFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-invalid-argument", unknown>>, unknown>;
-declare class WriteFileErrorInvalidArgument extends WriteFileErrorInvalidArgument_base {
+export declare class WriteFileErrorInvalidArgument extends WriteFileErrorInvalidArgument_base {
 }
 declare const WriteFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-file-too-many-open-files", unknown>>, unknown>;
-declare class WriteFileErrorTooManyOpenFiles extends WriteFileErrorTooManyOpenFiles_base {
+export declare class WriteFileErrorTooManyOpenFiles extends WriteFileErrorTooManyOpenFiles_base {
 }
 declare const WriteFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-busy", unknown>>, unknown>;
-declare class WriteFileErrorBusy extends WriteFileErrorBusy_base {
+export declare class WriteFileErrorBusy extends WriteFileErrorBusy_base {
 }
 declare const WriteFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-error", unknown>>, unknown>;
-declare class WriteFileError extends WriteFileError_base {
+export declare class WriteFileError extends WriteFileError_base {
 }
 export type WriteFileErrors = (WriteFileErrorNotFound | WriteFileErrorPermissionDenied | WriteFileErrorIsDirectory | WriteFileErrorNotDirectory | WriteFileErrorNoSpace | WriteFileErrorReadOnly | WriteFileErrorInvalidArgument | WriteFileErrorTooManyOpenFiles | WriteFileErrorBusy | WriteFileError);
 export type WriteFileResult = (DEither.Right<"file-system-write-file", void> | DEither.Left<"file-system-write-file-error", WriteFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        writeFile(path: string & DPath.Path, data: Uint8Array): Promise<WriteFileResult>;
+        writeFile(path: DPath.AnyPath, data: Uint8Array): Promise<WriteFileResult>;
     }
 }
-export declare function writeFile(data: Uint8Array): (path: string & DPath.Path) => Promise<WriteFileResult>;
-export declare function writeFile(path: string & DPath.Path, data: Uint8Array): Promise<WriteFileResult>;
+export declare function writeFile(data: Uint8Array): (path: DPath.AnyPath) => Promise<WriteFileResult>;
+export declare function writeFile(path: DPath.AnyPath, data: Uint8Array): Promise<WriteFileResult>;
 export {};

package/dist/file/writeFile.mjs

@@ -52,4 +52,4 @@ function writeFile(...args) {
 	return writeFileImplementation(...args);
 }
 //#endregion
-export { writeFile };
+export { WriteFileError, WriteFileErrorBusy, WriteFileErrorInvalidArgument, WriteFileErrorIsDirectory, WriteFileErrorNoSpace, WriteFileErrorNotDirectory, WriteFileErrorNotFound, WriteFileErrorPermissionDenied, WriteFileErrorReadOnly, WriteFileErrorTooManyOpenFiles, writeFile };

package/dist/file/writeJsonFile.cjs

@@ -64,4 +64,14 @@ function writeJsonFile(...args) {
 	return writeJsonFileImplementation(...args);
 }
 //#endregion
+exports.WriteJsonFileError = WriteJsonFileError;
+exports.WriteJsonFileErrorBusy = WriteJsonFileErrorBusy;
+exports.WriteJsonFileErrorInvalidArgument = WriteJsonFileErrorInvalidArgument;
+exports.WriteJsonFileErrorIsDirectory = WriteJsonFileErrorIsDirectory;
+exports.WriteJsonFileErrorNoSpace = WriteJsonFileErrorNoSpace;
+exports.WriteJsonFileErrorNotDirectory = WriteJsonFileErrorNotDirectory;
+exports.WriteJsonFileErrorNotFound = WriteJsonFileErrorNotFound;
+exports.WriteJsonFileErrorPermissionDenied = WriteJsonFileErrorPermissionDenied;
+exports.WriteJsonFileErrorReadOnly = WriteJsonFileErrorReadOnly;
+exports.WriteJsonFileErrorTooManyOpenFiles = WriteJsonFileErrorTooManyOpenFiles;
 exports.writeJsonFile = writeJsonFile;

package/dist/file/writeJsonFile.d.ts

@@ -5,42 +5,42 @@ interface WriteJsonFileParams {
     space?: number;
 }
 declare const WriteJsonFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-json-file-not-found", unknown>>, unknown>;
-declare class WriteJsonFileErrorNotFound extends WriteJsonFileErrorNotFound_base {
+export declare class WriteJsonFileErrorNotFound extends WriteJsonFileErrorNotFound_base {
 }
 declare const WriteJsonFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-json-file-permission-denied", unknown>>, unknown>;
-declare class WriteJsonFileErrorPermissionDenied extends WriteJsonFileErrorPermissionDenied_base {
+export declare class WriteJsonFileErrorPermissionDenied extends WriteJsonFileErrorPermissionDenied_base {
 }
 declare const WriteJsonFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-json-file-is-directory", unknown>>, unknown>;
-declare class WriteJsonFileErrorIsDirectory extends WriteJsonFileErrorIsDirectory_base {
+export declare class WriteJsonFileErrorIsDirectory extends WriteJsonFileErrorIsDirectory_base {
 }
 declare const WriteJsonFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-json-file-not-directory", unknown>>, unknown>;
-declare class WriteJsonFileErrorNotDirectory extends WriteJsonFileErrorNotDirectory_base {
+export declare class WriteJsonFileErrorNotDirectory extends WriteJsonFileErrorNotDirectory_base {
 }
 declare const WriteJsonFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-no-space", unknown>>, unknown>;
-declare class WriteJsonFileErrorNoSpace extends WriteJsonFileErrorNoSpace_base {
+export declare class WriteJsonFileErrorNoSpace extends WriteJsonFileErrorNoSpace_base {
 }
 declare const WriteJsonFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-read-only", unknown>>, unknown>;
-declare class WriteJsonFileErrorReadOnly extends WriteJsonFileErrorReadOnly_base {
+export declare class WriteJsonFileErrorReadOnly extends WriteJsonFileErrorReadOnly_base {
 }
 declare const WriteJsonFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-invalid-argument", unknown>>, unknown>;
-declare class WriteJsonFileErrorInvalidArgument extends WriteJsonFileErrorInvalidArgument_base {
+export declare class WriteJsonFileErrorInvalidArgument extends WriteJsonFileErrorInvalidArgument_base {
 }
 declare const WriteJsonFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-json-file-too-many-open-files", unknown>>, unknown>;
-declare class WriteJsonFileErrorTooManyOpenFiles extends WriteJsonFileErrorTooManyOpenFiles_base {
+export declare class WriteJsonFileErrorTooManyOpenFiles extends WriteJsonFileErrorTooManyOpenFiles_base {
 }
 declare const WriteJsonFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-busy", unknown>>, unknown>;
-declare class WriteJsonFileErrorBusy extends WriteJsonFileErrorBusy_base {
+export declare class WriteJsonFileErrorBusy extends WriteJsonFileErrorBusy_base {
 }
 declare const WriteJsonFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-error", unknown>>, unknown>;
-declare class WriteJsonFileError extends WriteJsonFileError_base {
+export declare class WriteJsonFileError extends WriteJsonFileError_base {
 }
 export type WriteJsonFileErrors = (WriteJsonFileErrorNotFound | WriteJsonFileErrorPermissionDenied | WriteJsonFileErrorIsDirectory | WriteJsonFileErrorNotDirectory | WriteJsonFileErrorNoSpace | WriteJsonFileErrorReadOnly | WriteJsonFileErrorInvalidArgument | WriteJsonFileErrorTooManyOpenFiles | WriteJsonFileErrorBusy | WriteJsonFileError);
 export type WriteJsonFileResult = (DEither.Right<"file-system-write-json-file", void> | DEither.Left<"file-system-write-json-file-error", WriteJsonFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        writeJsonFile(path: string & DPath.Path, data: unknown, params?: WriteJsonFileParams): Promise<WriteJsonFileResult>;
+        writeJsonFile(path: DPath.AnyPath, data: unknown, params?: WriteJsonFileParams): Promise<WriteJsonFileResult>;
     }
 }
-export declare function writeJsonFile(data: unknown): (path: string & DPath.Path) => Promise<WriteJsonFileResult>;
-export declare function writeJsonFile(path: string & DPath.Path, data: unknown, params?: WriteJsonFileParams): Promise<WriteJsonFileResult>;
+export declare function writeJsonFile(data: unknown): (path: DPath.AnyPath) => Promise<WriteJsonFileResult>;
+export declare function writeJsonFile(path: DPath.AnyPath, data: unknown, params?: WriteJsonFileParams): Promise<WriteJsonFileResult>;
 export {};

package/dist/file/writeJsonFile.mjs

@@ -61,4 +61,4 @@ function writeJsonFile(...args) {
 	return writeJsonFileImplementation(...args);
 }
 //#endregion
-export { writeJsonFile };
+export { WriteJsonFileError, WriteJsonFileErrorBusy, WriteJsonFileErrorInvalidArgument, WriteJsonFileErrorIsDirectory, WriteJsonFileErrorNoSpace, WriteJsonFileErrorNotDirectory, WriteJsonFileErrorNotFound, WriteJsonFileErrorPermissionDenied, WriteJsonFileErrorReadOnly, WriteJsonFileErrorTooManyOpenFiles, writeJsonFile };

package/dist/file/writeTextFile.cjs

@@ -55,4 +55,14 @@ function writeTextFile(...args) {
 	return writeTextFileImplementation(...args);
 }
 //#endregion
+exports.WriteTextFileError = WriteTextFileError;
+exports.WriteTextFileErrorBusy = WriteTextFileErrorBusy;
+exports.WriteTextFileErrorInvalidArgument = WriteTextFileErrorInvalidArgument;
+exports.WriteTextFileErrorIsDirectory = WriteTextFileErrorIsDirectory;
+exports.WriteTextFileErrorNoSpace = WriteTextFileErrorNoSpace;
+exports.WriteTextFileErrorNotDirectory = WriteTextFileErrorNotDirectory;
+exports.WriteTextFileErrorNotFound = WriteTextFileErrorNotFound;
+exports.WriteTextFileErrorPermissionDenied = WriteTextFileErrorPermissionDenied;
+exports.WriteTextFileErrorReadOnly = WriteTextFileErrorReadOnly;
+exports.WriteTextFileErrorTooManyOpenFiles = WriteTextFileErrorTooManyOpenFiles;
 exports.writeTextFile = writeTextFile;

package/dist/file/writeTextFile.d.ts

@@ -2,42 +2,42 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 declare const WriteTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-not-found", unknown>>, unknown>;
-declare class WriteTextFileErrorNotFound extends WriteTextFileErrorNotFound_base {
+export declare class WriteTextFileErrorNotFound extends WriteTextFileErrorNotFound_base {
 }
 declare const WriteTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-permission-denied", unknown>>, unknown>;
-declare class WriteTextFileErrorPermissionDenied extends WriteTextFileErrorPermissionDenied_base {
+export declare class WriteTextFileErrorPermissionDenied extends WriteTextFileErrorPermissionDenied_base {
 }
 declare const WriteTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-is-directory", unknown>>, unknown>;
-declare class WriteTextFileErrorIsDirectory extends WriteTextFileErrorIsDirectory_base {
+export declare class WriteTextFileErrorIsDirectory extends WriteTextFileErrorIsDirectory_base {
 }
 declare const WriteTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-not-directory", unknown>>, unknown>;
-declare class WriteTextFileErrorNotDirectory extends WriteTextFileErrorNotDirectory_base {
+export declare class WriteTextFileErrorNotDirectory extends WriteTextFileErrorNotDirectory_base {
 }
 declare const WriteTextFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-no-space", unknown>>, unknown>;
-declare class WriteTextFileErrorNoSpace extends WriteTextFileErrorNoSpace_base {
+export declare class WriteTextFileErrorNoSpace extends WriteTextFileErrorNoSpace_base {
 }
 declare const WriteTextFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-read-only", unknown>>, unknown>;
-declare class WriteTextFileErrorReadOnly extends WriteTextFileErrorReadOnly_base {
+export declare class WriteTextFileErrorReadOnly extends WriteTextFileErrorReadOnly_base {
 }
 declare const WriteTextFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-invalid-argument", unknown>>, unknown>;
-declare class WriteTextFileErrorInvalidArgument extends WriteTextFileErrorInvalidArgument_base {
+export declare class WriteTextFileErrorInvalidArgument extends WriteTextFileErrorInvalidArgument_base {
 }
 declare const WriteTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-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-write-text-file-too-many-open-files", unknown>>, unknown>;
-declare class WriteTextFileErrorTooManyOpenFiles extends WriteTextFileErrorTooManyOpenFiles_base {
+export declare class WriteTextFileErrorTooManyOpenFiles extends WriteTextFileErrorTooManyOpenFiles_base {
 }
 declare const WriteTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-busy", unknown>>, unknown>;
-declare class WriteTextFileErrorBusy extends WriteTextFileErrorBusy_base {
+export declare class WriteTextFileErrorBusy extends WriteTextFileErrorBusy_base {
 }
 declare const WriteTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-error", unknown>>, unknown>;
-declare class WriteTextFileError extends WriteTextFileError_base {
+export declare class WriteTextFileError extends WriteTextFileError_base {
 }
 export type WriteTextFileErrors = (WriteTextFileErrorNotFound | WriteTextFileErrorPermissionDenied | WriteTextFileErrorIsDirectory | WriteTextFileErrorNotDirectory | WriteTextFileErrorNoSpace | WriteTextFileErrorReadOnly | WriteTextFileErrorInvalidArgument | WriteTextFileErrorTooManyOpenFiles | WriteTextFileErrorBusy | WriteTextFileError);
 export type WriteTextFileResult = (DEither.Right<"file-system-write-text-file", void> | DEither.Left<"file-system-write-text-file-error", WriteTextFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        writeTextFile(path: string & DPath.Path, data: string): Promise<WriteTextFileResult>;
+        writeTextFile(path: DPath.AnyPath, data: string): Promise<WriteTextFileResult>;
     }
 }
-export declare function writeTextFile(data: string): (path: string & DPath.Path) => Promise<WriteTextFileResult>;
-export declare function writeTextFile(path: string & DPath.Path, data: string): Promise<WriteTextFileResult>;
+export declare function writeTextFile(data: string): (path: DPath.AnyPath) => Promise<WriteTextFileResult>;
+export declare function writeTextFile(path: DPath.AnyPath, data: string): Promise<WriteTextFileResult>;
 export {};

package/dist/file/writeTextFile.mjs

@@ -52,4 +52,4 @@ function writeTextFile(...args) {
 	return writeTextFileImplementation(...args);
 }
 //#endregion
-export { writeTextFile };
+export { WriteTextFileError, WriteTextFileErrorBusy, WriteTextFileErrorInvalidArgument, WriteTextFileErrorIsDirectory, WriteTextFileErrorNoSpace, WriteTextFileErrorNotDirectory, WriteTextFileErrorNotFound, WriteTextFileErrorPermissionDenied, WriteTextFileErrorReadOnly, WriteTextFileErrorTooManyOpenFiles, writeTextFile };

package/dist/override.d.ts

@@ -0,0 +1,8 @@
+import { UnknownEntryInterface, FileInterface, FolderInterface } from './file';
+declare module "@duplojs/lang/common" {
+    interface ReplaceTraversalExclusions {
+        fileInterface: FileInterface;
+        folderInterface: FolderInterface;
+        unknownEntryInterface: UnknownEntryInterface;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/server",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.4",
   "license": "MIT",
   "author": {
     "name": "DuploJS",
@@ -47,10 +47,10 @@
     }
   },
   "peerDependencies": {
-    "@duplojs/lang": "0.1.0-beta.3"
+    "@duplojs/lang": "0.1.0-beta.4"
   },
   "devDependencies": {
-    "@duplojs/code-config": "0.1.0-beta.3",
+    "@duplojs/code-config": "0.1.0-beta.4",
     "@types/bun": "1.4.1",
     "@types/deno": "2.7.0",
     "@types/node": "24.13.3",