obsidian-dev-utils 49.0.3 → 51.0.1

package/dist/lib/cjs/obsidian/async-with-notice.d.cts

@@ -0,0 +1,82 @@
+/**
+ * @packageDocumentation
+ *
+ * Provides a utility to execute an asynchronous function with a notice.
+ */
+import type { Promisable } from 'type-fest';
+import type { RetryOptions } from '../async.cjs';
+/**
+ * Options for {@link retryWithTimeoutNotice}.
+ */
+export interface RetryWithTimeoutNoticeParams {
+    /**
+     * The operation function to execute.
+     *
+     * @param abortSignal - The abort signal to listen to.
+     * @returns The result of the function.
+     */
+    readonly operationFn: (this: void, abortSignal: AbortSignal) => Promisable<boolean>;
+    /**
+     * The name of the operation.
+     */
+    readonly operationName?: string;
+    /**
+     * The retry options.
+     */
+    readonly retryOptions?: RetryOptions;
+    /**
+     * Whether to show a timeout notice. Default is `true`.
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+    /**
+     * The stack trace of the source function.
+     */
+    readonly stackTrace?: string;
+}
+/**
+ * Options for {@link runWithTimeout}.
+ */
+export interface RunWithTimeoutNoticeParams<Result> {
+    /**
+     * The context of the function.
+     */
+    readonly context?: unknown;
+    /**
+     * The operation function to execute.
+     *
+     * @param abortSignal - The abort signal to listen to.
+     * @returns The result of the function.
+     */
+    readonly operationFn: (abortSignal: AbortSignal) => Promisable<Result>;
+    /**
+     * The name of the operation.
+     */
+    readonly operationName?: string;
+    /**
+     * Whether to show a timeout notice. Default is `true`.
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+    /**
+     * The stack trace of the source function.
+     */
+    readonly stackTrace?: string;
+    /**
+     * The maximum time to wait in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * Retries the provided function until it returns `true` or the timeout is reached and displays a notice if the function times out.
+ *
+ * @param params - The parameters for the function.
+ * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.
+ */
+export declare function retryWithTimeoutNotice(params: RetryWithTimeoutNoticeParams): Promise<void>;
+/**
+ * Executes a function with a timeout and displays a notice if the function times out.
+ *
+ * @typeParam R - The type of the result from the asynchronous function.
+ * @param params - The parameters for the function.
+ * @returns The result of the function.
+ */
+export declare function runWithTimeoutNotice<Result>(params: RunWithTimeoutNoticeParams<Result>): Promise<Result>;

package/dist/lib/cjs/obsidian/attachment-path.cjs

@@ -0,0 +1,234 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
+    if (globalThis?.app?.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var attachment_path_exports = {};
+__export(attachment_path_exports, {
+  AttachmentPathContext: () => AttachmentPathContext,
+  DUMMY_PATH: () => DUMMY_PATH,
+  getAttachmentFilePath: () => getAttachmentFilePath,
+  getAttachmentFolderPath: () => getAttachmentFolderPath,
+  getAvailablePathForAttachments: () => getAvailablePathForAttachments,
+  hasOwnAttachmentFolder: () => hasOwnAttachmentFolder
+});
+module.exports = __toCommonJS(attachment_path_exports);
+var import_implementations = require('obsidian-typings/implementations');
+var import_path = require('../path.cjs');
+var import_string = require('../string.cjs');
+var import_file_system = require('./file-system.cjs');
+var AttachmentPathContext = /* @__PURE__ */ ((AttachmentPathContext2) => {
+  AttachmentPathContext2["DeleteNote"] = "DeleteNote";
+  AttachmentPathContext2["RenameNote"] = "RenameNote";
+  AttachmentPathContext2["Unknown"] = "Unknown";
+  return AttachmentPathContext2;
+})(AttachmentPathContext || {});
+const DUMMY_PATH = "__DUMMY__";
+async function getAttachmentFilePath(params) {
+  const {
+    app,
+    notePathOrFile,
+    oldAttachmentPathOrFile,
+    shouldSkipDuplicateCheck
+  } = params;
+  const attachmentPath = (0, import_file_system.getPath)(app, oldAttachmentPathOrFile);
+  const attachmentFileExtension = (0, import_path.extname)(attachmentPath);
+  const attachmentFileBaseName = (0, import_path.basename)(attachmentPath, attachmentFileExtension);
+  const attachmentFile = (0, import_file_system.getFileOrNull)(app, attachmentPath);
+  const extendedFn = app.vault.getAvailablePathForAttachments.extended;
+  if (extendedFn) {
+    return extendedFn({
+      attachmentFileBaseName,
+      attachmentFileContent: attachmentFile ? await app.vault.readBinary(attachmentFile) : void 0,
+      attachmentFileExtension: attachmentFileExtension.slice(1),
+      attachmentFileStat: attachmentFile?.stat,
+      context: params.context,
+      notePathOrFile,
+      oldAttachmentPathOrFile: params.oldAttachmentPathOrFile,
+      oldNotePathOrFile: params.oldNotePathOrFile,
+      shouldSkipDuplicateCheck,
+      shouldSkipMissingAttachmentFolderCreation: true
+    });
+  }
+  return await getAvailablePathForAttachments({
+    app,
+    attachmentFileBaseName,
+    attachmentFileExtension: attachmentFileExtension.slice(1),
+    notePathOrFile,
+    shouldSkipDuplicateCheck,
+    shouldSkipMissingAttachmentFolderCreation: true
+  });
+}
+async function getAttachmentFolderPath(app, notePathOrFile, context = "Unknown" /* Unknown */) {
+  return (0, import_implementations.parentFolderPath)(
+    await getAttachmentFilePath({
+      app,
+      context,
+      notePathOrFile,
+      oldAttachmentPathOrFile: DUMMY_PATH,
+      shouldSkipDuplicateCheck: true
+    })
+  );
+}
+async function getAvailablePathForAttachments(params) {
+  const {
+    app,
+    attachmentFileExtension,
+    notePathOrFile,
+    shouldSkipDuplicateCheck,
+    shouldSkipMissingAttachmentFolderCreation
+  } = params;
+  let attachmentFolderPath = app.vault.getConfig("attachmentFolderPath");
+  const isCurrentFolder = attachmentFolderPath === "." || attachmentFolderPath === "./";
+  const relativePath = attachmentFolderPath.startsWith("./") ? (0, import_string.trimStart)(attachmentFolderPath, "./") : null;
+  const noteFileOrNull = (0, import_file_system.getFileOrNull)(app, notePathOrFile);
+  if (isCurrentFolder) {
+    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? "" : "";
+  } else if (relativePath) {
+    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? "" : "") + relativePath;
+  }
+  attachmentFolderPath = (0, import_string.normalize)(normalizeSlashes(attachmentFolderPath));
+  const attachmentFileBaseName = (0, import_string.normalize)(normalizeSlashes(params.attachmentFileBaseName));
+  let folder = (0, import_file_system.getFolderOrNull)(app, attachmentFolderPath, true);
+  if (!folder && relativePath) {
+    folder = shouldSkipMissingAttachmentFolderCreation ? (0, import_file_system.getFolder)(app, attachmentFolderPath, true) : await app.vault.createFolder(attachmentFolderPath);
+  }
+  const prefix = folder?.getParentPrefix() ?? "";
+  return shouldSkipDuplicateCheck ? (0, import_path.makeFileName)(prefix + attachmentFileBaseName, attachmentFileExtension) : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);
+}
+async function hasOwnAttachmentFolder(app, path, context = "Unknown" /* Unknown */) {
+  const attachmentFolderPath = await getAttachmentFolderPath(app, path, context);
+  const dummyAttachmentFolderPath = await getAttachmentFolderPath(app, (0, import_path.join)((0, import_path.dirname)(path), `${DUMMY_PATH}.${import_file_system.MARKDOWN_FILE_EXTENSION}`), context);
+  return attachmentFolderPath !== dummyAttachmentFolderPath;
+}
+function normalizeSlashes(path) {
+  path = (0, import_string.replaceAll)(path, /(?:[\\/])+/g, "/");
+  path = (0, import_string.replaceAll)(path, /^\/+|\/+$/g, "");
+  return path || "/";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AttachmentPathContext,
+  DUMMY_PATH,
+  getAttachmentFilePath,
+  getAttachmentFolderPath,
+  getAvailablePathForAttachments,
+  hasOwnAttachmentFolder
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/attachment-path.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Provides utility functions for working with attachment paths.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  App,\n  FileStats,\n  Vault\n} from 'obsidian';\n\nimport { parentFolderPath } from 'obsidian-typings/implementations';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName\n} from '../path.ts';\nimport {\n  normalize,\n  replaceAll,\n  trimStart\n} from '../string.ts';\nimport {\n  getFileOrNull,\n  getFolder,\n  getFolderOrNull,\n  getPath,\n  MARKDOWN_FILE_EXTENSION\n} from './file-system.ts';\n\n/**\n * A context for an attachment path.\n */\nexport enum AttachmentPathContext {\n  /**\n   * A context for a delete note.\n   */\n  DeleteNote = 'DeleteNote',\n\n  /**\n   * A context for a rename note.\n   */\n  RenameNote = 'RenameNote',\n\n  /**\n   * An unknown context.\n   */\n  Unknown = 'Unknown'\n}\n\n/**\n * Options for the get available path for attachments extended function.\n */\nexport interface GetAvailablePathForAttachmentsExtendedFnParams {\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n\n  /**\n   * A content of the attachment file.\n   */\n  readonly attachmentFileContent?: ArrayBuffer | undefined;\n\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n\n  /**\n   * A stats of the attachment file.\n   */\n  readonly attachmentFileStat?: FileStats | undefined;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path or file of the note.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n\n  /**\n   * A path or file of the old attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path or file of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n\n  /**\n   * Should the generated attachment file name be skipped.\n   */\n  readonly shouldSkipGeneratedAttachmentFileName?: boolean;\n\n  /**\n   * Should missing attachment folder creation be skipped.\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;\n}\n\n/**\n * {@link Vault.getAvailablePathForAttachments} extended wrapper.\n */\nexport interface GetAvailablePathForAttachmentsFnExtended extends GetAvailablePathForAttachmentsFn {\n  /**\n   * Get available path for attachments with additional params.\n   *\n   * @param params - Parameters for the get available path for attachments.\n   * @returns A {@link Promise} that resolves to the available path for attachments.\n   */\n  extended(params: GetAvailablePathForAttachmentsExtendedFnParams): Promise<string>;\n}\n\ntype GetAvailablePathForAttachmentsFn = Vault['getAvailablePathForAttachments'];\n\n/**\n * Dummy path.\n */\nexport const DUMMY_PATH = '__DUMMY__';\n\n/**\n * Options for the getAttachmentFilePath function.\n */\nexport interface GetAttachmentFilePathParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n\n  /**\n   * A path of the attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck: boolean;\n}\n\n/**\n * Options for the getAvailablePathForAttachments function.\n */\nexport interface GetAvailablePathForAttachmentsParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n  /**\n   * A file to attach to.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n  /**\n   * Should missing attachment folder creation be skipped.\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation?: boolean;\n}\n\n/**\n * Retrieves the file path for an attachment within a note.\n *\n * @param params - Parameters for the get attachment file path function.\n * @returns A {@link Promise} that resolves to the file path of the attachment.\n */\nexport async function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string> {\n  const {\n    app,\n    notePathOrFile,\n    oldAttachmentPathOrFile,\n    shouldSkipDuplicateCheck\n  } = params;\n  const attachmentPath = getPath(app, oldAttachmentPathOrFile);\n  const attachmentFileExtension = extname(attachmentPath);\n  const attachmentFileBaseName = basename(attachmentPath, attachmentFileExtension);\n  const attachmentFile = getFileOrNull(app, attachmentPath);\n\n  const extendedFn = (app.vault.getAvailablePathForAttachments as Partial<GetAvailablePathForAttachmentsFnExtended>).extended;\n  if (extendedFn) {\n    return extendedFn({\n      attachmentFileBaseName,\n      attachmentFileContent: attachmentFile ? await app.vault.readBinary(attachmentFile) : undefined,\n      attachmentFileExtension: attachmentFileExtension.slice(1),\n      attachmentFileStat: attachmentFile?.stat,\n      context: params.context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: params.oldAttachmentPathOrFile,\n      oldNotePathOrFile: params.oldNotePathOrFile,\n      shouldSkipDuplicateCheck,\n      shouldSkipMissingAttachmentFolderCreation: true\n    });\n  }\n\n  return await getAvailablePathForAttachments({\n    app,\n    attachmentFileBaseName,\n    attachmentFileExtension: attachmentFileExtension.slice(1),\n    notePathOrFile,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation: true\n  });\n}\n\n/**\n * Retrieves the attachment folder path for a given note.\n *\n * @param app - The Obsidian application instance.\n * @param notePathOrFile - The path of the note.\n * @param context - The context.\n * @returns A {@link Promise} that resolves to the attachment folder path.\n */\nexport async function getAttachmentFolderPath(app: App, notePathOrFile: PathOrFile, context = AttachmentPathContext.Unknown): Promise<string> {\n  return parentFolderPath(\n    await getAttachmentFilePath({\n      app,\n      context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: DUMMY_PATH,\n      shouldSkipDuplicateCheck: true\n    })\n  );\n}\n\n/**\n * Retrieves the available path for attachments.\n *\n * @param params - Parameters for the get available path for attachments function.\n * @returns A {@link Promise} that resolves to the available path for attachments.\n */\nexport async function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string> {\n  const {\n    app,\n    attachmentFileExtension,\n    notePathOrFile,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation\n  } = params;\n  let attachmentFolderPath = app.vault.getConfig('attachmentFolderPath') as string;\n  const isCurrentFolder = attachmentFolderPath === '.' || attachmentFolderPath === './';\n  const relativePath = attachmentFolderPath.startsWith('./') ? trimStart(attachmentFolderPath, './') : null;\n\n  const noteFileOrNull = getFileOrNull(app, notePathOrFile);\n\n  if (isCurrentFolder) {\n    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? '' : '';\n  } else if (relativePath) {\n    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? '' : '') + relativePath;\n  }\n\n  attachmentFolderPath = normalize(normalizeSlashes(attachmentFolderPath));\n  const attachmentFileBaseName = normalize(normalizeSlashes(params.attachmentFileBaseName));\n\n  let folder = getFolderOrNull(app, attachmentFolderPath, true);\n\n  if (!folder && relativePath) {\n    folder = shouldSkipMissingAttachmentFolderCreation\n      ? getFolder(app, attachmentFolderPath, true)\n      : await app.vault.createFolder(attachmentFolderPath);\n  }\n\n  const prefix = folder?.getParentPrefix() ?? '';\n  return shouldSkipDuplicateCheck\n    ? makeFileName(prefix + attachmentFileBaseName, attachmentFileExtension)\n    : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);\n}\n\n/**\n * Checks if a note has its own attachment folder.\n *\n * @param app - The Obsidian application instance.\n * @param path - The path of the note.\n * @param context - The context.\n * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.\n */\nexport async function hasOwnAttachmentFolder(app: App, path: string, context = AttachmentPathContext.Unknown): Promise<boolean> {\n  const attachmentFolderPath = await getAttachmentFolderPath(app, path, context);\n  const dummyAttachmentFolderPath = await getAttachmentFolderPath(app, join(dirname(path), `${DUMMY_PATH}.${MARKDOWN_FILE_EXTENSION}`), context);\n  return attachmentFolderPath !== dummyAttachmentFolderPath;\n}\n\n/**\n * Normalizes a path by combining multiple slashes into a single slash and removing leading and trailing slashes.\n *\n * @param path - Path to normalize.\n * @returns The normalized path.\n */\nfunction normalizeSlashes(path: string): string {\n  path = replaceAll(path, /(?:[\\\\/])+/g, '/');\n  path = replaceAll(path, /^\\/+|\\/+$/g, '');\n  return path || '/';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["AttachmentPathContext"]
}


package/dist/lib/cjs/obsidian/attachment-path.d.cts

@@ -0,0 +1,181 @@
+/**
+ * @packageDocumentation
+ *
+ * Provides utility functions for working with attachment paths.
+ */
+import type { App, FileStats, Vault } from 'obsidian';
+import type { PathOrFile } from './file-system.cjs';
+/**
+ * A context for an attachment path.
+ */
+export declare enum AttachmentPathContext {
+    /**
+     * A context for a delete note.
+     */
+    DeleteNote = "DeleteNote",
+    /**
+     * A context for a rename note.
+     */
+    RenameNote = "RenameNote",
+    /**
+     * An unknown context.
+     */
+    Unknown = "Unknown"
+}
+/**
+ * Options for the get available path for attachments extended function.
+ */
+export interface GetAvailablePathForAttachmentsExtendedFnParams {
+    /**
+     * A base name of the attachment.
+     */
+    readonly attachmentFileBaseName: string;
+    /**
+     * A content of the attachment file.
+     */
+    readonly attachmentFileContent?: ArrayBuffer | undefined;
+    /**
+     * An extension of the attachment.
+     */
+    readonly attachmentFileExtension: string;
+    /**
+     * A stats of the attachment file.
+     */
+    readonly attachmentFileStat?: FileStats | undefined;
+    /**
+     * A context.
+     */
+    readonly context: AttachmentPathContext;
+    /**
+     * A path or file of the note.
+     */
+    readonly notePathOrFile: null | PathOrFile;
+    /**
+     * A path or file of the old attachment.
+     */
+    readonly oldAttachmentPathOrFile: PathOrFile;
+    /**
+     * A path or file of the old note.
+     */
+    readonly oldNotePathOrFile?: PathOrFile | undefined;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck?: boolean;
+    /**
+     * Should the generated attachment file name be skipped.
+     */
+    readonly shouldSkipGeneratedAttachmentFileName?: boolean;
+    /**
+     * Should missing attachment folder creation be skipped.
+     */
+    readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;
+}
+/**
+ * {@link Vault.getAvailablePathForAttachments} extended wrapper.
+ */
+export interface GetAvailablePathForAttachmentsFnExtended extends GetAvailablePathForAttachmentsFn {
+    /**
+     * Get available path for attachments with additional params.
+     *
+     * @param params - Parameters for the get available path for attachments.
+     * @returns A {@link Promise} that resolves to the available path for attachments.
+     */
+    extended(params: GetAvailablePathForAttachmentsExtendedFnParams): Promise<string>;
+}
+type GetAvailablePathForAttachmentsFn = Vault['getAvailablePathForAttachments'];
+/**
+ * Dummy path.
+ */
+export declare const DUMMY_PATH = "__DUMMY__";
+/**
+ * Options for the getAttachmentFilePath function.
+ */
+export interface GetAttachmentFilePathParams {
+    /**
+     * An Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * A context.
+     */
+    readonly context: AttachmentPathContext;
+    /**
+     * A path of the note.
+     */
+    readonly notePathOrFile: PathOrFile;
+    /**
+     * A path of the attachment.
+     */
+    readonly oldAttachmentPathOrFile: PathOrFile;
+    /**
+     * A path of the old note.
+     */
+    readonly oldNotePathOrFile?: PathOrFile | undefined;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck: boolean;
+}
+/**
+ * Options for the getAvailablePathForAttachments function.
+ */
+export interface GetAvailablePathForAttachmentsParams {
+    /**
+     * An Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * A base name of the attachment.
+     */
+    readonly attachmentFileBaseName: string;
+    /**
+     * An extension of the attachment.
+     */
+    readonly attachmentFileExtension: string;
+    /**
+     * A file to attach to.
+     */
+    readonly notePathOrFile: null | PathOrFile;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck?: boolean;
+    /**
+     * Should missing attachment folder creation be skipped.
+     */
+    readonly shouldSkipMissingAttachmentFolderCreation?: boolean;
+}
+/**
+ * Retrieves the file path for an attachment within a note.
+ *
+ * @param params - Parameters for the get attachment file path function.
+ * @returns A {@link Promise} that resolves to the file path of the attachment.
+ */
+export declare function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string>;
+/**
+ * Retrieves the attachment folder path for a given note.
+ *
+ * @param app - The Obsidian application instance.
+ * @param notePathOrFile - The path of the note.
+ * @param context - The context.
+ * @returns A {@link Promise} that resolves to the attachment folder path.
+ */
+export declare function getAttachmentFolderPath(app: App, notePathOrFile: PathOrFile, context?: AttachmentPathContext): Promise<string>;
+/**
+ * Retrieves the available path for attachments.
+ *
+ * @param params - Parameters for the get available path for attachments function.
+ * @returns A {@link Promise} that resolves to the available path for attachments.
+ */
+export declare function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string>;
+/**
+ * Checks if a note has its own attachment folder.
+ *
+ * @param app - The Obsidian application instance.
+ * @param path - The path of the note.
+ * @param context - The context.
+ * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.
+ */
+export declare function hasOwnAttachmentFolder(app: App, path: string, context?: AttachmentPathContext): Promise<boolean>;
+export {};