@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/vault-delete.d.mts

@@ -0,0 +1,82 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides deletion utilities that require metadata cache access.
+ */
+import type { App, TAbstractFile, TFile } from 'obsidian';
+import type { PluginNoticeComponent } from './components/plugin-notice-component.mjs';
+import type { PathOrAbstractFile } from './file-system.mjs';
+/**
+ * The result of {@link deleteIfNotUsed}.
+ */
+export declare enum DeleteIfNotUsedResult {
+    /**
+     * The file/folder was deleted.
+     */
+    Deleted = "deleted",
+    /**
+     * The file/folder was not deleted.
+     */
+    NotDeleted = "not-deleted",
+    /**
+     * The file was still used, and {@link DeleteIfNotUsedParams.rescueStillUsedFile} moved it out of the way
+     * instead of it being deleted or left where it was.
+     */
+    Rescued = "rescued"
+}
+/**
+ * Parameters passed to {@link DeleteIfNotUsedParams.rescueStillUsedFile}.
+ */
+export interface RescueStillUsedFileParams {
+    /**
+     * The file that is about to be kept because other notes still reference it.
+     */
+    readonly file: TFile;
+    /**
+     * The paths of the notes that still reference the file once everything being deleted alongside it is
+     * gone. Never empty.
+     */
+    readonly survivingNotePaths: readonly string[];
+}
+interface DeleteIfNotUsedParams {
+    readonly app: App;
+    readonly deleteAbstractFile?: (file: TAbstractFile) => Promise<void>;
+    readonly deletedNotePath?: string;
+    readonly deletedNotePaths?: readonly string[];
+    readonly pathOrFile: PathOrAbstractFile;
+    readonly pluginNoticeComponent?: PluginNoticeComponent;
+    readonly rescueStillUsedFile?: (params: RescueStillUsedFileParams) => Promise<boolean>;
+    readonly shouldDeleteEmptyFolders?: boolean;
+    readonly shouldProtectIfStillUsed?: (file: TFile) => boolean;
+}
+/**
+ * Deletes an abstract file safely from the vault, but only if it is not referenced by other notes.
+ *
+ * Backlinks originating from {@link DeleteIfNotUsedParams.deletedNotePath} and
+ * {@link DeleteIfNotUsedParams.deletedNotePaths} are discounted before deciding whether a file is still
+ * used — a note that is itself going away cannot keep an attachment alive. Deleting a single note needs
+ * only the former; deleting a folder needs the latter, because every note inside it disappears at once.
+ *
+ * {@link DeleteIfNotUsedParams.shouldProtectIfStillUsed} narrows which files that protection covers; a file
+ * it rejects is deleted no matter how many notes link to it. Deleting a whole folder of notes uses this to
+ * exempt the notes themselves — leaving a dangling link behind is what Obsidian normally does, so keeping
+ * every linked-to note would make folder deletion impossible. By default every still-used file is kept.
+ *
+ * A kept file is stranded: it survives in a folder whose owning note is gone, while the note still
+ * referencing it lives elsewhere. {@link DeleteIfNotUsedParams.rescueStillUsedFile} is the seam that lets
+ * the caller relocate it instead, since where it belongs is the caller's attachment-path policy, not this
+ * function's. Without that callback the file is simply kept, exactly as before.
+ *
+ * The actual removal goes through {@link DeleteIfNotUsedParams.deleteAbstractFile} when supplied,
+ * otherwise through {@link trashSafe}. A caller that intercepted a specific deletion primitive passes its
+ * unpatched original here, so the user's chosen semantics (permanent delete vs trash) survive the detour.
+ *
+ * @param params - The parameters for the function.
+ * @returns A {@link Promise} that resolves to {@link DeleteIfNotUsedResult.Deleted} if the abstract file
+ * was deleted, {@link DeleteIfNotUsedResult.Rescued} if it was moved away by
+ * {@link DeleteIfNotUsedParams.rescueStillUsedFile}, or {@link DeleteIfNotUsedResult.NotDeleted} if it was
+ * kept where it was.
+ */
+export declare function deleteIfNotUsed(params: DeleteIfNotUsedParams): Promise<DeleteIfNotUsedResult>;
+export {};

package/dist/lib/esm/vault-delete.mjs

@@ -0,0 +1,132 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { printError } from "@mnaoumov/typescript-lib/error";
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  getAbstractFileOrNull,
+  isFile,
+  isFolder
+} from "./file-system.mjs";
+import { t } from "./i18n/i18n.mjs";
+import { getBacklinksForFileSafe } from "./metadata-cache.mjs";
+import {
+  isEmptyFolder,
+  listSafe,
+  trashSafe
+} from "./vault.mjs";
+var DeleteIfNotUsedResult = /* @__PURE__ */ ((DeleteIfNotUsedResult2) => {
+  DeleteIfNotUsedResult2["Deleted"] = "deleted";
+  DeleteIfNotUsedResult2["NotDeleted"] = "not-deleted";
+  DeleteIfNotUsedResult2["Rescued"] = "rescued";
+  return DeleteIfNotUsedResult2;
+})(DeleteIfNotUsedResult || {});
+async function deleteIfNotUsed(params) {
+  const file = getAbstractFileOrNull({ app: params.app, pathOrFile: params.pathOrFile });
+  if (!file) {
+    return "not-deleted" /* NotDeleted */;
+  }
+  let canDelete = isFile(file) || (params.shouldDeleteEmptyFolders ?? true);
+  if (isFile(file)) {
+    const survivingNotePaths = await getSurvivingNotePaths(params, file);
+    if (survivingNotePaths.length > 0) {
+      if (await params.rescueStillUsedFile?.({ file, survivingNotePaths })) {
+        return "rescued" /* Rescued */;
+      }
+      params.pluginNoticeComponent?.showNotice(t(($) => $.obsidianDevUtils.notices.attachmentIsStillUsed, { attachmentPath: file.path }));
+      canDelete = false;
+    }
+  } else if (isFolder(file)) {
+    const listedFiles = await listSafe(params.app, file);
+    for (const child of [...listedFiles.files, ...listedFiles.folders]) {
+      const isChildGone = isGoneFromParent(
+        await deleteIfNotUsed(normalizeOptionalProperties({
+          app: params.app,
+          deleteAbstractFile: params.deleteAbstractFile,
+          deletedNotePath: params.deletedNotePath,
+          deletedNotePaths: params.deletedNotePaths,
+          pathOrFile: child,
+          pluginNoticeComponent: params.pluginNoticeComponent,
+          rescueStillUsedFile: params.rescueStillUsedFile,
+          shouldDeleteEmptyFolders: params.shouldDeleteEmptyFolders,
+          shouldProtectIfStillUsed: params.shouldProtectIfStillUsed
+        }))
+      );
+      canDelete &&= isChildGone;
+    }
+    canDelete &&= await isEmptyFolder(params.app, file);
+  }
+  if (canDelete) {
+    try {
+      if (params.deleteAbstractFile) {
+        await params.deleteAbstractFile(file);
+      } else {
+        await trashSafe(params.app, file);
+      }
+    } catch (error) {
+      printError(new Error(`Failed to delete ${file.path}`, { cause: error }));
+      canDelete = false;
+    }
+  }
+  return canDelete ? "deleted" /* Deleted */ : "not-deleted" /* NotDeleted */;
+}
+async function getSurvivingNotePaths(params, file) {
+  if (!(params.shouldProtectIfStillUsed?.(file) ?? true)) {
+    return [];
+  }
+  const backlinks = await getBacklinksForFileSafe({ app: params.app, pathOrFile: file });
+  const deletedNotePaths = new Set(params.deletedNotePaths);
+  if (params.deletedNotePath) {
+    deletedNotePaths.add(params.deletedNotePath);
+  }
+  for (const deletedNotePath of deletedNotePaths) {
+    backlinks.clear(deletedNotePath);
+  }
+  return backlinks.keys();
+}
+function isGoneFromParent(result) {
+  return result === "deleted" /* Deleted */ || result === "rescued" /* Rescued */;
+}
+export {
+  DeleteIfNotUsedResult,
+  deleteIfNotUsed
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/vault-delete.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides deletion utilities that require metadata cache access.\n */\n\nimport type {\n  App,\n  TAbstractFile,\n  TFile\n} from 'obsidian';\n\nimport { printError } from '@mnaoumov/typescript-lib/error';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport {\n  getAbstractFileOrNull,\n  isFile,\n  isFolder\n} from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\nimport { getBacklinksForFileSafe } from './metadata-cache.ts';\nimport {\n  isEmptyFolder,\n  listSafe,\n  trashSafe\n} from './vault.ts';\n\n/**\n * The result of {@link deleteIfNotUsed}.\n */\nexport enum DeleteIfNotUsedResult {\n  /**\n   * The file/folder was deleted.\n   */\n  Deleted = 'deleted',\n\n  /**\n   * The file/folder was not deleted.\n   */\n  NotDeleted = 'not-deleted',\n\n  /**\n   * The file was still used, and {@link DeleteIfNotUsedParams.rescueStillUsedFile} moved it out of the way\n   * instead of it being deleted or left where it was.\n   */\n  Rescued = 'rescued'\n}\n\n/**\n * Parameters passed to {@link DeleteIfNotUsedParams.rescueStillUsedFile}.\n */\nexport interface RescueStillUsedFileParams {\n  /**\n   * The file that is about to be kept because other notes still reference it.\n   */\n  readonly file: TFile;\n\n  /**\n   * The paths of the notes that still reference the file once everything being deleted alongside it is\n   * gone. Never empty.\n   */\n  readonly survivingNotePaths: readonly string[];\n}\n\ninterface DeleteIfNotUsedParams {\n  readonly app: App;\n  readonly deleteAbstractFile?: (file: TAbstractFile) => Promise<void>;\n  readonly deletedNotePath?: string;\n  readonly deletedNotePaths?: readonly string[];\n  readonly pathOrFile: PathOrAbstractFile;\n  readonly pluginNoticeComponent?: PluginNoticeComponent;\n  readonly rescueStillUsedFile?: (params: RescueStillUsedFileParams) => Promise<boolean>;\n  readonly shouldDeleteEmptyFolders?: boolean;\n  readonly shouldProtectIfStillUsed?: (file: TFile) => boolean;\n}\n\n/**\n * Deletes an abstract file safely from the vault, but only if it is not referenced by other notes.\n *\n * Backlinks originating from {@link DeleteIfNotUsedParams.deletedNotePath} and\n * {@link DeleteIfNotUsedParams.deletedNotePaths} are discounted before deciding whether a file is still\n * used \u2014 a note that is itself going away cannot keep an attachment alive. Deleting a single note needs\n * only the former; deleting a folder needs the latter, because every note inside it disappears at once.\n *\n * {@link DeleteIfNotUsedParams.shouldProtectIfStillUsed} narrows which files that protection covers; a file\n * it rejects is deleted no matter how many notes link to it. Deleting a whole folder of notes uses this to\n * exempt the notes themselves \u2014 leaving a dangling link behind is what Obsidian normally does, so keeping\n * every linked-to note would make folder deletion impossible. By default every still-used file is kept.\n *\n * A kept file is stranded: it survives in a folder whose owning note is gone, while the note still\n * referencing it lives elsewhere. {@link DeleteIfNotUsedParams.rescueStillUsedFile} is the seam that lets\n * the caller relocate it instead, since where it belongs is the caller's attachment-path policy, not this\n * function's. Without that callback the file is simply kept, exactly as before.\n *\n * The actual removal goes through {@link DeleteIfNotUsedParams.deleteAbstractFile} when supplied,\n * otherwise through {@link trashSafe}. A caller that intercepted a specific deletion primitive passes its\n * unpatched original here, so the user's chosen semantics (permanent delete vs trash) survive the detour.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves to {@link DeleteIfNotUsedResult.Deleted} if the abstract file\n * was deleted, {@link DeleteIfNotUsedResult.Rescued} if it was moved away by\n * {@link DeleteIfNotUsedParams.rescueStillUsedFile}, or {@link DeleteIfNotUsedResult.NotDeleted} if it was\n * kept where it was.\n */\nexport async function deleteIfNotUsed(params: DeleteIfNotUsedParams): Promise<DeleteIfNotUsedResult> {\n  const file = getAbstractFileOrNull({ app: params.app, pathOrFile: params.pathOrFile });\n\n  if (!file) {\n    return DeleteIfNotUsedResult.NotDeleted;\n  }\n\n  let canDelete = isFile(file) || (params.shouldDeleteEmptyFolders ?? true);\n\n  /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; the false branch of isFile leads to isFolder. */\n  if (isFile(file)) {\n    /* v8 ignore stop */\n    const survivingNotePaths = await getSurvivingNotePaths(params, file);\n    if (survivingNotePaths.length > 0) {\n      if (await params.rescueStillUsedFile?.({ file, survivingNotePaths })) {\n        return DeleteIfNotUsedResult.Rescued;\n      }\n\n      params.pluginNoticeComponent?.showNotice(t(($) => $.obsidianDevUtils.notices.attachmentIsStillUsed, { attachmentPath: file.path }));\n      canDelete = false;\n    }\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n  } else if (isFolder(file)) {\n    /* v8 ignore stop */\n    const listedFiles = await listSafe(params.app, file);\n    for (const child of [...listedFiles.files, ...listedFiles.folders]) {\n      // Every child is visited even once the folder itself is known to stay: `canDelete &&= await \u2026` would skip the call.\n      const isChildGone = isGoneFromParent(\n        await deleteIfNotUsed(normalizeOptionalProperties<DeleteIfNotUsedParams>({\n          app: params.app,\n          deleteAbstractFile: params.deleteAbstractFile,\n          deletedNotePath: params.deletedNotePath,\n          deletedNotePaths: params.deletedNotePaths,\n          pathOrFile: child,\n          pluginNoticeComponent: params.pluginNoticeComponent,\n          rescueStillUsedFile: params.rescueStillUsedFile,\n          shouldDeleteEmptyFolders: params.shouldDeleteEmptyFolders,\n          shouldProtectIfStillUsed: params.shouldProtectIfStillUsed\n        }))\n      );\n      canDelete &&= isChildGone;\n    }\n\n    canDelete &&= await isEmptyFolder(params.app, file);\n  }\n\n  if (canDelete) {\n    try {\n      if (params.deleteAbstractFile) {\n        await params.deleteAbstractFile(file);\n      } else {\n        await trashSafe(params.app, file);\n      }\n    } catch (error) {\n      printError(new Error(`Failed to delete ${file.path}`, { cause: error }));\n      canDelete = false;\n    }\n  }\n\n  return canDelete ? DeleteIfNotUsedResult.Deleted : DeleteIfNotUsedResult.NotDeleted;\n}\n\n/**\n * Lists the notes that would still reference a file once everything being deleted alongside it is gone.\n *\n * @param params - The parameters {@link deleteIfNotUsed} was called with.\n * @param file - The file whose remaining references are counted.\n * @returns A {@link Promise} that resolves to the paths of the notes that keep the file alive. Empty means\n * the file is free to go.\n */\nasync function getSurvivingNotePaths(params: DeleteIfNotUsedParams, file: TFile): Promise<readonly string[]> {\n  if (!(params.shouldProtectIfStillUsed?.(file) ?? true)) {\n    return [];\n  }\n\n  const backlinks = await getBacklinksForFileSafe({ app: params.app, pathOrFile: file });\n  const deletedNotePaths = new Set(params.deletedNotePaths);\n  if (params.deletedNotePath) {\n    deletedNotePaths.add(params.deletedNotePath);\n  }\n  for (const deletedNotePath of deletedNotePaths) {\n    backlinks.clear(deletedNotePath);\n  }\n\n  return backlinks.keys();\n}\n\n/**\n * Checks whether a child no longer sits in the folder being walked \u2014 deleted outright, or moved elsewhere\n * by a rescue. Either way the folder holding it can still be removed; only a child kept in place blocks it.\n *\n * @param result - The result of deleting the child.\n * @returns `true` when the child is gone from its parent folder.\n */\nfunction isGoneFromParent(result: DeleteIfNotUsedResult): boolean {\n  return result === DeleteIfNotUsedResult.Deleted || result === DeleteIfNotUsedResult.Rescued;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,kBAAkB;AAC3B,SAAS,mCAAmC;AAK5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS;AAClB,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKA,IAAK,wBAAL,kBAAKA,2BAAL;AAIL,EAAAA,uBAAA,aAAU;AAKV,EAAAA,uBAAA,gBAAa;AAMb,EAAAA,uBAAA,aAAU;AAfA,SAAAA;AAAA,GAAA;AA0EZ,eAAsB,gBAAgB,QAA+D;AACnG,QAAM,OAAO,sBAAsB,EAAE,KAAK,OAAO,KAAK,YAAY,OAAO,WAAW,CAAC;AAErF,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,MAAI,YAAY,OAAO,IAAI,MAAM,OAAO,4BAA4B;AAGpE,MAAI,OAAO,IAAI,GAAG;AAEhB,UAAM,qBAAqB,MAAM,sBAAsB,QAAQ,IAAI;AACnE,QAAI,mBAAmB,SAAS,GAAG;AACjC,UAAI,MAAM,OAAO,sBAAsB,EAAE,MAAM,mBAAmB,CAAC,GAAG;AACpE,eAAO;AAAA,MACT;AAEA,aAAO,uBAAuB,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,uBAAuB,EAAE,gBAAgB,KAAK,KAAK,CAAC,CAAC;AAClI,kBAAY;AAAA,IACd;AAAA,EAEF,WAAW,SAAS,IAAI,GAAG;AAEzB,UAAM,cAAc,MAAM,SAAS,OAAO,KAAK,IAAI;AACnD,eAAW,SAAS,CAAC,GAAG,YAAY,OAAO,GAAG,YAAY,OAAO,GAAG;AAElE,YAAM,cAAc;AAAA,QAClB,MAAM,gBAAgB,4BAAmD;AAAA,UACvE,KAAK,OAAO;AAAA,UACZ,oBAAoB,OAAO;AAAA,UAC3B,iBAAiB,OAAO;AAAA,UACxB,kBAAkB,OAAO;AAAA,UACzB,YAAY;AAAA,UACZ,uBAAuB,OAAO;AAAA,UAC9B,qBAAqB,OAAO;AAAA,UAC5B,0BAA0B,OAAO;AAAA,UACjC,0BAA0B,OAAO;AAAA,QACnC,CAAC,CAAC;AAAA,MACJ;AACA,oBAAc;AAAA,IAChB;AAEA,kBAAc,MAAM,cAAc,OAAO,KAAK,IAAI;AAAA,EACpD;AAEA,MAAI,WAAW;AACb,QAAI;AACF,UAAI,OAAO,oBAAoB;AAC7B,cAAM,OAAO,mBAAmB,IAAI;AAAA,MACtC,OAAO;AACL,cAAM,UAAU,OAAO,KAAK,IAAI;AAAA,MAClC;AAAA,IACF,SAAS,OAAO;AACd,iBAAW,IAAI,MAAM,oBAAoB,KAAK,IAAI,IAAI,EAAE,OAAO,MAAM,CAAC,CAAC;AACvE,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,SAAO,YAAY,0BAAgC;AACrD;AAUA,eAAe,sBAAsB,QAA+B,MAAyC;AAC3G,MAAI,EAAE,OAAO,2BAA2B,IAAI,KAAK,OAAO;AACtD,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,MAAM,wBAAwB,EAAE,KAAK,OAAO,KAAK,YAAY,KAAK,CAAC;AACrF,QAAM,mBAAmB,IAAI,IAAI,OAAO,gBAAgB;AACxD,MAAI,OAAO,iBAAiB;AAC1B,qBAAiB,IAAI,OAAO,eAAe;AAAA,EAC7C;AACA,aAAW,mBAAmB,kBAAkB;AAC9C,cAAU,MAAM,eAAe;AAAA,EACjC;AAEA,SAAO,UAAU,KAAK;AACxB;AASA,SAAS,iBAAiB,QAAwC;AAChE,SAAO,WAAW,2BAAiC,WAAW;AAChE;",
  "names": ["DeleteIfNotUsedResult"]
}


package/dist/lib/esm/vault-transaction.d.mts

@@ -0,0 +1,163 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * A reversible, transactional log of vault mutations. Each mutation records how to undo itself;
+ * {@link VaultTransaction.rollback} reverses the completed steps in reverse order and
+ * {@link VaultTransaction.commit} finalizes them. It is built on the `*Safe` vault wrappers so it
+ * inherits their case-insensitive / retry / missing-file handling.
+ *
+ * A deletion is performed as a **soft-delete**: the resource is moved aside into a dot-prefixed
+ * staging folder (a folder moves its whole subtree in a single rename, so subtree rollback is cheap
+ * and faithful). Because Obsidian's vault file-tree and file watcher ignore any `.`-prefixed path,
+ * staged resources are **untracked** — they do not churn the metadata cache, flash in the file
+ * explorer, or get propagated by sync while the transaction is in flight. The flip side is that
+ * `vault.*` methods cannot see the staging area, so ALL staging I/O goes through
+ * {@link App.vault.adapter} (`mkdir`/`rename`/`exists`/`trashSystem`/`rmdir`).
+ * {@link VaultTransaction.commit} then trashes the staged resources for real; {@link VaultTransaction.rollback}
+ * moves them back.
+ */
+import type { App, TFile } from 'obsidian';
+import type { PathOrAbstractFile } from './file-system.mjs';
+/**
+ * Parameters for the {@link VaultTransaction} constructor.
+ */
+export interface VaultTransactionConstructorParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * Opens an ambient mutation-bypass scope covering the paths this transaction touches, so the
+     * transaction's own writes pass a `shouldBlockMutations` lock that the owning operation holds. It is
+     * called once when the transaction is constructed, and the returned {@link Disposable} is disposed
+     * when the transaction settles (on `commit`, `rollback`, or `await using` disposal) — so the bypass
+     * stays active through rollback, including auto-rollback, which a caller managing the scope itself
+     * could easily get wrong. Typically
+     * `() => resourceLockComponent.bypassBlockedMutations(lockedPathsOrFiles)`. Omit it for the common
+     * standalone case where the transaction operates on unlocked paths.
+     *
+     * @returns A {@link Disposable} that ends the bypass scope.
+     */
+    readonly openMutationBypass?: () => Disposable;
+    /**
+     * The dot-prefixed folder that soft-deleted resources are moved into until the transaction is
+     * committed or rolled back. It must stay `.`-prefixed so Obsidian leaves the staged resources
+     * untracked.
+     *
+     * @default `'.obsidian-dev-utils-temp'`
+     */
+    readonly stagingFolderPath?: string;
+}
+/**
+ * A reversible log of vault mutations. Perform mutations through its methods, then call
+ * {@link VaultTransaction.commit} on success or {@link VaultTransaction.rollback} on failure. It is
+ * `await using`-friendly: if neither is called, disposal rolls back.
+ */
+export declare class VaultTransaction {
+    /**
+     * The Obsidian application instance the transaction mutates.
+     */
+    protected readonly app: App;
+    private hasStagingFolder;
+    private mutationBypass;
+    private readonly stagedTrashPaths;
+    private readonly stagingFolderPath;
+    private state;
+    private readonly undoSteps;
+    /**
+     * Creates a new vault transaction.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: VaultTransactionConstructorParams);
+    /**
+     * Commits the transaction: finalizes soft-deletes by trashing the staged resources for real and
+     * removes the staging folder. After this the transaction can no longer be mutated or rolled back.
+     *
+     * @returns A {@link Promise} that resolves when the commit completes.
+     */
+    commit(): Promise<void>;
+    /**
+     * Copies a file or folder, recording the removal of the copy as the inverse. A folder is copied with
+     * its whole subtree, so the single recorded removal undoes the whole tree. Unlike
+     * {@link VaultTransaction.create}, the content is copied byte for byte, so a binary resource
+     * round-trips faithfully.
+     *
+     * Parent folders that had to be created for the destination are NOT undone individually, matching
+     * {@link VaultTransaction.create} and {@link VaultTransaction.rename}.
+     *
+     * @param oldPathOrFile - The path, file or folder to copy.
+     * @param newPath - The desired new path (an available path is chosen if it is taken).
+     * @returns A {@link Promise} resolving to the actual path of the copy.
+     */
+    copy(oldPathOrFile: PathOrAbstractFile, newPath: string): Promise<string>;
+    /**
+     * Creates a file with the given content, recording its removal as the inverse.
+     *
+     * @param path - The path of the file to create.
+     * @param data - The content of the file.
+     * @returns A {@link Promise} resolving to the created {@link TFile}.
+     */
+    create(path: string, data: string): Promise<TFile>;
+    /**
+     * Creates a folder (including missing ancestors), recording its removal as the inverse. A no-op if
+     * the folder already exists.
+     *
+     * @param path - The path of the folder to create.
+     * @returns A {@link Promise} that resolves when the folder exists.
+     */
+    createFolder(path: string): Promise<void>;
+    /**
+     * Replaces the content of a file, capturing the old content so it can be restored on rollback.
+     *
+     * @param pathOrFile - The path or file to modify.
+     * @param newContent - The new content.
+     * @returns A {@link Promise} that resolves when the file is modified.
+     */
+    modify(pathOrFile: PathOrAbstractFile, newContent: string): Promise<void>;
+    /**
+     * Transforms the content of a file, capturing the old content so it can be restored on rollback.
+     *
+     * @param pathOrFile - The path or file to process.
+     * @param newContentProvider - Maps the current content to the new content.
+     * @returns A {@link Promise} that resolves when the file is processed.
+     */
+    process(pathOrFile: PathOrAbstractFile, newContentProvider: (content: string) => string): Promise<void>;
+    /**
+     * Renames or moves a resource, recording the reverse rename as the inverse.
+     *
+     * @param oldPathOrFile - The resource to rename.
+     * @param newPath - The desired new path (an available path is chosen if it is taken).
+     * @returns A {@link Promise} resolving to the actual new path.
+     */
+    rename(oldPathOrFile: PathOrAbstractFile, newPath: string): Promise<string>;
+    /**
+     * Rolls back the transaction: undoes the completed steps in reverse order and removes the staging
+     * folder. Idempotent.
+     *
+     * @returns A {@link Promise} that resolves when the rollback completes.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Rolls back the transaction on disposal unless it was already committed or rolled back.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Soft-deletes a resource by moving it into the staging folder, recording the move-back as the
+     * inverse. The real trash happens on {@link VaultTransaction.commit}. A no-op if the resource does
+     * not exist.
+     *
+     * @param pathOrFile - The path or resource to trash.
+     * @returns A {@link Promise} that resolves when the resource has been staged.
+     */
+    trash(pathOrFile: PathOrAbstractFile): Promise<void>;
+    private assertNotCommitted;
+    private assertOpen;
+    private disposeMutationBypass;
+    private ensureStagingFolder;
+    private getAvailableStagedPath;
+    private hardDelete;
+    private pushUndo;
+    private removeStagingFolder;
+}