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

package/dist/file/relocate.cjs

@@ -69,4 +69,15 @@ function relocate(...args) {
 	return relocateImplementation(...args);
 }
 //#endregion
+exports.RelocateError = RelocateError;
+exports.RelocateErrorAlreadyExists = RelocateErrorAlreadyExists;
+exports.RelocateErrorBusy = RelocateErrorBusy;
+exports.RelocateErrorCrossDevice = RelocateErrorCrossDevice;
+exports.RelocateErrorDirectoryNotEmpty = RelocateErrorDirectoryNotEmpty;
+exports.RelocateErrorInvalidArgument = RelocateErrorInvalidArgument;
+exports.RelocateErrorIsDirectory = RelocateErrorIsDirectory;
+exports.RelocateErrorNotDirectory = RelocateErrorNotDirectory;
+exports.RelocateErrorNotFound = RelocateErrorNotFound;
+exports.RelocateErrorPermissionDenied = RelocateErrorPermissionDenied;
+exports.RelocateErrorReadOnly = RelocateErrorReadOnly;
 exports.relocate = relocate;

package/dist/file/relocate.d.ts

@@ -2,45 +2,45 @@ import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 declare const RelocateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-not-found", unknown>>, unknown>;
-declare class RelocateErrorNotFound extends RelocateErrorNotFound_base {
+export declare class RelocateErrorNotFound extends RelocateErrorNotFound_base {
 }
 declare const RelocateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-permission-denied", unknown>>, unknown>;
-declare class RelocateErrorPermissionDenied extends RelocateErrorPermissionDenied_base {
+export declare class RelocateErrorPermissionDenied extends RelocateErrorPermissionDenied_base {
 }
 declare const RelocateErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-already-exists", unknown>>, unknown>;
-declare class RelocateErrorAlreadyExists extends RelocateErrorAlreadyExists_base {
+export declare class RelocateErrorAlreadyExists extends RelocateErrorAlreadyExists_base {
 }
 declare const RelocateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-is-directory", unknown>>, unknown>;
-declare class RelocateErrorIsDirectory extends RelocateErrorIsDirectory_base {
+export declare class RelocateErrorIsDirectory extends RelocateErrorIsDirectory_base {
 }
 declare const RelocateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-not-directory", unknown>>, unknown>;
-declare class RelocateErrorNotDirectory extends RelocateErrorNotDirectory_base {
+export declare class RelocateErrorNotDirectory extends RelocateErrorNotDirectory_base {
 }
 declare const RelocateErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-directory-not-empty", unknown>>, unknown>;
-declare class RelocateErrorDirectoryNotEmpty extends RelocateErrorDirectoryNotEmpty_base {
+export declare class RelocateErrorDirectoryNotEmpty extends RelocateErrorDirectoryNotEmpty_base {
 }
 declare const RelocateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-read-only", unknown>>, unknown>;
-declare class RelocateErrorReadOnly extends RelocateErrorReadOnly_base {
+export declare class RelocateErrorReadOnly extends RelocateErrorReadOnly_base {
 }
 declare const RelocateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-invalid-argument", unknown>>, unknown>;
-declare class RelocateErrorInvalidArgument extends RelocateErrorInvalidArgument_base {
+export declare class RelocateErrorInvalidArgument extends RelocateErrorInvalidArgument_base {
 }
 declare const RelocateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-busy", unknown>>, unknown>;
-declare class RelocateErrorBusy extends RelocateErrorBusy_base {
+export declare class RelocateErrorBusy extends RelocateErrorBusy_base {
 }
 declare const RelocateErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-cross-device", unknown>>, unknown>;
-declare class RelocateErrorCrossDevice extends RelocateErrorCrossDevice_base {
+export declare class RelocateErrorCrossDevice extends RelocateErrorCrossDevice_base {
 }
 declare const RelocateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-error", unknown>>, unknown>;
-declare class RelocateError extends RelocateError_base {
+export declare class RelocateError extends RelocateError_base {
 }
 export type RelocateErrors = (RelocateErrorNotFound | RelocateErrorPermissionDenied | RelocateErrorAlreadyExists | RelocateErrorIsDirectory | RelocateErrorNotDirectory | RelocateErrorDirectoryNotEmpty | RelocateErrorReadOnly | RelocateErrorInvalidArgument | RelocateErrorBusy | RelocateErrorCrossDevice | RelocateError);
 export type RelocateResult = (DEither.Right<"file-system-relocate", string & DPath.Path> | DEither.Left<"file-system-relocate-error", RelocateErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        relocate(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<RelocateResult>;
+        relocate(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<RelocateResult>;
     }
 }
-export declare function relocate(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<RelocateResult>;
-export declare function relocate(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<RelocateResult>;
+export declare function relocate(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<RelocateResult>;
+export declare function relocate(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<RelocateResult>;
 export {};

package/dist/file/relocate.mjs

@@ -65,4 +65,4 @@ function relocate(...args) {
 	return relocateImplementation(...args);
 }
 //#endregion
-export { relocate };
+export { RelocateError, RelocateErrorAlreadyExists, RelocateErrorBusy, RelocateErrorCrossDevice, RelocateErrorDirectoryNotEmpty, RelocateErrorInvalidArgument, RelocateErrorIsDirectory, RelocateErrorNotDirectory, RelocateErrorNotFound, RelocateErrorPermissionDenied, RelocateErrorReadOnly, relocate };

package/dist/file/remove.cjs

@@ -48,4 +48,13 @@ const remove = require_implementor.implementFunction("remove", {
 	DENO: (path, params) => Deno.remove(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-remove")).catch(handleDenoRemoveError)
 });
 //#endregion
+exports.RemoveError = RemoveError;
+exports.RemoveErrorBusy = RemoveErrorBusy;
+exports.RemoveErrorDirectoryNotEmpty = RemoveErrorDirectoryNotEmpty;
+exports.RemoveErrorInvalidArgument = RemoveErrorInvalidArgument;
+exports.RemoveErrorIsDirectory = RemoveErrorIsDirectory;
+exports.RemoveErrorNotDirectory = RemoveErrorNotDirectory;
+exports.RemoveErrorNotFound = RemoveErrorNotFound;
+exports.RemoveErrorPermissionDenied = RemoveErrorPermissionDenied;
+exports.RemoveErrorReadOnly = RemoveErrorReadOnly;
 exports.remove = remove;

package/dist/file/remove.d.ts

@@ -5,38 +5,38 @@ interface RemoveDirectoryParams {
     recursive?: boolean;
 }
 declare const RemoveErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-not-found", unknown>>, unknown>;
-declare class RemoveErrorNotFound extends RemoveErrorNotFound_base {
+export declare class RemoveErrorNotFound extends RemoveErrorNotFound_base {
 }
 declare const RemoveErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-permission-denied", unknown>>, unknown>;
-declare class RemoveErrorPermissionDenied extends RemoveErrorPermissionDenied_base {
+export declare class RemoveErrorPermissionDenied extends RemoveErrorPermissionDenied_base {
 }
 declare const RemoveErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-is-directory", unknown>>, unknown>;
-declare class RemoveErrorIsDirectory extends RemoveErrorIsDirectory_base {
+export declare class RemoveErrorIsDirectory extends RemoveErrorIsDirectory_base {
 }
 declare const RemoveErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-not-directory", unknown>>, unknown>;
-declare class RemoveErrorNotDirectory extends RemoveErrorNotDirectory_base {
+export declare class RemoveErrorNotDirectory extends RemoveErrorNotDirectory_base {
 }
 declare const RemoveErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-directory-not-empty", unknown>>, unknown>;
-declare class RemoveErrorDirectoryNotEmpty extends RemoveErrorDirectoryNotEmpty_base {
+export declare class RemoveErrorDirectoryNotEmpty extends RemoveErrorDirectoryNotEmpty_base {
 }
 declare const RemoveErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-read-only", unknown>>, unknown>;
-declare class RemoveErrorReadOnly extends RemoveErrorReadOnly_base {
+export declare class RemoveErrorReadOnly extends RemoveErrorReadOnly_base {
 }
 declare const RemoveErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-invalid-argument", unknown>>, unknown>;
-declare class RemoveErrorInvalidArgument extends RemoveErrorInvalidArgument_base {
+export declare class RemoveErrorInvalidArgument extends RemoveErrorInvalidArgument_base {
 }
 declare const RemoveErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-busy", unknown>>, unknown>;
-declare class RemoveErrorBusy extends RemoveErrorBusy_base {
+export declare class RemoveErrorBusy extends RemoveErrorBusy_base {
 }
 declare const RemoveError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-error", unknown>>, unknown>;
-declare class RemoveError extends RemoveError_base {
+export declare class RemoveError extends RemoveError_base {
 }
 export type RemoveErrors = (RemoveErrorNotFound | RemoveErrorPermissionDenied | RemoveErrorIsDirectory | RemoveErrorNotDirectory | RemoveErrorDirectoryNotEmpty | RemoveErrorReadOnly | RemoveErrorInvalidArgument | RemoveErrorBusy | RemoveError);
 export type RemoveResult = (DEither.Right<"file-system-remove", void> | DEither.Left<"file-system-remove-error", RemoveErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        remove(path: string & DPath.Path, params?: RemoveDirectoryParams): Promise<RemoveResult>;
+        remove(path: DPath.AnyPath, params?: RemoveDirectoryParams): Promise<RemoveResult>;
     }
 }
-export declare const remove: (path: string & DPath.Path, params?: RemoveDirectoryParams) => Promise<RemoveResult>;
+export declare const remove: (path: DPath.AnyPath, params?: RemoveDirectoryParams) => Promise<RemoveResult>;
 export {};

package/dist/file/remove.mjs

@@ -45,4 +45,4 @@ const remove = implementFunction("remove", {
 	DENO: (path, params) => Deno.remove(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-remove")).catch(handleDenoRemoveError)
 });
 //#endregion
-export { remove };
+export { RemoveError, RemoveErrorBusy, RemoveErrorDirectoryNotEmpty, RemoveErrorInvalidArgument, RemoveErrorIsDirectory, RemoveErrorNotDirectory, RemoveErrorNotFound, RemoveErrorPermissionDenied, RemoveErrorReadOnly, remove };

package/dist/file/rename.cjs

@@ -69,4 +69,15 @@ function rename(...args) {
 	return renameImplementation(...args);
 }
 //#endregion
+exports.RenameError = RenameError;
+exports.RenameErrorAlreadyExists = RenameErrorAlreadyExists;
+exports.RenameErrorBusy = RenameErrorBusy;
+exports.RenameErrorCrossDevice = RenameErrorCrossDevice;
+exports.RenameErrorDirectoryNotEmpty = RenameErrorDirectoryNotEmpty;
+exports.RenameErrorInvalidArgument = RenameErrorInvalidArgument;
+exports.RenameErrorIsDirectory = RenameErrorIsDirectory;
+exports.RenameErrorNotDirectory = RenameErrorNotDirectory;
+exports.RenameErrorNotFound = RenameErrorNotFound;
+exports.RenameErrorPermissionDenied = RenameErrorPermissionDenied;
+exports.RenameErrorReadOnly = RenameErrorReadOnly;
 exports.rename = rename;

package/dist/file/rename.d.ts

@@ -2,45 +2,45 @@ import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 declare const RenameErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-not-found", unknown>>, unknown>;
-declare class RenameErrorNotFound extends RenameErrorNotFound_base {
+export declare class RenameErrorNotFound extends RenameErrorNotFound_base {
 }
 declare const RenameErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-permission-denied", unknown>>, unknown>;
-declare class RenameErrorPermissionDenied extends RenameErrorPermissionDenied_base {
+export declare class RenameErrorPermissionDenied extends RenameErrorPermissionDenied_base {
 }
 declare const RenameErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-already-exists", unknown>>, unknown>;
-declare class RenameErrorAlreadyExists extends RenameErrorAlreadyExists_base {
+export declare class RenameErrorAlreadyExists extends RenameErrorAlreadyExists_base {
 }
 declare const RenameErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-is-directory", unknown>>, unknown>;
-declare class RenameErrorIsDirectory extends RenameErrorIsDirectory_base {
+export declare class RenameErrorIsDirectory extends RenameErrorIsDirectory_base {
 }
 declare const RenameErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-not-directory", unknown>>, unknown>;
-declare class RenameErrorNotDirectory extends RenameErrorNotDirectory_base {
+export declare class RenameErrorNotDirectory extends RenameErrorNotDirectory_base {
 }
 declare const RenameErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-directory-not-empty", unknown>>, unknown>;
-declare class RenameErrorDirectoryNotEmpty extends RenameErrorDirectoryNotEmpty_base {
+export declare class RenameErrorDirectoryNotEmpty extends RenameErrorDirectoryNotEmpty_base {
 }
 declare const RenameErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-read-only", unknown>>, unknown>;
-declare class RenameErrorReadOnly extends RenameErrorReadOnly_base {
+export declare class RenameErrorReadOnly extends RenameErrorReadOnly_base {
 }
 declare const RenameErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-invalid-argument", unknown>>, unknown>;
-declare class RenameErrorInvalidArgument extends RenameErrorInvalidArgument_base {
+export declare class RenameErrorInvalidArgument extends RenameErrorInvalidArgument_base {
 }
 declare const RenameErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-busy", unknown>>, unknown>;
-declare class RenameErrorBusy extends RenameErrorBusy_base {
+export declare class RenameErrorBusy extends RenameErrorBusy_base {
 }
 declare const RenameErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-cross-device", unknown>>, unknown>;
-declare class RenameErrorCrossDevice extends RenameErrorCrossDevice_base {
+export declare class RenameErrorCrossDevice extends RenameErrorCrossDevice_base {
 }
 declare const RenameError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-error", unknown>>, unknown>;
-declare class RenameError extends RenameError_base {
+export declare class RenameError extends RenameError_base {
 }
 export type RenameErrors = (RenameErrorNotFound | RenameErrorPermissionDenied | RenameErrorAlreadyExists | RenameErrorIsDirectory | RenameErrorNotDirectory | RenameErrorDirectoryNotEmpty | RenameErrorReadOnly | RenameErrorInvalidArgument | RenameErrorBusy | RenameErrorCrossDevice | RenameError);
 export type RenameResult = (DEither.Right<"file-system-rename", string & DPath.Path> | DEither.Left<"file-system-rename-error", RenameErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        rename(path: string & DPath.Path, newName: string & DPath.Segment): Promise<RenameResult>;
+        rename(path: DPath.AnyPath, newName: string & DPath.Segment): Promise<RenameResult>;
     }
 }
-export declare function rename(newName: string & DPath.Segment): (path: string & DPath.Path) => Promise<RenameResult>;
-export declare function rename(path: string & DPath.Path, newName: string & DPath.Segment): Promise<RenameResult>;
+export declare function rename(newName: string & DPath.Segment): (path: DPath.AnyPath) => Promise<RenameResult>;
+export declare function rename(path: DPath.AnyPath, newName: string & DPath.Segment): Promise<RenameResult>;
 export {};

package/dist/file/rename.mjs

@@ -65,4 +65,4 @@ function rename(...args) {
 	return renameImplementation(...args);
 }
 //#endregion
-export { rename };
+export { RenameError, RenameErrorAlreadyExists, RenameErrorBusy, RenameErrorCrossDevice, RenameErrorDirectoryNotEmpty, RenameErrorInvalidArgument, RenameErrorIsDirectory, RenameErrorNotDirectory, RenameErrorNotFound, RenameErrorPermissionDenied, RenameErrorReadOnly, rename };

package/dist/file/setMode.cjs

@@ -56,4 +56,10 @@ function setMode(...args) {
 	return setModeImplementation(...args);
 }
 //#endregion
+exports.SetModeError = SetModeError;
+exports.SetModeErrorInvalidArgument = SetModeErrorInvalidArgument;
+exports.SetModeErrorNotDirectory = SetModeErrorNotDirectory;
+exports.SetModeErrorNotFound = SetModeErrorNotFound;
+exports.SetModeErrorPermissionDenied = SetModeErrorPermissionDenied;
+exports.SetModeErrorReadOnly = SetModeErrorReadOnly;
 exports.setMode = setMode;

package/dist/file/setMode.d.ts

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

package/dist/file/setMode.mjs

@@ -53,4 +53,4 @@ function setMode(...args) {
 	return setModeImplementation(...args);
 }
 //#endregion
-export { setMode };
+export { SetModeError, SetModeErrorInvalidArgument, SetModeErrorNotDirectory, SetModeErrorNotFound, SetModeErrorPermissionDenied, SetModeErrorReadOnly, setMode };

package/dist/file/setOwner.cjs

@@ -44,4 +44,10 @@ function setOwner(...args) {
 	return setOwnerImplementation(...args);
 }
 //#endregion
+exports.SetOwnerError = SetOwnerError;
+exports.SetOwnerErrorInvalidArgument = SetOwnerErrorInvalidArgument;
+exports.SetOwnerErrorNotDirectory = SetOwnerErrorNotDirectory;
+exports.SetOwnerErrorNotFound = SetOwnerErrorNotFound;
+exports.SetOwnerErrorPermissionDenied = SetOwnerErrorPermissionDenied;
+exports.SetOwnerErrorReadOnly = SetOwnerErrorReadOnly;
 exports.setOwner = setOwner;

package/dist/file/setOwner.d.ts

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

package/dist/file/setOwner.mjs

@@ -41,4 +41,4 @@ function setOwner(...args) {
 	return setOwnerImplementation(...args);
 }
 //#endregion
-export { setOwner };
+export { SetOwnerError, SetOwnerErrorInvalidArgument, SetOwnerErrorNotDirectory, SetOwnerErrorNotFound, SetOwnerErrorPermissionDenied, SetOwnerErrorReadOnly, setOwner };

package/dist/file/setTime.cjs

@@ -46,4 +46,10 @@ function setTime(...args) {
 	return setTimeImplementation(...args);
 }
 //#endregion
+exports.SetTimeError = SetTimeError;
+exports.SetTimeErrorInvalidArgument = SetTimeErrorInvalidArgument;
+exports.SetTimeErrorNotDirectory = SetTimeErrorNotDirectory;
+exports.SetTimeErrorNotFound = SetTimeErrorNotFound;
+exports.SetTimeErrorPermissionDenied = SetTimeErrorPermissionDenied;
+exports.SetTimeErrorReadOnly = SetTimeErrorReadOnly;
 exports.setTime = setTime;

package/dist/file/setTime.d.ts

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

package/dist/file/setTime.mjs

@@ -42,4 +42,4 @@ function setTime(...args) {
 	return setTimeImplementation(...args);
 }
 //#endregion
-export { setTime };
+export { SetTimeError, SetTimeErrorInvalidArgument, SetTimeErrorNotDirectory, SetTimeErrorNotFound, SetTimeErrorPermissionDenied, SetTimeErrorReadOnly, setTime };

package/dist/file/stat.cjs

@@ -90,4 +90,10 @@ const stat = require_implementor.implementFunction("stat", {
 	BUN: (path) => Bun.file(path).stat().then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError)
 });
 //#endregion
+exports.StatError = StatError;
+exports.StatErrorBusy = StatErrorBusy;
+exports.StatErrorNotDirectory = StatErrorNotDirectory;
+exports.StatErrorNotFound = StatErrorNotFound;
+exports.StatErrorPermissionDenied = StatErrorPermissionDenied;
+exports.StatErrorTooManyOpenFiles = StatErrorTooManyOpenFiles;
 exports.stat = stat;

package/dist/file/stat.d.ts

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

package/dist/file/stat.mjs

@@ -86,4 +86,4 @@ const stat = implementFunction("stat", {
 	BUN: (path) => Bun.file(path).stat().then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-stat", value))).catch(handleNodeStatError)
 });
 //#endregion
-export { stat };
+export { StatError, StatErrorBusy, StatErrorNotDirectory, StatErrorNotFound, StatErrorPermissionDenied, StatErrorTooManyOpenFiles, stat };

package/dist/file/symlink.cjs

@@ -52,4 +52,13 @@ function symlink(...args) {
 	return symlinkImplementation(...args);
 }
 //#endregion
+exports.SymlinkError = SymlinkError;
+exports.SymlinkErrorAlreadyExists = SymlinkErrorAlreadyExists;
+exports.SymlinkErrorBusy = SymlinkErrorBusy;
+exports.SymlinkErrorInvalidArgument = SymlinkErrorInvalidArgument;
+exports.SymlinkErrorNotDirectory = SymlinkErrorNotDirectory;
+exports.SymlinkErrorNotFound = SymlinkErrorNotFound;
+exports.SymlinkErrorPermissionDenied = SymlinkErrorPermissionDenied;
+exports.SymlinkErrorReadOnly = SymlinkErrorReadOnly;
+exports.SymlinkErrorTooManyOpenFiles = SymlinkErrorTooManyOpenFiles;
 exports.symlink = symlink;

package/dist/file/symlink.d.ts

@@ -10,39 +10,39 @@ export interface SymlinkParams {
     type: "file" | "dir" | "junction";
 }
 declare const SymlinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-found", unknown>>, unknown>;
-declare class SymlinkErrorNotFound extends SymlinkErrorNotFound_base {
+export declare class SymlinkErrorNotFound extends SymlinkErrorNotFound_base {
 }
 declare const SymlinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-permission-denied", unknown>>, unknown>;
-declare class SymlinkErrorPermissionDenied extends SymlinkErrorPermissionDenied_base {
+export declare class SymlinkErrorPermissionDenied extends SymlinkErrorPermissionDenied_base {
 }
 declare const SymlinkErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-already-exists", unknown>>, unknown>;
-declare class SymlinkErrorAlreadyExists extends SymlinkErrorAlreadyExists_base {
+export declare class SymlinkErrorAlreadyExists extends SymlinkErrorAlreadyExists_base {
 }
 declare const SymlinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-directory", unknown>>, unknown>;
-declare class SymlinkErrorNotDirectory extends SymlinkErrorNotDirectory_base {
+export declare class SymlinkErrorNotDirectory extends SymlinkErrorNotDirectory_base {
 }
 declare const SymlinkErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-read-only", unknown>>, unknown>;
-declare class SymlinkErrorReadOnly extends SymlinkErrorReadOnly_base {
+export declare class SymlinkErrorReadOnly extends SymlinkErrorReadOnly_base {
 }
 declare const SymlinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-invalid-argument", unknown>>, unknown>;
-declare class SymlinkErrorInvalidArgument extends SymlinkErrorInvalidArgument_base {
+export declare class SymlinkErrorInvalidArgument extends SymlinkErrorInvalidArgument_base {
 }
 declare const SymlinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-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-symlink-too-many-open-files", unknown>>, unknown>;
-declare class SymlinkErrorTooManyOpenFiles extends SymlinkErrorTooManyOpenFiles_base {
+export declare class SymlinkErrorTooManyOpenFiles extends SymlinkErrorTooManyOpenFiles_base {
 }
 declare const SymlinkErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-busy", unknown>>, unknown>;
-declare class SymlinkErrorBusy extends SymlinkErrorBusy_base {
+export declare class SymlinkErrorBusy extends SymlinkErrorBusy_base {
 }
 declare const SymlinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-error", unknown>>, unknown>;
-declare class SymlinkError extends SymlinkError_base {
+export declare class SymlinkError extends SymlinkError_base {
 }
 export type SymlinkErrors = (SymlinkErrorNotFound | SymlinkErrorPermissionDenied | SymlinkErrorAlreadyExists | SymlinkErrorNotDirectory | SymlinkErrorReadOnly | SymlinkErrorInvalidArgument | SymlinkErrorTooManyOpenFiles | SymlinkErrorBusy | SymlinkError);
 export type SymlinkResult = (DEither.Right<"file-system-symlink", void> | DEither.Left<"file-system-symlink-error", SymlinkErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
+        symlink(oldPath: DPath.AnyPath, newPath: DPath.AnyPath, params?: SymlinkParams): Promise<SymlinkResult>;
     }
 }
-export declare function symlink(newPath: string & DPath.Path): (oldPath: string & DPath.Path) => Promise<SymlinkResult>;
-export declare function symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
+export declare function symlink(newPath: DPath.AnyPath): (oldPath: DPath.AnyPath) => Promise<SymlinkResult>;
+export declare function symlink(oldPath: DPath.AnyPath, newPath: DPath.AnyPath, params?: SymlinkParams): Promise<SymlinkResult>;
 export {};

package/dist/file/symlink.mjs

@@ -49,4 +49,4 @@ function symlink(...args) {
 	return symlinkImplementation(...args);
 }
 //#endregion
-export { symlink };
+export { SymlinkError, SymlinkErrorAlreadyExists, SymlinkErrorBusy, SymlinkErrorInvalidArgument, SymlinkErrorNotDirectory, SymlinkErrorNotFound, SymlinkErrorPermissionDenied, SymlinkErrorReadOnly, SymlinkErrorTooManyOpenFiles, symlink };