obsidian-dev-utils 85.1.0 → 86.1.0

package/dist/lib/cjs/obsidian/components/plugin-notice-component.d.cts

@@ -4,6 +4,8 @@
  *
  * Component that manages displaying notices to the user.
  */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import { Notice } from 'obsidian';
 import type { ValueProvider } from '../../value-provider.cjs';
 import { ComponentEx } from './component-ex.cjs';
@@ -64,20 +66,64 @@ export interface PluginNoticeComponentShowNoticeOptions {
      * @default `false`
      */
     readonly isPermanent?: boolean;
+    /**
+     * Whether the notice occupies the single per-plugin reusable slot.
+     *
+     * A reusable notice takes the shared slot: the next reusable notice hides it, and it is hidden on unload.
+     * A non-reusable (standalone) notice is not placed in the slot — it never hides, and is never hidden by, a
+     * reusable notice; multiple standalone notices coexist. Standalone notices are still hidden together on unload.
+     *
+     * A permanent notice must be reusable ({@link PluginNoticeComponentShowNoticeOptions.isPermanent} implies
+     * `isReusable`); passing `isReusable: false` together with `isPermanent: true` throws.
+     *
+     * @default `true`
+     */
+    readonly isReusable?: boolean;
+    /**
+     * A callback invoked when the notice is hidden — whether by the user closing it, by a later reusable
+     * notice replacing it, by its duration elapsing, or on component unload. It runs at most once per
+     * notice. An async callback is run fire-and-forget (its rejection surfaces through the async-error
+     * pipeline).
+     */
+    onHide?(this: void): Promisable<void>;
+    /**
+     * Whether the notice is hard to close: it does not dismiss on any stray click, and instead shows a
+     * close (X) button whose click opens a confirmation modal, dismissing the notice only if confirmed.
+     *
+     * A hard-to-close notice is shown with an infinite duration and is standalone (implies
+     * {@link PluginNoticeComponentShowNoticeOptions.isReusable} `= false`), so a later notice never
+     * silently replaces it; passing `isReusable: true` together with `requiresCloseConfirmation: true`
+     * throws.
+     *
+     * @default `false`
+     */
+    readonly requiresCloseConfirmation?: boolean;
+}
+interface PluginNoticeComponentConstructorParams {
+    readonly app: App;
+    readonly pluginName: string;
 }
 /**
  * Manages showing plugin notices. Automatically hides the previous notice when a new one is shown.
  */
 export declare class PluginNoticeComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The plugin name (shown as prefix in notices).
+     */
     protected readonly pluginName: string;
     private notice;
     private readonly pendingTimerCancellations;
+    private readonly standaloneNotices;
     /**
      * Creates a new plugin notice component.
      *
-     * @param pluginName - The plugin name (shown as prefix in notices).
+     * @param params - The constructor parameters.
      */
-    constructor(pluginName: string);
+    constructor(params: PluginNoticeComponentConstructorParams);
     /**
      * Dismisses the permanent notice left over from a previous load (e.g. a previous plugin session) on load.
      */
@@ -116,6 +162,14 @@ export declare class PluginNoticeComponent extends ComponentEx {
      * timer) when disposed and lets the content be updated while it is shown.
      */
     showNoticeAfterDelay(params: PluginNoticeComponentShowNoticeAfterDelayParams): PluginNoticeComponentDelayedNotice;
+    /**
+     * Appends a close (X) button to the notice content. Clicking it opens a confirmation modal and, only
+     * if confirmed, hides the notice and drops it from the standalone-notice tracking set.
+     *
+     * @param contentEl - The notice content wrapper to append the button to.
+     * @param getNotice - Resolves the notice to hide when the close is confirmed.
+     */
+    private appendCloseButton;
     /**
      * Builds the message for a delayed notice: the resolved content, optionally followed by a Cancel
      * button that aborts the provided controller when clicked.
@@ -130,7 +184,7 @@ export declare class PluginNoticeComponent extends ComponentEx {
      * element; the container intercepts clicks originating on an interactive element (a link, button,
      * input, etc.) and stops them there, so the element's own handler still runs but the notice stays.
      *
-     * @param message - The message to display after the plugin name prefix.
+     * @param params - The parameters.
      * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.
      */
     private buildNoticeContent;
@@ -144,15 +198,34 @@ export declare class PluginNoticeComponent extends ComponentEx {
     private buildPrefixedMessage;
     private getPermanentNotice;
     private getPermanentNotices;
+    /**
+     * Makes a notice hard to close: marks its outer element (so the CSS neutralizes its padding) and
+     * installs a capture-phase click guard that stops every click except on the close button from
+     * reaching Obsidian's own dismiss handler.
+     *
+     * @param notice - The notice to guard.
+     * @param requiresCloseConfirmation - Whether the notice requires close confirmation; when `false`,
+     * nothing is installed.
+     */
+    private installCloseConfirmationGuards;
     private setPermanentNotice;
     /**
-     * Shows a notice with the given duration, replacing the current notice, and optionally registers it
-     * as this plugin's permanent notice.
+     * Shows a notice with the given duration. A reusable notice replaces the current reusable notice (and
+     * is optionally registered as this plugin's permanent notice); a standalone notice is tracked
+     * separately, leaving the reusable slot untouched.
      *
-     * @param message - The message to display.
-     * @param durationInMilliseconds - The notice duration; `0` keeps it until it is hidden explicitly.
-     * @param shouldRegisterAsPermanent - Whether to track the notice as this plugin's permanent notice.
+     * @param params - The parameters.
      * @returns The created notice.
      */
     private showNoticeWithDuration;
+    /**
+     * Wraps a notice's `hide` so the given callback runs the first time the notice is hidden — by the
+     * user, by a replacing notice, by its duration elapsing, or on unload. Does nothing when no callback
+     * is given.
+     *
+     * @param notice - The notice whose `hide` to wrap.
+     * @param onHide - The callback to invoke on the first hide, or `undefined` to skip wrapping.
+     */
+    private wireOnHide;
 }
+export {};

package/dist/lib/cjs/obsidian/css-class.cjs

@@ -156,12 +156,15 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["OkButton"] = "ok-button";
   CssClass2["OverlayValidator"] = "overlay-validator";
   CssClass2["PasswordComponent"] = "password-component";
+  CssClass2["PluginNoticeCloseButton"] = "plugin-notice-close-button";
   CssClass2["PluginNoticeContent"] = "plugin-notice-content";
   CssClass2["PluginNoticeName"] = "plugin-notice-name";
+  CssClass2["PluginNoticeRequiresConfirmation"] = "plugin-notice-requires-confirmation";
   CssClass2["PluginSettingsTab"] = "plugin-settings-tab";
   CssClass2["PromptModal"] = "prompt-modal";
   CssClass2["RestoreButton"] = "restore-button";
   CssClass2["SelectItemModal"] = "select-item-modal";
+  CssClass2["SelectOptionModal"] = "select-option-modal";
   CssClass2["SettingComponentWrapper"] = "setting-component-wrapper";
   CssClass2["TelephoneComponent"] = "telephone-component";
   CssClass2["TextBox"] = "text-box";
@@ -180,4 +183,4 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
 0 && (module.exports = {
   CssClass
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `obsidian-dev-utils` library.\n */\n\n/**\n * CSS classes used by the `obsidian-dev-utils` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name.\n   */\n  LibraryName = 'obsidian-dev-utils',\n\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAKjC,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAlON,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `obsidian-dev-utils` library.\n */\n\n/**\n * CSS classes used by the `obsidian-dev-utils` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name.\n   */\n  LibraryName = 'obsidian-dev-utils',\n\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires close confirmation, used to\n   * make its whole area non-dismissible.\n   */\n  PluginNoticeRequiresConfirmation = 'plugin-notice-requires-confirmation',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,sCAAmC;AAKnC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAKjC,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAlPN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}


package/dist/lib/cjs/obsidian/css-class.d.cts

@@ -117,6 +117,10 @@ export declare enum CssClass {
      * A CSS class for the password component.
      */
     PasswordComponent = "password-component",
+    /**
+     * A CSS class for the close button of a notice that requires close confirmation.
+     */
+    PluginNoticeCloseButton = "plugin-notice-close-button",
     /**
      * A CSS class for the container wrapping a notice's content, used to keep the notice open when an
      * interactive element inside it is clicked.
@@ -126,6 +130,11 @@ export declare enum CssClass {
      * A CSS class for the plugin name shown as the prefix of a notice.
      */
     PluginNoticeName = "plugin-notice-name",
+    /**
+     * A CSS class applied to the notice element of a notice that requires close confirmation, used to
+     * make its whole area non-dismissible.
+     */
+    PluginNoticeRequiresConfirmation = "plugin-notice-requires-confirmation",
     /**
      * A CSS class for the plugin settings tab.
      */
@@ -142,6 +151,10 @@ export declare enum CssClass {
      * A CSS class for the select item modal.
      */
     SelectItemModal = "select-item-modal",
+    /**
+     * A CSS class for the select option modal.
+     */
+    SelectOptionModal = "select-option-modal",
     /**
      * A CSS class for the setting component wrapper.
      */

package/dist/lib/cjs/obsidian/desktop-demo-vault-opener.cjs

@@ -0,0 +1,239 @@
+/*
+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() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  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, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var desktop_demo_vault_opener_exports = {};
+__export(desktop_demo_vault_opener_exports, {
+  openDemoVault: () => openDemoVault
+});
+module.exports = __toCommonJS(desktop_demo_vault_opener_exports);
+var import_adm_zip = __toESM(__extractDefault(require('adm-zip')), 1);
+var import_compare_versions = require('compare-versions');
+var import_node_buffer = require('node:buffer');
+var import_node_fs = require('node:fs');
+var import_node_os = require('node:os');
+var import_obsidian = require('obsidian');
+var import_path = require('../path.cjs');
+var import_community_plugins = require('./community-plugins.cjs');
+var import_select_option = require('./modals/select-option.cjs');
+const DEMO_VAULTS_CACHE_FOLDER = "obsidian-demo-vaults";
+const HTTP_STATUS_OK = 200;
+async function openDemoVault(params) {
+  const {
+    app,
+    manifest,
+    pluginNoticeComponent
+  } = params;
+  const repo = await (0, import_community_plugins.getCommunityPluginRepo)(manifest.id);
+  if (!repo) {
+    pluginNoticeComponent.showNotice(`Could not find plugin ${manifest.name} in the community plugins registry.`);
+    return;
+  }
+  const currentVersion = manifest.version;
+  const latestVersion = await getLatestReleaseVersion(repo);
+  let versionToOpen;
+  if ((0, import_compare_versions.compareVersions)(currentVersion, latestVersion) >= 0) {
+    versionToOpen = currentVersion;
+  } else {
+    const chosenVersion = await (0, import_select_option.selectOption)({
+      app,
+      message: `Current version of plugin ${manifest.name} v${currentVersion} is not the latest (v${latestVersion})`,
+      options: [
+        {
+          isCta: true,
+          text: `Open demo vault for latest version (v${latestVersion})`,
+          value: latestVersion
+        },
+        {
+          text: `Open demo vault for current version (v${currentVersion})`,
+          value: currentVersion
+        },
+        {
+          text: "Cancel",
+          value: null
+        }
+      ],
+      title: manifest.name
+    });
+    if (chosenVersion === null) {
+      return;
+    }
+    versionToOpen = chosenVersion;
+  }
+  const cacheDir = (0, import_path.join)((0, import_node_os.tmpdir)(), DEMO_VAULTS_CACHE_FOLDER, manifest.id, versionToOpen);
+  if (!(0, import_node_fs.existsSync)(cacheDir)) {
+    const isExtracted = await downloadAndExtractDemoVault({
+      cacheDir,
+      manifest,
+      pluginNoticeComponent,
+      repo,
+      version: versionToOpen
+    });
+    if (!isExtracted) {
+      return;
+    }
+  }
+  window.electron.ipcRenderer.sendSync("vault-open", cacheDir, false);
+}
+async function downloadAndExtractDemoVault(params) {
+  const {
+    cacheDir,
+    manifest,
+    pluginNoticeComponent,
+    repo,
+    version
+  } = params;
+  const assetUrl = `https://github.com/${repo}/releases/download/${version}/demo-vault-${version}.zip`;
+  const response = await (0, import_obsidian.requestUrl)({
+    throw: false,
+    url: assetUrl
+  });
+  if (response.status !== HTTP_STATUS_OK) {
+    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${manifest.name} v${version}.`);
+    return false;
+  }
+  const zip = new import_adm_zip.default(import_node_buffer.Buffer.from(response.arrayBuffer));
+  zip.extractAllTo(cacheDir, true);
+  return true;
+}
+async function getLatestReleaseVersion(repo) {
+  const response = await (0, import_obsidian.requestUrl)(`https://api.github.com/repos/${repo}/releases/latest`);
+  const release = response.json;
+  return release.tag_name;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDemoVault
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, extracts it to a\n * per-version cache folder under the OS temp directory, and opens that folder as a vault in a new\n * window. When the installed plugin version is behind the latest release, the user is offered a choice\n * between the two versions.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\n\nimport AdmZip from 'adm-zip';\nimport { compareVersions } from 'compare-versions';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { Buffer } from 'node:buffer';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { existsSync } from 'node:fs';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { tmpdir } from 'node:os';\nimport { requestUrl } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { join } from '../path.ts';\nimport { getCommunityPluginRepo } from './community-plugins.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The manifest of the plugin whose demo vault is opened. Its `id` locates the GitHub repository, its\n   * `version` selects the archive, and its `name` labels the notices and the version-choice dialog.\n   */\n  readonly manifest: PluginManifest;\n\n  /**\n   * The notice component used to report problems (plugin not in the registry, missing archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n}\n\ninterface DownloadAndExtractDemoVaultParams {\n  readonly cacheDir: string;\n  readonly manifest: PluginManifest;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly repo: string;\n  readonly version: string;\n}\n\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst HTTP_STATUS_OK = 200;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. The chosen version's\n * archive is downloaded and extracted once, then reused from a per-version cache folder.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    manifest,\n    pluginNoticeComponent\n  } = params;\n\n  const repo = await getCommunityPluginRepo(manifest.id);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${manifest.name} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = manifest.version;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${manifest.name} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: manifest.name\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const cacheDir = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, manifest.id, versionToOpen);\n  if (!existsSync(cacheDir)) {\n    const isExtracted = await downloadAndExtractDemoVault({\n      cacheDir,\n      manifest,\n      pluginNoticeComponent,\n      repo,\n      version: versionToOpen\n    });\n    if (!isExtracted) {\n      return;\n    }\n  }\n\n  window.electron.ipcRenderer.sendSync('vault-open', cacheDir, false);\n}\n\nasync function downloadAndExtractDemoVault(params: DownloadAndExtractDemoVaultParams): Promise<boolean> {\n  const {\n    cacheDir,\n    manifest,\n    pluginNoticeComponent,\n    repo,\n    version\n  } = params;\n\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${manifest.name} v${version}.`);\n    return false;\n  }\n\n  const zip = new AdmZip(Buffer.from(response.arrayBuffer));\n  zip.extractAllTo(cacheDir, true);\n  return true;\n}\n\nasync function getLatestReleaseVersion(repo: string): Promise<string> {\n  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);\n  const release = response.json as GitHubRelease;\n  return release.tag_name;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,qBAAmB;AACnB,8BAAgC;AAEhC,yBAAuB;AAEvB,qBAA2B;AAE3B,qBAAuB;AACvB,sBAA2B;AAI3B,kBAAqB;AACrB,+BAAuC;AACvC,2BAA6B;AAsC7B,MAAM,2BAA2B;AACjC,MAAM,iBAAiB;AAavB,eAAsB,cAAc,QAA4C;AAC9E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,OAAO,UAAM,iDAAuB,SAAS,EAAE;AACrD,MAAI,CAAC,MAAM;AACT,0BAAsB,WAAW,yBAAyB,SAAS,IAAI,qCAAqC;AAC5G;AAAA,EACF;AAEA,QAAM,iBAAiB,SAAS;AAChC,QAAM,gBAAgB,MAAM,wBAAwB,IAAI;AAExD,MAAI;AACJ,UAAI,yCAAgB,gBAAgB,aAAa,KAAK,GAAG;AACvD,oBAAgB;AAAA,EAClB,OAAO;AACL,UAAM,gBAAgB,UAAM,mCAA4B;AAAA,MACtD;AAAA,MACA,SAAS,6BAA6B,SAAS,IAAI,KAAK,cAAc,wBAAwB,aAAa;AAAA,MAC3G,SAAS;AAAA,QACP;AAAA,UACE,OAAO;AAAA,UACP,MAAM,wCAAwC,aAAa;AAAA,UAC3D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM,yCAAyC,cAAc;AAAA,UAC7D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,MACA,OAAO,SAAS;AAAA,IAClB,CAAC;AACD,QAAI,kBAAkB,MAAM;AAC1B;AAAA,IACF;AACA,oBAAgB;AAAA,EAClB;AAEA,QAAM,eAAW,sBAAK,uBAAO,GAAG,0BAA0B,SAAS,IAAI,aAAa;AACpF,MAAI,KAAC,2BAAW,QAAQ,GAAG;AACzB,UAAM,cAAc,MAAM,4BAA4B;AAAA,MACpD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,aAAa;AAChB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,SAAS,YAAY,SAAS,cAAc,UAAU,KAAK;AACpE;AAEA,eAAe,4BAA4B,QAA6D;AACtG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,sBAAsB,IAAI,sBAAsB,OAAO,eAAe,OAAO;AAC9F,QAAM,WAAW,UAAM,4BAAW;AAAA,IAChC,OAAO;AAAA,IACP,KAAK;AAAA,EACP,CAAC;AACD,MAAI,SAAS,WAAW,gBAAgB;AACtC,0BAAsB,WAAW,yCAAyC,SAAS,IAAI,KAAK,OAAO,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,IAAI,eAAAA,QAAO,0BAAO,KAAK,SAAS,WAAW,CAAC;AACxD,MAAI,aAAa,UAAU,IAAI;AAC/B,SAAO;AACT;AAEA,eAAe,wBAAwB,MAA+B;AACpE,QAAM,WAAW,UAAM,4BAAW,gCAAgC,IAAI,kBAAkB;AACxF,QAAM,UAAU,SAAS;AACzB,SAAO,QAAQ;AACjB;",
  "names": ["AdmZip"]
}


package/dist/lib/cjs/obsidian/desktop-demo-vault-opener.d.cts

@@ -0,0 +1,45 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).
+ *
+ * A plugin can attach a `demo-vault-<version>.zip` archive to each GitHub release (see
+ * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository
+ * from Obsidian's community registry, downloads the archive for the chosen version, extracts it to a
+ * per-version cache folder under the OS temp directory, and opens that folder as a vault in a new
+ * window. When the installed plugin version is behind the latest release, the user is offered a choice
+ * between the two versions.
+ */
+import type { App, PluginManifest } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PluginNoticeComponent } from './components/plugin-notice-component.cjs';
+/**
+ * Parameters for {@link openDemoVault}.
+ */
+export interface OpenDemoVaultParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The manifest of the plugin whose demo vault is opened. Its `id` locates the GitHub repository, its
+     * `version` selects the archive, and its `name` labels the notices and the version-choice dialog.
+     */
+    readonly manifest: PluginManifest;
+    /**
+     * The notice component used to report problems (plugin not in the registry, missing archive).
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+}
+/**
+ * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.
+ *
+ * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise
+ * the user chooses between the latest and the currently-installed version. The chosen version's
+ * archive is downloaded and extracted once, then reused from a per-version cache folder.
+ *
+ * @param params - The {@link OpenDemoVaultParams}.
+ * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has
+ * been reported as not possible (notice shown) or cancelled by the user.
+ */
+export declare function openDemoVault(params: OpenDemoVaultParams): Promise<void>;