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

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

@@ -1,6 +1,42 @@
-import { Result } from '@fgv/ts-utils';
+import { DetailedResult, Result } from '@fgv/ts-utils';
 import { Converter, Validator } from '@fgv/ts-utils';
 import { JsonValue } from '../json';
+/**
+ * Indicates the persistence capability of a save operation.
+ * - `persistent`: Changes are saved to durable storage (e.g., file system).
+ * - `transient`: Changes are saved in memory only and will be lost on reload.
+ * @public
+ */
+export type SaveCapability = 'persistent' | 'transient';
+/**
+ * Indicates the reason a save operation cannot be performed.
+ * - `not-supported`: The accessors do not support mutation.
+ * - `read-only`: The file or file system is read-only.
+ * - `not-mutable`: Mutability is disabled in configuration.
+ * - `path-excluded`: The path is excluded by the mutability filter.
+ * - `permission-denied`: Insufficient permissions to write.
+ * @public
+ */
+export type SaveFailureReason = 'not-supported' | 'read-only' | 'not-mutable' | 'path-excluded' | 'permission-denied';
+/**
+ * Detail type for getIsMutable results.
+ * @public
+ */
+export type SaveDetail = SaveCapability | SaveFailureReason;
+/**
+ * Filter specification for controlling which paths are mutable.
+ * @public
+ */
+export interface IFilterSpec {
+    /**
+     * Paths or patterns to include. If specified, only matching paths are mutable.
+     */
+    include?: (string | RegExp)[];
+    /**
+     * Paths or patterns to exclude. Matching paths are not mutable.
+     */
+    exclude?: (string | RegExp)[];
+}
 /**
  * Type of item in a file tree.
  * @public
@@ -18,6 +54,13 @@ export type ContentTypeFactory<TCT extends string = string> = (filePath: string,
 export interface IFileTreeInitParams<TCT extends string = string> {
     prefix?: string;
     inferContentType?: ContentTypeFactory<TCT>;
+    /**
+     * Controls mutability of the file tree.
+     * - `undefined` or `false`: No files are mutable.
+     * - `true`: All files are mutable.
+     * - `IFilterSpec`: Only files matching the filter are mutable.
+     */
+    mutable?: boolean | IFilterSpec;
 }
 /**
  * Interface for a file in a file tree.
@@ -68,6 +111,27 @@ export 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>;
 }
 /**
  * Interface for a directory in a file tree.
@@ -92,6 +156,21 @@ export 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>>;
 }
 /**
  * Type for an item in a file tree.
@@ -155,4 +234,65 @@ export interface IFileTreeAccessors<TCT extends string = string> {
      */
     getChildren(path: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
 }
+/**
+ * Extended accessors interface that supports mutation operations.
+ * @public
+ */
+export interface IMutableFileTreeAccessors<TCT extends string = string> extends IFileTreeAccessors<TCT> {
+    /**
+     * Checks if a file at the given path can be saved.
+     * @param path - The path to check.
+     * @returns `DetailedSuccess` with {@link FileTree.SaveCapability} if the file can be saved,
+     * or `DetailedFailure` with {@link FileTree.SaveFailureReason} if it cannot.
+     */
+    fileIsMutable(path: string): DetailedResult<boolean, SaveDetail>;
+    /**
+     * Saves the contents to a file at the given path.
+     * @param path - The path of the file to save.
+     * @param contents - The string contents to save.
+     * @returns `Success` if the file was saved, or `Failure` with an error message.
+     */
+    saveFileContents(path: string, contents: string): Result<string>;
+    /**
+     * 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>;
+}
+/**
+ * Extended accessors interface that supports persistence operations.
+ * @public
+ */
+export interface IPersistentFileTreeAccessors<TCT extends string = string> extends IMutableFileTreeAccessors<TCT> {
+    /**
+     * Synchronize all dirty files to persistent storage.
+     * @returns Promise resolving to success or failure
+     */
+    syncToDisk(): Promise<Result<void>>;
+    /**
+     * Check if there are unsaved changes.
+     * @returns True if there are dirty files
+     */
+    isDirty(): boolean;
+    /**
+     * Get paths of all files with unsaved changes.
+     * @returns Array of dirty file paths
+     */
+    getDirtyPaths(): string[];
+}
+/**
+ * Type guard to check if accessors support mutation.
+ * @param accessors - The accessors to check.
+ * @returns `true` if the accessors implement {@link FileTree.IMutableFileTreeAccessors}.
+ * @public
+ */
+export declare function isMutableAccessors<TCT extends string = string>(accessors: IFileTreeAccessors<TCT>): accessors is IMutableFileTreeAccessors<TCT>;
+/**
+ * Type guard to check if accessors support persistence.
+ * @param accessors - The accessors to check.
+ * @returns `true` if the accessors implement {@link FileTree.IPersistentFileTreeAccessors}.
+ * @public
+ */
+export declare function isPersistentAccessors<TCT extends string = string>(accessors: IFileTreeAccessors<TCT>): accessors is IPersistentFileTreeAccessors<TCT>;
 //# sourceMappingURL=fileTreeAccessors.d.ts.map

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

@@ -21,4 +21,30 @@
  * SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMutableAccessors = isMutableAccessors;
+exports.isPersistentAccessors = isPersistentAccessors;
+/**
+ * Type guard to check if accessors support mutation.
+ * @param accessors - The accessors to check.
+ * @returns `true` if the accessors implement {@link FileTree.IMutableFileTreeAccessors}.
+ * @public
+ */
+function isMutableAccessors(accessors) {
+    const mutable = accessors;
+    return typeof mutable.fileIsMutable === 'function' && typeof mutable.saveFileContents === 'function';
+}
+/**
+ * Type guard to check if accessors support persistence.
+ * @param accessors - The accessors to check.
+ * @returns `true` if the accessors implement {@link FileTree.IPersistentFileTreeAccessors}.
+ * @public
+ */
+function isPersistentAccessors(accessors) {
+    const persistent = accessors;
+    /* c8 ignore next 6 - no current accessor implements IPersistentFileTreeAccessors */
+    return (isMutableAccessors(accessors) &&
+        typeof persistent.syncToDisk === 'function' &&
+        typeof persistent.isDirty === 'function' &&
+        typeof persistent.getDirtyPaths === 'function');
+}
 //# sourceMappingURL=fileTreeAccessors.js.map

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

@@ -0,0 +1,10 @@
+import { IFilterSpec } from './fileTreeAccessors';
+/**
+ * Checks if a path is allowed by a mutability configuration.
+ * @param path - The path to check.
+ * @param mutable - The mutability configuration.
+ * @returns `true` if the path is mutable according to the configuration.
+ * @public
+ */
+export declare function isPathMutable(path: string, mutable: boolean | IFilterSpec | undefined): boolean;
+//# sourceMappingURL=filterSpec.d.ts.map

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

@@ -0,0 +1,77 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathMutable = isPathMutable;
+/**
+ * Checks if a path matches a single pattern (string or RegExp).
+ * @param path - The path to check.
+ * @param pattern - The pattern to match against.
+ * @returns `true` if the path matches the pattern.
+ * @internal
+ */
+function matchesPattern(path, pattern) {
+    if (typeof pattern === 'string') {
+        return path === pattern || path.startsWith(pattern + '/') || path.includes(pattern);
+    }
+    return pattern.test(path);
+}
+/**
+ * Checks if a path matches any pattern in an array.
+ * @param path - The path to check.
+ * @param patterns - The patterns to match against.
+ * @returns `true` if the path matches any pattern.
+ * @internal
+ */
+function matchesAny(path, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    return patterns.some((pattern) => matchesPattern(path, pattern));
+}
+/**
+ * Checks if a path is allowed by a mutability configuration.
+ * @param path - The path to check.
+ * @param mutable - The mutability configuration.
+ * @returns `true` if the path is mutable according to the configuration.
+ * @public
+ */
+function isPathMutable(path, mutable) {
+    if (mutable === undefined || mutable === false) {
+        return false;
+    }
+    if (mutable === true) {
+        return true;
+    }
+    const { include, exclude } = mutable;
+    // If exclude patterns are specified and path matches, it's not mutable
+    if (matchesAny(path, exclude)) {
+        return false;
+    }
+    // If include patterns are specified, path must match at least one
+    if (include && include.length > 0) {
+        return matchesAny(path, include);
+    }
+    // No include patterns means all paths (not excluded) are mutable
+    return true;
+}
+//# sourceMappingURL=filterSpec.js.map

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

@@ -1,11 +1,11 @@
-import { FileTreeItem, IFileTreeAccessors, IFileTreeInitParams } from './fileTreeAccessors';
-import { Result } from '@fgv/ts-utils';
+import { FileTreeItem, IFileTreeInitParams, IMutableFileTreeAccessors, SaveDetail } from './fileTreeAccessors';
+import { DetailedResult, Result } from '@fgv/ts-utils';
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses the
- * file system to access files and directories.
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses the
+ * file system to access and modify files and directories.
  * @public
  */
-export declare class FsFileTreeAccessors<TCT extends string = string> implements IFileTreeAccessors<TCT> {
+export declare class FsFileTreeAccessors<TCT extends string = string> implements IMutableFileTreeAccessors<TCT> {
     /**
      * Optional path prefix to prepend to all paths.
      */
@@ -15,6 +15,10 @@ export declare class FsFileTreeAccessors<TCT extends string = string> implements
      * @public
      */
     protected readonly _inferContentType: (filePath: string) => Result<TCT | undefined>;
+    /**
+     * The mutability configuration.
+     */
+    private readonly _mutable;
     /**
      * Construct a new instance of the {@link FileTree.FsFileTreeAccessors | FsFileTreeAccessors} class.
      * @param params - Optional {@link FileTree.IFileTreeInitParams | initialization parameters}.
@@ -22,36 +26,48 @@ export declare class FsFileTreeAccessors<TCT extends string = string> implements
      */
     constructor(params?: IFileTreeInitParams<TCT>);
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths: string[]): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(itemPath: string): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(itemPath: string, suffix?: string): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths: string[]): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath: string): Result<FileTreeItem<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(filePath: string): Result<string>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(filePath: string, provided?: string): Result<TCT | undefined>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(dirPath: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path: string): DetailedResult<boolean, SaveDetail>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path: string, contents: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath: string): Result<string>;
 }
 //# sourceMappingURL=fsTree.d.ts.map

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

@@ -30,9 +30,10 @@ const fs_1 = __importDefault(require("fs"));
 const ts_utils_1 = require("@fgv/ts-utils");
 const directoryItem_1 = require("./directoryItem");
 const fileItem_1 = require("./fileItem");
+const filterSpec_1 = require("./filterSpec");
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses the
- * file system to access files and directories.
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses the
+ * file system to access and modify files and directories.
  * @public
  */
 class FsFileTreeAccessors {
@@ -42,12 +43,14 @@ class FsFileTreeAccessors {
      * @public
      */
     constructor(params) {
-        var _a;
+        var _a, _b;
         this.prefix = params === null || params === void 0 ? void 0 : params.prefix;
         this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : fileItem_1.FileItem.defaultInferContentType;
+        /* c8 ignore next 1 - defensive default when params is undefined */
+        this._mutable = (_b = params === null || params === void 0 ? void 0 : params.mutable) !== null && _b !== void 0 ? _b : false;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths) {
         if (this.prefix && !path_1.default.isAbsolute(paths[0])) {
@@ -56,25 +59,25 @@ class FsFileTreeAccessors {
         return path_1.default.resolve(...paths);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(itemPath) {
         return path_1.default.extname(itemPath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(itemPath, suffix) {
         return path_1.default.basename(itemPath, suffix);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths) {
         return path_1.default.join(...paths);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath) {
         return (0, ts_utils_1.captureResult)(() => {
@@ -90,13 +93,13 @@ class FsFileTreeAccessors {
         });
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(filePath) {
         return (0, ts_utils_1.captureResult)(() => fs_1.default.readFileSync(this.resolveAbsolutePath(filePath), 'utf8'));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(filePath, provided) {
         if (provided !== undefined) {
@@ -106,7 +109,7 @@ class FsFileTreeAccessors {
         return this._inferContentType(filePath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(dirPath) {
         return (0, ts_utils_1.captureResult)(() => {
@@ -124,6 +127,64 @@ class FsFileTreeAccessors {
             return children;
         });
     }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: mutability is disabled`, 'not-mutable');
+        }
+        // Check if path is excluded by filter
+        if (!(0, filterSpec_1.isPathMutable)(absolutePath, this._mutable)) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: path is excluded by filter`, 'path-excluded');
+        }
+        // Check file system permissions
+        try {
+            // Check if file exists
+            if (fs_1.default.existsSync(absolutePath)) {
+                fs_1.default.accessSync(absolutePath, fs_1.default.constants.W_OK);
+            }
+            else {
+                // Check if parent directory is writable
+                const parentDir = absolutePath.substring(0, absolutePath.lastIndexOf('/'));
+                if (parentDir && fs_1.default.existsSync(parentDir)) {
+                    fs_1.default.accessSync(parentDir, fs_1.default.constants.W_OK);
+                }
+            }
+            return (0, ts_utils_1.succeedWithDetail)(true, 'persistent');
+        }
+        catch (_a) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: permission denied`, 'permission-denied');
+        }
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path, contents) {
+        return this.fileIsMutable(path).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(path);
+            return (0, ts_utils_1.captureResult)(() => {
+                fs_1.default.writeFileSync(absolutePath, contents, 'utf8');
+                return contents;
+            });
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath) {
+        const absolutePath = this.resolveAbsolutePath(dirPath);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: mutability is disabled`);
+        }
+        return (0, ts_utils_1.captureResult)(() => {
+            fs_1.default.mkdirSync(absolutePath, { recursive: true });
+            return absolutePath;
+        });
+    }
 }
 exports.FsFileTreeAccessors = FsFileTreeAccessors;
 //# sourceMappingURL=fsTree.js.map

package/lib/packlets/file-tree/in-memory/inMemoryTree.d.ts

@@ -1,5 +1,5 @@
-import { Result } from '@fgv/ts-utils';
-import { FileTreeItem, IFileTreeAccessors, IFileTreeInitParams } from '../fileTreeAccessors';
+import { DetailedResult, Result } from '@fgv/ts-utils';
+import { FileTreeItem, IFileTreeInitParams, IMutableFileTreeAccessors, SaveDetail } from '../fileTreeAccessors';
 /**
  * Represents a single file in an in-memory {@link FileTree | file tree}.
  * @public
@@ -19,13 +19,16 @@ export interface IInMemoryFile<TCT extends string = string> {
     readonly contentType?: TCT;
 }
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses an in-memory
- * tree to access files and directories.
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses an in-memory
+ * tree to access and modify files and directories.
  * @public
  */
-export declare class InMemoryTreeAccessors<TCT extends string = string> implements IFileTreeAccessors<TCT> {
+export declare class InMemoryTreeAccessors<TCT extends string = string> implements IMutableFileTreeAccessors<TCT> {
     private readonly _tree;
     private readonly _inferContentType;
+    private readonly _mutable;
+    private readonly _mutableByPath;
+    private readonly _mutableRoot;
     /**
      * Protected constructor for derived classes.
      * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
@@ -48,36 +51,49 @@ export declare class InMemoryTreeAccessors<TCT extends string = string> implemen
      */
     static create<TCT extends string = string>(files: IInMemoryFile<TCT>[], params?: IFileTreeInitParams<TCT>): Result<InMemoryTreeAccessors<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths: string[]): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(path: string): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(path: string, suffix?: string): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths: string[]): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath: string): Result<FileTreeItem<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(path: string): Result<string>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(path: string, provided?: string): Result<TCT | undefined>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(path: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+    private _addMutableFile;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path: string): DetailedResult<boolean, SaveDetail>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path: string, contents: string): Result<string>;
 }
 //# sourceMappingURL=inMemoryTree.d.ts.map