@fgv/ts-json-base 5.1.0-0 → 5.1.0-10

package/dist/ts-json-base.d.ts

@@ -9,6 +9,30 @@ import { Validation } from '@fgv/ts-utils';
 import { Validator } from '@fgv/ts-utils';
 import { Validators as Validators_3 } from '@fgv/ts-utils';
 
+/**
+ * A directory item that may or may not be mutable at runtime.
+ *
+ * Use this type for parameters or fields where the code checks for mutability
+ * and handles the read-only case gracefully. Use {@link FileTree.IMutableFileTreeDirectoryItem}
+ * when mutation is required.
+ *
+ * Narrow with {@link FileTree.isMutableDirectoryItem} to access mutation methods.
+ * @public
+ */
+declare type AnyFileTreeDirectoryItem<TCT extends string = string> = IFileTreeDirectoryItem<TCT> | IMutableFileTreeDirectoryItem<TCT>;
+
+/**
+ * A file item that may or may not be mutable at runtime.
+ *
+ * Use this type for parameters or fields where the code checks for mutability
+ * and handles the read-only case gracefully. Use {@link FileTree.IMutableFileTreeFileItem}
+ * when mutation is required.
+ *
+ * Narrow with {@link FileTree.isMutableFileItem} to access mutation methods.
+ * @public
+ */
+declare type AnyFileTreeFileItem<TCT extends string = string> = IFileTreeFileItem<TCT> | IMutableFileTreeFileItem<TCT>;
+
 /**
  * A converter which converts a supplied `unknown` value to a valid array of {@link JsonCompatibleType | JsonCompatible} values.
  * @public
@@ -158,7 +182,7 @@ declare const DefaultJsonTreeHelper: JsonTreeHelper;
  * Class representing a directory in a file tree.
  * @public
  */
-declare class DirectoryItem<TCT extends string = string> implements IFileTreeDirectoryItem<TCT> {
+declare class DirectoryItem<TCT extends string = string> implements IMutableFileTreeDirectoryItem<TCT> {
     /**
      * {@inheritDoc FileTree.IFileTreeDirectoryItem."type"}
      */
@@ -198,13 +222,28 @@ declare class DirectoryItem<TCT extends string = string> implements IFileTreeDir
      */
     getChildren(): Result<ReadonlyArray<FileTreeItem<TCT>>>;
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildFile}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildFile}
+     */
+    createChildFile(name: string, contents: string): Result<IMutableFileTreeFileItem<TCT>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildDirectory}
+     */
+    createChildDirectory(name: string): Result<IMutableFileTreeDirectoryItem<TCT>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.deleteChild}
      */
-    createChildFile(name: string, contents: string): Result<IFileTreeFileItem<TCT>>;
+    deleteChild(name: string, options?: IDeleteChildOptions): Result<boolean>;
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildDirectory}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.delete}
      */
-    createChildDirectory(name: string): Result<IFileTreeDirectoryItem<TCT>>;
+    delete(): Result<boolean>;
+    /**
+     * Recursively deletes all children of a directory and then the directory itself.
+     * @param dirPath - The absolute path of the directory to delete.
+     * @returns `Success` with `true` if the directory was deleted, or `Failure` with an error message.
+     * @internal
+     */
+    private _deleteRecursive;
 }
 
 /**
@@ -254,7 +293,7 @@ declare function enumeratedValue_2<T>(values: ReadonlyArray<T>, message?: string
  * Class representing a file in a file tree.
  * @public
  */
-declare class FileItem<TCT extends string = string> implements IFileTreeFileItem<TCT> {
+declare class FileItem<TCT extends string = string> implements IMutableFileTreeFileItem<TCT> {
     /**
      * {@inheritDoc FileTree.IFileTreeFileItem."type"}
      */
@@ -334,6 +373,10 @@ declare class FileItem<TCT extends string = string> implements IFileTreeFileItem
      * {@inheritDoc FileTree.IFileTreeFileItem.setRawContents}
      */
     setRawContents(contents: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.delete}
+     */
+    delete(): Result<boolean>;
     /**
      * Default function to infer the content type of a file.
      * @param filePath - The path of the file.
@@ -361,6 +404,8 @@ declare namespace FileTree {
         inMemory,
         isMutableAccessors,
         isPersistentAccessors,
+        isMutableFileItem,
+        isMutableDirectoryItem,
         SaveCapability,
         SaveFailureReason,
         SaveDetail,
@@ -368,9 +413,15 @@ declare namespace FileTree {
         FileTreeItemType,
         ContentTypeFactory,
         IFileTreeInitParams,
+        IDeleteChildOptions,
         IFileTreeFileItem,
+        IMutableFileTreeFileItem,
         IFileTreeDirectoryItem,
+        IMutableFileTreeDirectoryItem,
         FileTreeItem,
+        MutableFileTreeItem,
+        AnyFileTreeFileItem,
+        AnyFileTreeDirectoryItem,
         IFileTreeAccessors,
         IMutableFileTreeAccessors,
         IPersistentFileTreeAccessors,
@@ -530,10 +581,30 @@ declare class FsFileTreeAccessors<TCT extends string = string> implements IMutab
      * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
      */
     saveFileContents(path: string, contents: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path: string): Result<boolean>;
     /**
      * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
      */
     createDirectory(dirPath: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(dirPath: string): Result<boolean>;
+}
+
+/**
+ * Options for deleting a child item from a directory.
+ * @public
+ */
+declare interface IDeleteChildOptions {
+    /**
+     * If true, recursively delete directory children and their contents.
+     * Default: false (fail if directory is non-empty).
+     */
+    recursive?: boolean;
 }
 
 /**
@@ -595,7 +666,7 @@ declare interface IFileTreeAccessors<TCT extends string = string> {
 }
 
 /**
- * Interface for a directory in a file tree.
+ * Interface for a read-only directory in a file tree.
  * @public
  */
 declare interface IFileTreeDirectoryItem<TCT extends string = string> {
@@ -617,25 +688,10 @@ declare interface IFileTreeDirectoryItem<TCT extends string = string> {
      * or `Failure` with an error message otherwise.
      */
     getChildren(): Result<ReadonlyArray<FileTreeItem<TCT>>>;
-    /**
-     * Creates a new file as a child of this directory.
-     * @param name - The file name to create.
-     * @param contents - The string contents to write.
-     * @returns `Success` with the new file item, or `Failure` with an error message.
-     * @remarks This method is optional. Only available on mutable directory items.
-     */
-    createChildFile?(name: string, contents: string): Result<IFileTreeFileItem<TCT>>;
-    /**
-     * Creates a new subdirectory as a child of this directory.
-     * @param name - The directory name to create.
-     * @returns `Success` with the new directory item, or `Failure` with an error message.
-     * @remarks This method is optional. Only available on mutable directory items.
-     */
-    createChildDirectory?(name: string): Result<IFileTreeDirectoryItem<TCT>>;
 }
 
 /**
- * Interface for a file in a file tree.
+ * Interface for a read-only file in a file tree.
  * @public
  */
 declare interface IFileTreeFileItem<TCT extends string = string> {
@@ -683,27 +739,6 @@ declare interface IFileTreeFileItem<TCT extends string = string> {
      * `Failure` with an error message otherwise.
      */
     getRawContents(): Result<string>;
-    /**
-     * Indicates whether this file can be saved.
-     * @returns `DetailedSuccess` with {@link FileTree.SaveCapability} if the file can be saved,
-     * or `DetailedFailure` with {@link FileTree.SaveFailureReason} if it cannot.
-     * @remarks This property is optional. If not present, the file is not mutable.
-     */
-    getIsMutable(): DetailedResult<boolean, SaveDetail>;
-    /**
-     * Sets the contents of the file from a JSON value.
-     * @param json - The JSON value to serialize and save.
-     * @returns `Success` if the file was saved, or `Failure` with an error message.
-     * @remarks This method is optional. If not present, the file is not mutable.
-     */
-    setContents(json: JsonValue): Result<JsonValue>;
-    /**
-     * Sets the raw contents of the file.
-     * @param contents - The string contents to save.
-     * @returns `Success` if the file was saved, or `Failure` with an error message.
-     * @remarks This method is optional. If not present, the file is not mutable.
-     */
-    setRawContents(contents: string): Result<string>;
 }
 
 /**
@@ -816,6 +851,8 @@ declare interface IJsonValidatorContext {
 
 /**
  * Extended accessors interface that supports mutation operations.
+ * All mutation methods are required — use {@link FileTree.isMutableAccessors | isMutableAccessors}
+ * type guard to check if an accessor supports mutation.
  * @public
  */
 declare interface IMutableFileTreeAccessors<TCT extends string = string> extends IFileTreeAccessors<TCT> {
@@ -833,12 +870,90 @@ declare interface IMutableFileTreeAccessors<TCT extends string = string> extends
      * @returns `Success` if the file was saved, or `Failure` with an error message.
      */
     saveFileContents(path: string, contents: string): Result<string>;
+    /**
+     * Deletes a file at the given path.
+     * @param path - The path of the file to delete.
+     * @returns `Success` with `true` if the file was deleted, or `Failure` with an error message.
+     */
+    deleteFile(path: string): Result<boolean>;
     /**
      * Creates a directory at the given path, including any missing parent directories.
      * @param path - The path of the directory to create.
      * @returns `Success` with the absolute path if created, or `Failure` with an error message.
      */
-    createDirectory?(path: string): Result<string>;
+    createDirectory(path: string): Result<string>;
+    /**
+     * Deletes a directory at the given path.
+     * The directory must be empty or the operation will fail.
+     * @param path - The path of the directory to delete.
+     * @returns `Success` with `true` if the directory was deleted, or `Failure` with an error message.
+     */
+    deleteDirectory(path: string): Result<boolean>;
+}
+
+/**
+ * Extended directory item interface that supports mutation operations.
+ * Use {@link FileTree.isMutableDirectoryItem | isMutableDirectoryItem} type guard to narrow.
+ * @public
+ */
+declare interface IMutableFileTreeDirectoryItem<TCT extends string = string> extends IFileTreeDirectoryItem<TCT> {
+    /**
+     * Creates a new file as a child of this directory.
+     * @param name - The file name to create.
+     * @param contents - The string contents to write.
+     * @returns `Success` with the new file item, or `Failure` with an error message.
+     */
+    createChildFile(name: string, contents: string): Result<IMutableFileTreeFileItem<TCT>>;
+    /**
+     * Creates a new subdirectory as a child of this directory.
+     * @param name - The directory name to create.
+     * @returns `Success` with the new directory item, or `Failure` with an error message.
+     */
+    createChildDirectory(name: string): Result<IMutableFileTreeDirectoryItem<TCT>>;
+    /**
+     * Deletes a child item from this directory.
+     * @param name - The name of the child to delete.
+     * @param options - Optional {@link FileTree.IDeleteChildOptions | options} controlling deletion behavior.
+     * @returns `Success` with `true` if the child was deleted, or `Failure` with an error message.
+     */
+    deleteChild(name: string, options?: IDeleteChildOptions): Result<boolean>;
+    /**
+     * Deletes this directory from its backing store.
+     * The directory must be empty or the operation will fail.
+     * @returns `Success` with `true` if the directory was deleted, or `Failure` with an error message.
+     */
+    delete(): Result<boolean>;
+}
+
+/**
+ * Extended file item interface that supports mutation operations.
+ * Use {@link FileTree.isMutableFileItem | isMutableFileItem} type guard to narrow.
+ * @public
+ */
+declare interface IMutableFileTreeFileItem<TCT extends string = string> extends IFileTreeFileItem<TCT> {
+    /**
+     * Indicates whether this file can be saved.
+     * @returns `DetailedSuccess` with {@link FileTree.SaveCapability} if the file can be saved,
+     * or `DetailedFailure` with {@link FileTree.SaveFailureReason} if it cannot.
+     */
+    getIsMutable(): DetailedResult<boolean, SaveDetail>;
+    /**
+     * Sets the contents of the file from a JSON value.
+     * @param json - The JSON value to serialize and save.
+     * @returns `Success` if the file was saved, or `Failure` with an error message.
+     */
+    setContents(json: JsonValue): Result<JsonValue>;
+    /**
+     * Sets the raw contents of the file.
+     * @param contents - The string contents to save.
+     * @returns `Success` if the file was saved, or `Failure` with an error message.
+     */
+    setRawContents(contents: string): Result<string>;
+    /**
+     * Deletes this file from its backing store.
+     * @returns `Success` with `true` if the file was deleted, or `Failure` with an error message.
+     */
+    delete(): Result<boolean>;
 }
 
 /**
@@ -936,6 +1051,14 @@ declare class InMemoryTreeAccessors<TCT extends string = string> implements IMut
      * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
      */
     fileIsMutable(path: string): DetailedResult<boolean, SaveDetail>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path: string): Result<boolean>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(path: string): Result<boolean>;
     /**
      * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
      */
@@ -1014,6 +1137,22 @@ export declare function isJsonPrimitive(from: unknown): from is JsonPrimitive;
  */
 declare function isMutableAccessors<TCT extends string = string>(accessors: IFileTreeAccessors<TCT>): accessors is IMutableFileTreeAccessors<TCT>;
 
+/**
+ * Type guard to check if a directory item supports mutation.
+ * @param item - The directory item to check.
+ * @returns `true` if the item implements {@link FileTree.IMutableFileTreeDirectoryItem}.
+ * @public
+ */
+declare function isMutableDirectoryItem<TCT extends string = string>(item: AnyFileTreeDirectoryItem<TCT> | FileTreeItem<TCT>): item is IMutableFileTreeDirectoryItem<TCT>;
+
+/**
+ * Type guard to check if a file item supports mutation.
+ * @param item - The file item to check.
+ * @returns `true` if the item implements {@link FileTree.IMutableFileTreeFileItem}.
+ * @public
+ */
+declare function isMutableFileItem<TCT extends string = string>(item: AnyFileTreeFileItem<TCT> | FileTreeItem<TCT>): item is IMutableFileTreeFileItem<TCT>;
+
 /**
  * Checks if a path is allowed by a mutability configuration.
  * @param path - The path to check.
@@ -1419,6 +1558,12 @@ declare function literal<T>(value: T): Converter<T, IJsonConverterContext>;
  */
 declare function literal_2<T>(value: T): Validator<T, IJsonValidatorContext>;
 
+/**
+ * Type for a mutable item in a file tree.
+ * @public
+ */
+declare type MutableFileTreeItem<TCT extends string = string> = IMutableFileTreeFileItem<TCT> | IMutableFileTreeDirectoryItem<TCT>;
+
 /**
  * A `Converter` which converts `unknown` to a `number`.
  * Accepts `IJsonConverterContext` but ignores it.

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.57.6"
+      "packageVersion": "7.57.7"
     }
   ]
 }

package/lib/packlets/file-tree/directoryItem.d.ts

@@ -1,10 +1,10 @@
 import { Result } from '@fgv/ts-utils';
-import { FileTreeItem, IFileTreeAccessors, IFileTreeDirectoryItem, IFileTreeFileItem } from './fileTreeAccessors';
+import { FileTreeItem, IDeleteChildOptions, IFileTreeAccessors, IMutableFileTreeDirectoryItem, IMutableFileTreeFileItem } from './fileTreeAccessors';
 /**
  * Class representing a directory in a file tree.
  * @public
  */
-export declare class DirectoryItem<TCT extends string = string> implements IFileTreeDirectoryItem<TCT> {
+export declare class DirectoryItem<TCT extends string = string> implements IMutableFileTreeDirectoryItem<TCT> {
     /**
      * {@inheritDoc FileTree.IFileTreeDirectoryItem."type"}
      */
@@ -44,12 +44,27 @@ export declare class DirectoryItem<TCT extends string = string> implements IFile
      */
     getChildren(): Result<ReadonlyArray<FileTreeItem<TCT>>>;
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildFile}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildFile}
      */
-    createChildFile(name: string, contents: string): Result<IFileTreeFileItem<TCT>>;
+    createChildFile(name: string, contents: string): Result<IMutableFileTreeFileItem<TCT>>;
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildDirectory}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildDirectory}
      */
-    createChildDirectory(name: string): Result<IFileTreeDirectoryItem<TCT>>;
+    createChildDirectory(name: string): Result<IMutableFileTreeDirectoryItem<TCT>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.deleteChild}
+     */
+    deleteChild(name: string, options?: IDeleteChildOptions): Result<boolean>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.delete}
+     */
+    delete(): Result<boolean>;
+    /**
+     * Recursively deletes all children of a directory and then the directory itself.
+     * @param dirPath - The absolute path of the directory to delete.
+     * @returns `Success` with `true` if the directory was deleted, or `Failure` with an error message.
+     * @internal
+     */
+    private _deleteRecursive;
 }
 //# sourceMappingURL=directoryItem.d.ts.map

package/lib/packlets/file-tree/directoryItem.js

@@ -68,34 +68,98 @@ class DirectoryItem {
         return this._hal.getChildren(this.absolutePath);
     }
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildFile}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildFile}
      */
     createChildFile(name, contents) {
-        if (!(0, fileTreeAccessors_1.isMutableAccessors)(this._hal)) {
+        const hal = this._hal;
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
             return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
         }
-        const filePath = this._hal.joinPaths(this.absolutePath, name);
-        return this._hal.saveFileContents(filePath, contents).onSuccess(() => this._hal.getItem(filePath).onSuccess((item) => {
+        const filePath = hal.joinPaths(this.absolutePath, name);
+        return hal.saveFileContents(filePath, contents).onSuccess(() => hal.getItem(filePath).onSuccess((item) => {
             /* c8 ignore next 3 - defensive: verifies accessor returned correct item type after save */
-            if (item.type !== 'file') {
-                return (0, ts_utils_1.fail)(`${filePath}: expected file but got ${item.type}`);
+            if (!(0, fileTreeAccessors_1.isMutableFileItem)(item)) {
+                return (0, ts_utils_1.fail)(`${filePath}: expected mutable file but got ${item.type}`);
             }
             return (0, ts_utils_1.succeed)(item);
         }));
     }
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildDirectory}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildDirectory}
      */
     createChildDirectory(name) {
-        if (!(0, fileTreeAccessors_1.isMutableAccessors)(this._hal)) {
+        const hal = this._hal;
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
             return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
         }
-        /* c8 ignore next 3 - defensive: createDirectory should always exist if isMutableAccessors is true */
-        if (this._hal.createDirectory === undefined) {
-            return (0, ts_utils_1.fail)(`${this.absolutePath}: directory creation not supported`);
+        const dirPath = hal.joinPaths(this.absolutePath, name);
+        return hal.createDirectory(dirPath).onSuccess(() => DirectoryItem.create(dirPath, hal));
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.deleteChild}
+     */
+    deleteChild(name, options) {
+        const hal = this._hal;
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
+        }
+        const childPath = hal.joinPaths(this.absolutePath, name);
+        return hal.getItem(childPath).onSuccess((item) => {
+            if (item.type === 'file') {
+                return hal.deleteFile(childPath);
+            }
+            // Directory child
+            if (options === null || options === void 0 ? void 0 : options.recursive) {
+                return this._deleteRecursive(childPath);
+            }
+            return hal.deleteDirectory(childPath);
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.delete}
+     */
+    delete() {
+        const hal = this._hal;
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
+        }
+        return hal.deleteDirectory(this.absolutePath);
+    }
+    /**
+     * Recursively deletes all children of a directory and then the directory itself.
+     * @param dirPath - The absolute path of the directory to delete.
+     * @returns `Success` with `true` if the directory was deleted, or `Failure` with an error message.
+     * @internal
+     */
+    _deleteRecursive(dirPath) {
+        const hal = this._hal;
+        /* c8 ignore next 3 - defensive: caller already verified mutable */
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            return (0, ts_utils_1.fail)(`${dirPath}: mutation not supported`);
         }
-        const dirPath = this._hal.joinPaths(this.absolutePath, name);
-        return this._hal.createDirectory(dirPath).onSuccess(() => DirectoryItem.create(dirPath, this._hal));
+        return hal.getChildren(dirPath).onSuccess((children) => {
+            for (const child of children) {
+                if (child.type === 'file') {
+                    const result = hal.deleteFile(child.absolutePath);
+                    /* c8 ignore next 3 - defensive: error propagation during recursive delete */
+                    if (result.isFailure()) {
+                        return result;
+                    }
+                }
+                else {
+                    const result = this._deleteRecursive(child.absolutePath);
+                    /* c8 ignore next 3 - defensive: error propagation during recursive delete */
+                    if (result.isFailure()) {
+                        return result;
+                    }
+                }
+            }
+            return hal.deleteDirectory(dirPath);
+        });
     }
 }
 exports.DirectoryItem = DirectoryItem;

package/lib/packlets/file-tree/fileItem.d.ts

@@ -1,12 +1,12 @@
 import { DetailedResult, Result } from '@fgv/ts-utils';
 import { Converter, Validator } from '@fgv/ts-utils';
 import { JsonValue } from '../json';
-import { IFileTreeAccessors, IFileTreeFileItem, SaveDetail } from './fileTreeAccessors';
+import { IFileTreeAccessors, IMutableFileTreeFileItem, SaveDetail } from './fileTreeAccessors';
 /**
  * Class representing a file in a file tree.
  * @public
  */
-export declare class FileItem<TCT extends string = string> implements IFileTreeFileItem<TCT> {
+export declare class FileItem<TCT extends string = string> implements IMutableFileTreeFileItem<TCT> {
     /**
      * {@inheritDoc FileTree.IFileTreeFileItem."type"}
      */
@@ -86,6 +86,10 @@ export declare class FileItem<TCT extends string = string> implements IFileTreeF
      * {@inheritDoc FileTree.IFileTreeFileItem.setRawContents}
      */
     setRawContents(contents: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.delete}
+     */
+    delete(): Result<boolean>;
     /**
      * Default function to infer the content type of a file.
      * @param filePath - The path of the file.

package/lib/packlets/file-tree/fileItem.js

@@ -129,6 +129,16 @@ class FileItem {
         /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
         return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
     }
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.delete}
+     */
+    delete() {
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(this._hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
+        }
+        return this._hal.deleteFile(this.absolutePath);
+    }
     /**
      * Default function to infer the content type of a file.
      * @param filePath - The path of the file.