@vasakgroup/vue-libvasak 0.0.2 → 0.1.0

package/dist/vue-libvasak.es.js

@@ -0,0 +1,2084 @@
+import { createElementBlock as v, openBlock as f, renderSlot as R, defineComponent as C, createElementVNode as u, ref as p, onMounted as F, toDisplayString as U, unref as D, Fragment as V, createVNode as G } from "vue";
+const $ = (i, e) => {
+  const t = i.__vccOpts || i;
+  for (const [l, s] of e)
+    t[l] = s;
+  return t;
+}, H = {}, J = { class: "sidebar" };
+function q(i, e) {
+  return f(), v("div", J, [
+    R(i.$slots, "default")
+  ]);
+}
+const j = /* @__PURE__ */ $(H, [["render", q]]), Z = {
+  href: "#",
+  class: "sidebar-button"
+}, Q = ["src"], Y = /* @__PURE__ */ C({
+  __name: "SideButton",
+  props: {
+    title: {
+      type: String,
+      default: "Link"
+    },
+    image: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(i) {
+    return (e, t) => (f(), v("a", Z, [
+      u("img", {
+        src: i.image,
+        class: "img-fluid"
+      }, null, 8, Q)
+    ]));
+  }
+});
+function K(i, e, t, l) {
+  if (typeof e == "function" ? i !== e || !l : !e.has(i)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return t === "m" ? l : t === "a" ? l.call(i) : l ? l.value : e.get(i);
+}
+function X(i, e, t, l, s) {
+  if (typeof e == "function" ? i !== e || !0 : !e.has(i)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return e.set(i, t), t;
+}
+var y;
+const o = "__TAURI_TO_IPC_KEY__";
+function ee(i, e = !1) {
+  return window.__TAURI_INTERNALS__.transformCallback(i, e);
+}
+async function n(i, e = {}, t) {
+  return window.__TAURI_INTERNALS__.invoke(i, e, t);
+}
+class ie {
+  get rid() {
+    return K(this, y, "f");
+  }
+  constructor(e) {
+    y.set(this, void 0), X(this, y, e);
+  }
+  /**
+   * Destroys and cleans up this resource from memory.
+   * **You should not call any method on this object anymore and should drop any reference to it.**
+   */
+  async close() {
+    return n("plugin:resources|close", {
+      rid: this.rid
+    });
+  }
+}
+y = /* @__PURE__ */ new WeakMap();
+class L {
+  constructor(...e) {
+    this.type = "Logical", e.length === 1 ? "Logical" in e[0] ? (this.width = e[0].Logical.width, this.height = e[0].Logical.height) : (this.width = e[0].width, this.height = e[0].height) : (this.width = e[0], this.height = e[1]);
+  }
+  /**
+   * Converts the logical size to a physical one.
+   * @example
+   * ```typescript
+   * import { LogicalSize } from '@tauri-apps/api/dpi';
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   *
+   * const appWindow = getCurrentWindow();
+   * const factor = await appWindow.scaleFactor();
+   * const size = new LogicalSize(400, 500);
+   * const physical = size.toPhysical(factor);
+   * ```
+   *
+   * @since 2.0.0
+   */
+  toPhysical(e) {
+    return new b(this.width * e, this.height * e);
+  }
+  [o]() {
+    return {
+      width: this.width,
+      height: this.height
+    };
+  }
+  toJSON() {
+    return this[o]();
+  }
+}
+class b {
+  constructor(...e) {
+    this.type = "Physical", e.length === 1 ? "Physical" in e[0] ? (this.width = e[0].Physical.width, this.height = e[0].Physical.height) : (this.width = e[0].width, this.height = e[0].height) : (this.width = e[0], this.height = e[1]);
+  }
+  /**
+   * Converts the physical size to a logical one.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const appWindow = getCurrentWindow();
+   * const factor = await appWindow.scaleFactor();
+   * const size = await appWindow.innerSize(); // PhysicalSize
+   * const logical = size.toLogical(factor);
+   * ```
+   */
+  toLogical(e) {
+    return new L(this.width / e, this.height / e);
+  }
+  [o]() {
+    return {
+      width: this.width,
+      height: this.height
+    };
+  }
+  toJSON() {
+    return this[o]();
+  }
+}
+class w {
+  constructor(e) {
+    this.size = e;
+  }
+  toLogical(e) {
+    return this.size instanceof L ? this.size : this.size.toLogical(e);
+  }
+  toPhysical(e) {
+    return this.size instanceof b ? this.size : this.size.toPhysical(e);
+  }
+  [o]() {
+    return {
+      [`${this.size.type}`]: {
+        width: this.size.width,
+        height: this.size.height
+      }
+    };
+  }
+  toJSON() {
+    return this[o]();
+  }
+}
+class E {
+  constructor(...e) {
+    this.type = "Logical", e.length === 1 ? "Logical" in e[0] ? (this.x = e[0].Logical.x, this.y = e[0].Logical.y) : (this.x = e[0].x, this.y = e[0].y) : (this.x = e[0], this.y = e[1]);
+  }
+  /**
+   * Converts the logical position to a physical one.
+   * @example
+   * ```typescript
+   * import { LogicalPosition } from '@tauri-apps/api/dpi';
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   *
+   * const appWindow = getCurrentWindow();
+   * const factor = await appWindow.scaleFactor();
+   * const position = new LogicalPosition(400, 500);
+   * const physical = position.toPhysical(factor);
+   * ```
+   *
+   * @since 2.0.0
+   */
+  toPhysical(e) {
+    return new c(this.x * e, this.y * e);
+  }
+  [o]() {
+    return {
+      x: this.x,
+      y: this.y
+    };
+  }
+  toJSON() {
+    return this[o]();
+  }
+}
+class c {
+  constructor(...e) {
+    this.type = "Physical", e.length === 1 ? "Physical" in e[0] ? (this.x = e[0].Physical.x, this.y = e[0].Physical.y) : (this.x = e[0].x, this.y = e[0].y) : (this.x = e[0], this.y = e[1]);
+  }
+  /**
+   * Converts the physical position to a logical one.
+   * @example
+   * ```typescript
+   * import { PhysicalPosition } from '@tauri-apps/api/dpi';
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   *
+   * const appWindow = getCurrentWindow();
+   * const factor = await appWindow.scaleFactor();
+   * const position = new PhysicalPosition(400, 500);
+   * const physical = position.toLogical(factor);
+   * ```
+   *
+   * @since 2.0.0
+   */
+  toLogical(e) {
+    return new E(this.x / e, this.y / e);
+  }
+  [o]() {
+    return {
+      x: this.x,
+      y: this.y
+    };
+  }
+  toJSON() {
+    return this[o]();
+  }
+}
+class _ {
+  constructor(e) {
+    this.position = e;
+  }
+  toLogical(e) {
+    return this.position instanceof E ? this.position : this.position.toLogical(e);
+  }
+  toPhysical(e) {
+    return this.position instanceof c ? this.position : this.position.toPhysical(e);
+  }
+  [o]() {
+    return {
+      [`${this.position.type}`]: {
+        x: this.position.x,
+        y: this.position.y
+      }
+    };
+  }
+  toJSON() {
+    return this[o]();
+  }
+}
+var r;
+(function(i) {
+  i.WINDOW_RESIZED = "tauri://resize", i.WINDOW_MOVED = "tauri://move", i.WINDOW_CLOSE_REQUESTED = "tauri://close-requested", i.WINDOW_DESTROYED = "tauri://destroyed", i.WINDOW_FOCUS = "tauri://focus", i.WINDOW_BLUR = "tauri://blur", i.WINDOW_SCALE_FACTOR_CHANGED = "tauri://scale-change", i.WINDOW_THEME_CHANGED = "tauri://theme-changed", i.WINDOW_CREATED = "tauri://window-created", i.WEBVIEW_CREATED = "tauri://webview-created", i.DRAG_ENTER = "tauri://drag-enter", i.DRAG_OVER = "tauri://drag-over", i.DRAG_DROP = "tauri://drag-drop", i.DRAG_LEAVE = "tauri://drag-leave";
+})(r || (r = {}));
+async function P(i, e) {
+  window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener(i, e), await n("plugin:event|unlisten", {
+    event: i,
+    eventId: e
+  });
+}
+async function T(i, e, t) {
+  var l;
+  const s = typeof t?.target == "string" ? { kind: "AnyLabel", label: t.target } : (l = t?.target) !== null && l !== void 0 ? l : { kind: "Any" };
+  return n("plugin:event|listen", {
+    event: i,
+    target: s,
+    handler: ee(e)
+  }).then((d) => async () => P(i, d));
+}
+async function te(i, e, t) {
+  return T(i, (l) => {
+    P(i, l.id), e(l);
+  }, t);
+}
+async function ne(i, e) {
+  await n("plugin:event|emit", {
+    event: i,
+    payload: e
+  });
+}
+async function le(i, e, t) {
+  await n("plugin:event|emit_to", {
+    target: typeof i == "string" ? { kind: "AnyLabel", label: i } : i,
+    event: e,
+    payload: t
+  });
+}
+class g extends ie {
+  /**
+   * Creates an Image from a resource ID. For internal use only.
+   *
+   * @ignore
+   */
+  constructor(e) {
+    super(e);
+  }
+  /** Creates a new Image using RGBA data, in row-major order from top to bottom, and with specified width and height. */
+  static async new(e, t, l) {
+    return n("plugin:image|new", {
+      rgba: m(e),
+      width: t,
+      height: l
+    }).then((s) => new g(s));
+  }
+  /**
+   * Creates a new image using the provided bytes by inferring the file format.
+   * If the format is known, prefer [@link Image.fromPngBytes] or [@link Image.fromIcoBytes].
+   *
+   * Only `ico` and `png` are supported (based on activated feature flag).
+   *
+   * Note that you need the `image-ico` or `image-png` Cargo features to use this API.
+   * To enable it, change your Cargo.toml file:
+   * ```toml
+   * [dependencies]
+   * tauri = { version = "...", features = ["...", "image-png"] }
+   * ```
+   */
+  static async fromBytes(e) {
+    return n("plugin:image|from_bytes", {
+      bytes: m(e)
+    }).then((t) => new g(t));
+  }
+  /**
+   * Creates a new image using the provided path.
+   *
+   * Only `ico` and `png` are supported (based on activated feature flag).
+   *
+   * Note that you need the `image-ico` or `image-png` Cargo features to use this API.
+   * To enable it, change your Cargo.toml file:
+   * ```toml
+   * [dependencies]
+   * tauri = { version = "...", features = ["...", "image-png"] }
+   * ```
+   */
+  static async fromPath(e) {
+    return n("plugin:image|from_path", { path: e }).then((t) => new g(t));
+  }
+  /** Returns the RGBA data for this image, in row-major order from top to bottom.  */
+  async rgba() {
+    return n("plugin:image|rgba", {
+      rid: this.rid
+    }).then((e) => new Uint8Array(e));
+  }
+  /** Returns the size of this image.  */
+  async size() {
+    return n("plugin:image|size", { rid: this.rid });
+  }
+}
+function m(i) {
+  return i == null ? null : typeof i == "string" ? i : i instanceof g ? i.rid : i;
+}
+var x;
+(function(i) {
+  i[i.Critical = 1] = "Critical", i[i.Informational = 2] = "Informational";
+})(x || (x = {}));
+class se {
+  constructor(e) {
+    this._preventDefault = !1, this.event = e.event, this.id = e.id;
+  }
+  preventDefault() {
+    this._preventDefault = !0;
+  }
+  isPreventDefault() {
+    return this._preventDefault;
+  }
+}
+var k;
+(function(i) {
+  i.None = "none", i.Normal = "normal", i.Indeterminate = "indeterminate", i.Paused = "paused", i.Error = "error";
+})(k || (k = {}));
+function B() {
+  return new M(window.__TAURI_INTERNALS__.metadata.currentWindow.label, {
+    // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor
+    skip: !0
+  });
+}
+async function z() {
+  return n("plugin:window|get_all_windows").then((i) => i.map((e) => new M(e, {
+    // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor
+    skip: !0
+  })));
+}
+const S = ["tauri://created", "tauri://error"];
+class M {
+  /**
+   * Creates a new Window.
+   * @example
+   * ```typescript
+   * import { Window } from '@tauri-apps/api/window';
+   * const appWindow = new Window('my-label');
+   * appWindow.once('tauri://created', function () {
+   *  // window successfully created
+   * });
+   * appWindow.once('tauri://error', function (e) {
+   *  // an error happened creating the window
+   * });
+   * ```
+   *
+   * @param label The unique window label. Must be alphanumeric: `a-zA-Z-/:_`.
+   * @returns The {@link Window} instance to communicate with the window.
+   */
+  constructor(e, t = {}) {
+    var l;
+    this.label = e, this.listeners = /* @__PURE__ */ Object.create(null), t?.skip || n("plugin:window|create", {
+      options: {
+        ...t,
+        parent: typeof t.parent == "string" ? t.parent : (l = t.parent) === null || l === void 0 ? void 0 : l.label,
+        label: e
+      }
+    }).then(async () => this.emit("tauri://created")).catch(async (s) => this.emit("tauri://error", s));
+  }
+  /**
+   * Gets the Window associated with the given label.
+   * @example
+   * ```typescript
+   * import { Window } from '@tauri-apps/api/window';
+   * const mainWindow = Window.getByLabel('main');
+   * ```
+   *
+   * @param label The window label.
+   * @returns The Window instance to communicate with the window or null if the window doesn't exist.
+   */
+  static async getByLabel(e) {
+    var t;
+    return (t = (await z()).find((l) => l.label === e)) !== null && t !== void 0 ? t : null;
+  }
+  /**
+   * Get an instance of `Window` for the current window.
+   */
+  static getCurrent() {
+    return B();
+  }
+  /**
+   * Gets a list of instances of `Window` for all available windows.
+   */
+  static async getAll() {
+    return z();
+  }
+  /**
+   *  Gets the focused window.
+   * @example
+   * ```typescript
+   * import { Window } from '@tauri-apps/api/window';
+   * const focusedWindow = Window.getFocusedWindow();
+   * ```
+   *
+   * @returns The Window instance or `undefined` if there is not any focused window.
+   */
+  static async getFocusedWindow() {
+    for (const e of await z())
+      if (await e.isFocused())
+        return e;
+    return null;
+  }
+  /**
+   * Listen to an emitted event on this window.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const unlisten = await getCurrentWindow().listen<string>('state-changed', (event) => {
+   *   console.log(`Got error: ${payload}`);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`.
+   * @param handler Event handler.
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async listen(e, t) {
+    return this._handleTauriEvent(e, t) ? () => {
+      const l = this.listeners[e];
+      l.splice(l.indexOf(t), 1);
+    } : T(e, t, {
+      target: { kind: "Window", label: this.label }
+    });
+  }
+  /**
+   * Listen to an emitted event on this window only once.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const unlisten = await getCurrentWindow().once<null>('initialized', (event) => {
+   *   console.log(`Window initialized!`);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`.
+   * @param handler Event handler.
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async once(e, t) {
+    return this._handleTauriEvent(e, t) ? () => {
+      const l = this.listeners[e];
+      l.splice(l.indexOf(t), 1);
+    } : te(e, t, {
+      target: { kind: "Window", label: this.label }
+    });
+  }
+  /**
+   * Emits an event to all {@link EventTarget|targets}.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().emit('window-loaded', { loggedIn: true, token: 'authToken' });
+   * ```
+   *
+   * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`.
+   * @param payload Event payload.
+   */
+  async emit(e, t) {
+    if (S.includes(e)) {
+      for (const l of this.listeners[e] || [])
+        l({
+          event: e,
+          id: -1,
+          payload: t
+        });
+      return;
+    }
+    return ne(e, t);
+  }
+  /**
+   * Emits an event to all {@link EventTarget|targets} matching the given target.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().emit('main', 'window-loaded', { loggedIn: true, token: 'authToken' });
+   * ```
+   * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object.
+   * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`.
+   * @param payload Event payload.
+   */
+  async emitTo(e, t, l) {
+    if (S.includes(t)) {
+      for (const s of this.listeners[t] || [])
+        s({
+          event: t,
+          id: -1,
+          payload: l
+        });
+      return;
+    }
+    return le(e, t, l);
+  }
+  /** @ignore */
+  _handleTauriEvent(e, t) {
+    return S.includes(e) ? (e in this.listeners ? this.listeners[e].push(t) : this.listeners[e] = [t], !0) : !1;
+  }
+  // Getters
+  /**
+   * The scale factor that can be used to map physical pixels to logical pixels.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const factor = await getCurrentWindow().scaleFactor();
+   * ```
+   *
+   * @returns The window's monitor scale factor.
+   */
+  async scaleFactor() {
+    return n("plugin:window|scale_factor", {
+      label: this.label
+    });
+  }
+  /**
+   * The position of the top-left hand corner of the window's client area relative to the top-left hand corner of the desktop.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const position = await getCurrentWindow().innerPosition();
+   * ```
+   *
+   * @returns The window's inner position.
+   */
+  async innerPosition() {
+    return n("plugin:window|inner_position", {
+      label: this.label
+    }).then((e) => new c(e));
+  }
+  /**
+   * The position of the top-left hand corner of the window relative to the top-left hand corner of the desktop.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const position = await getCurrentWindow().outerPosition();
+   * ```
+   *
+   * @returns The window's outer position.
+   */
+  async outerPosition() {
+    return n("plugin:window|outer_position", {
+      label: this.label
+    }).then((e) => new c(e));
+  }
+  /**
+   * The physical size of the window's client area.
+   * The client area is the content of the window, excluding the title bar and borders.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const size = await getCurrentWindow().innerSize();
+   * ```
+   *
+   * @returns The window's inner size.
+   */
+  async innerSize() {
+    return n("plugin:window|inner_size", {
+      label: this.label
+    }).then((e) => new b(e));
+  }
+  /**
+   * The physical size of the entire window.
+   * These dimensions include the title bar and borders. If you don't want that (and you usually don't), use inner_size instead.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const size = await getCurrentWindow().outerSize();
+   * ```
+   *
+   * @returns The window's outer size.
+   */
+  async outerSize() {
+    return n("plugin:window|outer_size", {
+      label: this.label
+    }).then((e) => new b(e));
+  }
+  /**
+   * Gets the window's current fullscreen state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const fullscreen = await getCurrentWindow().isFullscreen();
+   * ```
+   *
+   * @returns Whether the window is in fullscreen mode or not.
+   */
+  async isFullscreen() {
+    return n("plugin:window|is_fullscreen", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current minimized state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const minimized = await getCurrentWindow().isMinimized();
+   * ```
+   */
+  async isMinimized() {
+    return n("plugin:window|is_minimized", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current maximized state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const maximized = await getCurrentWindow().isMaximized();
+   * ```
+   *
+   * @returns Whether the window is maximized or not.
+   */
+  async isMaximized() {
+    return n("plugin:window|is_maximized", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current focus state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const focused = await getCurrentWindow().isFocused();
+   * ```
+   *
+   * @returns Whether the window is focused or not.
+   */
+  async isFocused() {
+    return n("plugin:window|is_focused", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current decorated state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const decorated = await getCurrentWindow().isDecorated();
+   * ```
+   *
+   * @returns Whether the window is decorated or not.
+   */
+  async isDecorated() {
+    return n("plugin:window|is_decorated", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current resizable state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const resizable = await getCurrentWindow().isResizable();
+   * ```
+   *
+   * @returns Whether the window is resizable or not.
+   */
+  async isResizable() {
+    return n("plugin:window|is_resizable", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's native maximize button state.
+   *
+   * #### Platform-specific
+   *
+   * - **Linux / iOS / Android:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const maximizable = await getCurrentWindow().isMaximizable();
+   * ```
+   *
+   * @returns Whether the window's native maximize button is enabled or not.
+   */
+  async isMaximizable() {
+    return n("plugin:window|is_maximizable", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's native minimize button state.
+   *
+   * #### Platform-specific
+   *
+   * - **Linux / iOS / Android:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const minimizable = await getCurrentWindow().isMinimizable();
+   * ```
+   *
+   * @returns Whether the window's native minimize button is enabled or not.
+   */
+  async isMinimizable() {
+    return n("plugin:window|is_minimizable", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's native close button state.
+   *
+   * #### Platform-specific
+   *
+   * - **iOS / Android:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const closable = await getCurrentWindow().isClosable();
+   * ```
+   *
+   * @returns Whether the window's native close button is enabled or not.
+   */
+  async isClosable() {
+    return n("plugin:window|is_closable", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current visible state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const visible = await getCurrentWindow().isVisible();
+   * ```
+   *
+   * @returns Whether the window is visible or not.
+   */
+  async isVisible() {
+    return n("plugin:window|is_visible", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current title.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const title = await getCurrentWindow().title();
+   * ```
+   */
+  async title() {
+    return n("plugin:window|title", {
+      label: this.label
+    });
+  }
+  /**
+   * Gets the window's current theme.
+   *
+   * #### Platform-specific
+   *
+   * - **macOS:** Theme was introduced on macOS 10.14. Returns `light` on macOS 10.13 and below.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const theme = await getCurrentWindow().theme();
+   * ```
+   *
+   * @returns The window theme.
+   */
+  async theme() {
+    return n("plugin:window|theme", {
+      label: this.label
+    });
+  }
+  /**
+   * Whether the window is configured to be always on top of other windows or not.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * const alwaysOnTop = await getCurrentWindow().isAlwaysOnTop();
+   * ```
+   *
+   * @returns Whether the window is visible or not.
+   */
+  async isAlwaysOnTop() {
+    return n("plugin:window|is_always_on_top", {
+      label: this.label
+    });
+  }
+  // Setters
+  /**
+   * Centers the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().center();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async center() {
+    return n("plugin:window|center", {
+      label: this.label
+    });
+  }
+  /**
+   *  Requests user attention to the window, this has no effect if the application
+   * is already focused. How requesting for user attention manifests is platform dependent,
+   * see `UserAttentionType` for details.
+   *
+   * Providing `null` will unset the request for user attention. Unsetting the request for
+   * user attention might not be done automatically by the WM when the window receives input.
+   *
+   * #### Platform-specific
+   *
+   * - **macOS:** `null` has no effect.
+   * - **Linux:** Urgency levels have the same effect.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().requestUserAttention();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async requestUserAttention(e) {
+    let t = null;
+    return e && (e === x.Critical ? t = { type: "Critical" } : t = { type: "Informational" }), n("plugin:window|request_user_attention", {
+      label: this.label,
+      value: t
+    });
+  }
+  /**
+   * Updates the window resizable flag.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setResizable(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setResizable(e) {
+    return n("plugin:window|set_resizable", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Enable or disable the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setEnabled(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   *
+   * @since 2.0.0
+   */
+  async setEnabled(e) {
+    return n("plugin:window|set_enabled", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Whether the window is enabled or disabled.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setEnabled(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   *
+   * @since 2.0.0
+   */
+  async isEnabled() {
+    return n("plugin:window|is_enabled", {
+      label: this.label
+    });
+  }
+  /**
+   * Sets whether the window's native maximize button is enabled or not.
+   * If resizable is set to false, this setting is ignored.
+   *
+   * #### Platform-specific
+   *
+   * - **macOS:** Disables the "zoom" button in the window titlebar, which is also used to enter fullscreen mode.
+   * - **Linux / iOS / Android:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setMaximizable(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setMaximizable(e) {
+    return n("plugin:window|set_maximizable", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets whether the window's native minimize button is enabled or not.
+   *
+   * #### Platform-specific
+   *
+   * - **Linux / iOS / Android:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setMinimizable(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setMinimizable(e) {
+    return n("plugin:window|set_minimizable", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets whether the window's native close button is enabled or not.
+   *
+   * #### Platform-specific
+   *
+   * - **Linux:** GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible
+   * - **iOS / Android:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setClosable(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setClosable(e) {
+    return n("plugin:window|set_closable", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the window title.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setTitle('Tauri');
+   * ```
+   *
+   * @param title The new title
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setTitle(e) {
+    return n("plugin:window|set_title", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Maximizes the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().maximize();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async maximize() {
+    return n("plugin:window|maximize", {
+      label: this.label
+    });
+  }
+  /**
+   * Unmaximizes the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().unmaximize();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async unmaximize() {
+    return n("plugin:window|unmaximize", {
+      label: this.label
+    });
+  }
+  /**
+   * Toggles the window maximized state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().toggleMaximize();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async toggleMaximize() {
+    return n("plugin:window|toggle_maximize", {
+      label: this.label
+    });
+  }
+  /**
+   * Minimizes the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().minimize();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async minimize() {
+    return n("plugin:window|minimize", {
+      label: this.label
+    });
+  }
+  /**
+   * Unminimizes the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().unminimize();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async unminimize() {
+    return n("plugin:window|unminimize", {
+      label: this.label
+    });
+  }
+  /**
+   * Sets the window visibility to true.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().show();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async show() {
+    return n("plugin:window|show", {
+      label: this.label
+    });
+  }
+  /**
+   * Sets the window visibility to false.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().hide();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async hide() {
+    return n("plugin:window|hide", {
+      label: this.label
+    });
+  }
+  /**
+   * Closes the window.
+   *
+   * Note this emits a closeRequested event so you can intercept it. To force window close, use {@link Window.destroy}.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().close();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async close() {
+    return n("plugin:window|close", {
+      label: this.label
+    });
+  }
+  /**
+   * Destroys the window. Behaves like {@link Window.close} but forces the window close instead of emitting a closeRequested event.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().destroy();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async destroy() {
+    return n("plugin:window|destroy", {
+      label: this.label
+    });
+  }
+  /**
+   * Whether the window should have borders and bars.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setDecorations(false);
+   * ```
+   *
+   * @param decorations Whether the window should have borders and bars.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setDecorations(e) {
+    return n("plugin:window|set_decorations", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Whether or not the window should have shadow.
+   *
+   * #### Platform-specific
+   *
+   * - **Windows:**
+   *   - `false` has no effect on decorated window, shadows are always ON.
+   *   - `true` will make undecorated window have a 1px white border,
+   * and on Windows 11, it will have a rounded corners.
+   * - **Linux:** Unsupported.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setShadow(false);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setShadow(e) {
+    return n("plugin:window|set_shadow", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Set window effects.
+   */
+  async setEffects(e) {
+    return n("plugin:window|set_effects", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Clear any applied effects if possible.
+   */
+  async clearEffects() {
+    return n("plugin:window|set_effects", {
+      label: this.label,
+      value: null
+    });
+  }
+  /**
+   * Whether the window should always be on top of other windows.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setAlwaysOnTop(true);
+   * ```
+   *
+   * @param alwaysOnTop Whether the window should always be on top of other windows or not.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setAlwaysOnTop(e) {
+    return n("plugin:window|set_always_on_top", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Whether the window should always be below other windows.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setAlwaysOnBottom(true);
+   * ```
+   *
+   * @param alwaysOnBottom Whether the window should always be below other windows or not.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setAlwaysOnBottom(e) {
+    return n("plugin:window|set_always_on_bottom", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Prevents the window contents from being captured by other apps.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setContentProtected(true);
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setContentProtected(e) {
+    return n("plugin:window|set_content_protected", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Resizes the window with a new inner size.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setSize(new LogicalSize(600, 500));
+   * ```
+   *
+   * @param size The logical or physical inner size.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setSize(e) {
+    return n("plugin:window|set_size", {
+      label: this.label,
+      value: e instanceof w ? e : new w(e)
+    });
+  }
+  /**
+   * Sets the window minimum inner size. If the `size` argument is not provided, the constraint is unset.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow, PhysicalSize } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setMinSize(new PhysicalSize(600, 500));
+   * ```
+   *
+   * @param size The logical or physical inner size, or `null` to unset the constraint.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setMinSize(e) {
+    return n("plugin:window|set_min_size", {
+      label: this.label,
+      value: e instanceof w ? e : e ? new w(e) : null
+    });
+  }
+  /**
+   * Sets the window maximum inner size. If the `size` argument is undefined, the constraint is unset.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setMaxSize(new LogicalSize(600, 500));
+   * ```
+   *
+   * @param size The logical or physical inner size, or `null` to unset the constraint.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setMaxSize(e) {
+    return n("plugin:window|set_max_size", {
+      label: this.label,
+      value: e instanceof w ? e : e ? new w(e) : null
+    });
+  }
+  /**
+   * Sets the window inner size constraints.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setSizeConstraints({ minWidth: 300 });
+   * ```
+   *
+   * @param constraints The logical or physical inner size, or `null` to unset the constraint.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setSizeConstraints(e) {
+    function t(l) {
+      return l ? { Logical: l } : null;
+    }
+    return n("plugin:window|set_size_constraints", {
+      label: this.label,
+      value: {
+        minWidth: t(e?.minWidth),
+        minHeight: t(e?.minHeight),
+        maxWidth: t(e?.maxWidth),
+        maxHeight: t(e?.maxHeight)
+      }
+    });
+  }
+  /**
+   * Sets the window outer position.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setPosition(new LogicalPosition(600, 500));
+   * ```
+   *
+   * @param position The new position, in logical or physical pixels.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setPosition(e) {
+    return n("plugin:window|set_position", {
+      label: this.label,
+      value: e instanceof _ ? e : new _(e)
+    });
+  }
+  /**
+   * Sets the window fullscreen state.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setFullscreen(true);
+   * ```
+   *
+   * @param fullscreen Whether the window should go to fullscreen or not.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setFullscreen(e) {
+    return n("plugin:window|set_fullscreen", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * On macOS, Toggles a fullscreen mode that doesn’t require a new macOS space. Returns a boolean indicating whether the transition was successful (this won’t work if the window was already in the native fullscreen).
+   * This is how fullscreen used to work on macOS in versions before Lion. And allows the user to have a fullscreen window without using another space or taking control over the entire monitor.
+   *
+   * On other platforms, this is the same as {@link Window.setFullscreen}.
+   *
+   * @param fullscreen Whether the window should go to simple fullscreen or not.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setSimpleFullscreen(e) {
+    return n("plugin:window|set_simple_fullscreen", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Bring the window to front and focus.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setFocus();
+   * ```
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setFocus() {
+    return n("plugin:window|set_focus", {
+      label: this.label
+    });
+  }
+  /**
+   * Sets whether the window can be focused.
+   *
+   * #### Platform-specific
+   *
+   * - **macOS**: If the window is already focused, it is not possible to unfocus it after calling `set_focusable(false)`.
+   *   In this case, you might consider calling {@link Window.setFocus} but it will move the window to the back i.e. at the bottom in terms of z-order.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setFocusable(true);
+   * ```
+   *
+   * @param focusable Whether the window can be focused.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setFocusable(e) {
+    return n("plugin:window|set_focusable", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the window icon.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setIcon('/tauri/awesome.png');
+   * ```
+   *
+   * Note that you may need the `image-ico` or `image-png` Cargo features to use this API.
+   * To enable it, change your Cargo.toml file:
+   * ```toml
+   * [dependencies]
+   * tauri = { version = "...", features = ["...", "image-png"] }
+   * ```
+   *
+   * @param icon Icon bytes or path to the icon file.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setIcon(e) {
+    return n("plugin:window|set_icon", {
+      label: this.label,
+      value: m(e)
+    });
+  }
+  /**
+   * Whether the window icon should be hidden from the taskbar or not.
+   *
+   * #### Platform-specific
+   *
+   * - **macOS:** Unsupported.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setSkipTaskbar(true);
+   * ```
+   *
+   * @param skip true to hide window icon, false to show it.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setSkipTaskbar(e) {
+    return n("plugin:window|set_skip_taskbar", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Grabs the cursor, preventing it from leaving the window.
+   *
+   * There's no guarantee that the cursor will be hidden. You should
+   * hide it by yourself if you want so.
+   *
+   * #### Platform-specific
+   *
+   * - **Linux:** Unsupported.
+   * - **macOS:** This locks the cursor in a fixed location, which looks visually awkward.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setCursorGrab(true);
+   * ```
+   *
+   * @param grab `true` to grab the cursor icon, `false` to release it.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setCursorGrab(e) {
+    return n("plugin:window|set_cursor_grab", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Modifies the cursor's visibility.
+   *
+   * #### Platform-specific
+   *
+   * - **Windows:** The cursor is only hidden within the confines of the window.
+   * - **macOS:** The cursor is hidden as long as the window has input focus, even if the cursor is
+   *   outside of the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setCursorVisible(false);
+   * ```
+   *
+   * @param visible If `false`, this will hide the cursor. If `true`, this will show the cursor.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setCursorVisible(e) {
+    return n("plugin:window|set_cursor_visible", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Modifies the cursor icon of the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setCursorIcon('help');
+   * ```
+   *
+   * @param icon The new cursor icon.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setCursorIcon(e) {
+    return n("plugin:window|set_cursor_icon", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the window background color.
+   *
+   * #### Platform-specific:
+   *
+   * - **Windows:** alpha channel is ignored.
+   * - **iOS / Android:** Unsupported.
+   *
+   * @returns A promise indicating the success or failure of the operation.
+   *
+   * @since 2.1.0
+   */
+  async setBackgroundColor(e) {
+    return n("plugin:window|set_background_color", { color: e });
+  }
+  /**
+   * Changes the position of the cursor in window coordinates.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setCursorPosition(new LogicalPosition(600, 300));
+   * ```
+   *
+   * @param position The new cursor position.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setCursorPosition(e) {
+    return n("plugin:window|set_cursor_position", {
+      label: this.label,
+      value: e instanceof _ ? e : new _(e)
+    });
+  }
+  /**
+   * Changes the cursor events behavior.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setIgnoreCursorEvents(true);
+   * ```
+   *
+   * @param ignore `true` to ignore the cursor events; `false` to process them as usual.
+   * @returns A promise indicating the success or failure of the operation.
+   */
+  async setIgnoreCursorEvents(e) {
+    return n("plugin:window|set_ignore_cursor_events", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Starts dragging the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().startDragging();
+   * ```
+   *
+   * @return A promise indicating the success or failure of the operation.
+   */
+  async startDragging() {
+    return n("plugin:window|start_dragging", {
+      label: this.label
+    });
+  }
+  /**
+   * Starts resize-dragging the window.
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().startResizeDragging();
+   * ```
+   *
+   * @return A promise indicating the success or failure of the operation.
+   */
+  async startResizeDragging(e) {
+    return n("plugin:window|start_resize_dragging", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the badge count. It is app wide and not specific to this window.
+   *
+   * #### Platform-specific
+   *
+   * - **Windows**: Unsupported. Use @{linkcode Window.setOverlayIcon} instead.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setBadgeCount(5);
+   * ```
+   *
+   * @param count The badge count. Use `undefined` to remove the badge.
+   * @return A promise indicating the success or failure of the operation.
+   */
+  async setBadgeCount(e) {
+    return n("plugin:window|set_badge_count", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the badge cont **macOS only**.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setBadgeLabel("Hello");
+   * ```
+   *
+   * @param label The badge label. Use `undefined` to remove the badge.
+   * @return A promise indicating the success or failure of the operation.
+   */
+  async setBadgeLabel(e) {
+    return n("plugin:window|set_badge_label", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the overlay icon. **Windows only**
+   * The overlay icon can be set for every window.
+   *
+   *
+   * Note that you may need the `image-ico` or `image-png` Cargo features to use this API.
+   * To enable it, change your Cargo.toml file:
+   *
+   * ```toml
+   * [dependencies]
+   * tauri = { version = "...", features = ["...", "image-png"] }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setOverlayIcon("/tauri/awesome.png");
+   * ```
+   *
+   * @param icon Icon bytes or path to the icon file. Use `undefined` to remove the overlay icon.
+   * @return A promise indicating the success or failure of the operation.
+   */
+  async setOverlayIcon(e) {
+    return n("plugin:window|set_overlay_icon", {
+      label: this.label,
+      value: e ? m(e) : void 0
+    });
+  }
+  /**
+   * Sets the taskbar progress state.
+   *
+   * #### Platform-specific
+   *
+   * - **Linux / macOS**: Progress bar is app-wide and not specific to this window.
+   * - **Linux**: Only supported desktop environments with `libunity` (e.g. GNOME).
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow, ProgressBarStatus } from '@tauri-apps/api/window';
+   * await getCurrentWindow().setProgressBar({
+   *   status: ProgressBarStatus.Normal,
+   *   progress: 50,
+   * });
+   * ```
+   *
+   * @return A promise indicating the success or failure of the operation.
+   */
+  async setProgressBar(e) {
+    return n("plugin:window|set_progress_bar", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets whether the window should be visible on all workspaces or virtual desktops.
+   *
+   * #### Platform-specific
+   *
+   * - **Windows / iOS / Android:** Unsupported.
+   *
+   * @since 2.0.0
+   */
+  async setVisibleOnAllWorkspaces(e) {
+    return n("plugin:window|set_visible_on_all_workspaces", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Sets the title bar style. **macOS only**.
+   *
+   * @since 2.0.0
+   */
+  async setTitleBarStyle(e) {
+    return n("plugin:window|set_title_bar_style", {
+      label: this.label,
+      value: e
+    });
+  }
+  /**
+   * Set window theme, pass in `null` or `undefined` to follow system theme
+   *
+   * #### Platform-specific
+   *
+   * - **Linux / macOS**: Theme is app-wide and not specific to this window.
+   * - **iOS / Android:** Unsupported.
+   *
+   * @since 2.0.0
+   */
+  async setTheme(e) {
+    return n("plugin:window|set_theme", {
+      label: this.label,
+      value: e
+    });
+  }
+  // Listeners
+  /**
+   * Listen to window resize.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/window";
+   * const unlisten = await getCurrentWindow().onResized(({ payload: size }) => {
+   *  console.log('Window resized', size);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onResized(e) {
+    return this.listen(r.WINDOW_RESIZED, (t) => {
+      t.payload = new b(t.payload), e(t);
+    });
+  }
+  /**
+   * Listen to window move.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/window";
+   * const unlisten = await getCurrentWindow().onMoved(({ payload: position }) => {
+   *  console.log('Window moved', position);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onMoved(e) {
+    return this.listen(r.WINDOW_MOVED, (t) => {
+      t.payload = new c(t.payload), e(t);
+    });
+  }
+  /**
+   * Listen to window close requested. Emitted when the user requests to closes the window.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/window";
+   * import { confirm } from '@tauri-apps/api/dialog';
+   * const unlisten = await getCurrentWindow().onCloseRequested(async (event) => {
+   *   const confirmed = await confirm('Are you sure?');
+   *   if (!confirmed) {
+   *     // user did not confirm closing the window; let's prevent it
+   *     event.preventDefault();
+   *   }
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onCloseRequested(e) {
+    return this.listen(r.WINDOW_CLOSE_REQUESTED, async (t) => {
+      const l = new se(t);
+      await e(l), l.isPreventDefault() || await this.destroy();
+    });
+  }
+  /**
+   * Listen to a file drop event.
+   * The listener is triggered when the user hovers the selected files on the webview,
+   * drops the files or cancels the operation.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/webview";
+   * const unlisten = await getCurrentWindow().onDragDropEvent((event) => {
+   *  if (event.payload.type === 'over') {
+   *    console.log('User hovering', event.payload.position);
+   *  } else if (event.payload.type === 'drop') {
+   *    console.log('User dropped', event.payload.paths);
+   *  } else {
+   *    console.log('File drop cancelled');
+   *  }
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onDragDropEvent(e) {
+    const t = await this.listen(r.DRAG_ENTER, (a) => {
+      e({
+        ...a,
+        payload: {
+          type: "enter",
+          paths: a.payload.paths,
+          position: new c(a.payload.position)
+        }
+      });
+    }), l = await this.listen(r.DRAG_OVER, (a) => {
+      e({
+        ...a,
+        payload: {
+          type: "over",
+          position: new c(a.payload.position)
+        }
+      });
+    }), s = await this.listen(r.DRAG_DROP, (a) => {
+      e({
+        ...a,
+        payload: {
+          type: "drop",
+          paths: a.payload.paths,
+          position: new c(a.payload.position)
+        }
+      });
+    }), d = await this.listen(r.DRAG_LEAVE, (a) => {
+      e({ ...a, payload: { type: "leave" } });
+    });
+    return () => {
+      t(), s(), l(), d();
+    };
+  }
+  /**
+   * Listen to window focus change.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/window";
+   * const unlisten = await getCurrentWindow().onFocusChanged(({ payload: focused }) => {
+   *  console.log('Focus changed, window is focused? ' + focused);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onFocusChanged(e) {
+    const t = await this.listen(r.WINDOW_FOCUS, (s) => {
+      e({ ...s, payload: !0 });
+    }), l = await this.listen(r.WINDOW_BLUR, (s) => {
+      e({ ...s, payload: !1 });
+    });
+    return () => {
+      t(), l();
+    };
+  }
+  /**
+   * Listen to window scale change. Emitted when the window's scale factor has changed.
+   * The following user actions can cause DPI changes:
+   * - Changing the display's resolution.
+   * - Changing the display's scale factor (e.g. in Control Panel on Windows).
+   * - Moving the window to a display with a different scale factor.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/window";
+   * const unlisten = await getCurrentWindow().onScaleChanged(({ payload }) => {
+   *  console.log('Scale changed', payload.scaleFactor, payload.size);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onScaleChanged(e) {
+    return this.listen(r.WINDOW_SCALE_FACTOR_CHANGED, e);
+  }
+  /**
+   * Listen to the system theme change.
+   *
+   * @example
+   * ```typescript
+   * import { getCurrentWindow } from "@tauri-apps/api/window";
+   * const unlisten = await getCurrentWindow().onThemeChanged(({ payload: theme }) => {
+   *  console.log('New theme: ' + theme);
+   * });
+   *
+   * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted
+   * unlisten();
+   * ```
+   *
+   * @returns A promise resolving to a function to unlisten to the event.
+   * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted.
+   */
+  async onThemeChanged(e) {
+    return this.listen(r.WINDOW_THEME_CHANGED, e);
+  }
+}
+var O;
+(function(i) {
+  i.Disabled = "disabled", i.Throttle = "throttle", i.Suspend = "suspend";
+})(O || (O = {}));
+var A;
+(function(i) {
+  i.AppearanceBased = "appearanceBased", i.Light = "light", i.Dark = "dark", i.MediumLight = "mediumLight", i.UltraDark = "ultraDark", i.Titlebar = "titlebar", i.Selection = "selection", i.Menu = "menu", i.Popover = "popover", i.Sidebar = "sidebar", i.HeaderView = "headerView", i.Sheet = "sheet", i.WindowBackground = "windowBackground", i.HudWindow = "hudWindow", i.FullScreenUI = "fullScreenUI", i.Tooltip = "tooltip", i.ContentBackground = "contentBackground", i.UnderWindowBackground = "underWindowBackground", i.UnderPageBackground = "underPageBackground", i.Mica = "mica", i.Blur = "blur", i.Acrylic = "acrylic", i.Tabbed = "tabbed", i.TabbedDark = "tabbedDark", i.TabbedLight = "tabbedLight";
+})(A || (A = {}));
+var N;
+(function(i) {
+  i.FollowsWindowActiveState = "followsWindowActiveState", i.Active = "active", i.Inactive = "inactive";
+})(N || (N = {}));
+async function ae(i) {
+  try {
+    return await n("plugin:vicons|get_icon", { name: i });
+  } catch (e) {
+    console.error("[Icon Error] Error obteniendo icono:", e);
+  }
+  return "";
+}
+function re(i) {
+  try {
+    const e = atob(i.substring(0, 32)), t = new Uint8Array(e.length);
+    for (let l = 0; l < e.length; l++)
+      t[l] = e.charCodeAt(l);
+    return t[0] === 137 && t[1] === 80 && t[2] === 78 && t[3] === 71 ? "image/png" : "image/svg+xml";
+  } catch (e) {
+    return console.error("Error identificando tipo de imagen:", e), "image/png";
+  }
+}
+async function W(i) {
+  try {
+    const e = await ae(i);
+    return `data:${re(e)};base64,${e}`;
+  } catch (e) {
+    return console.error("[Icon Error] Error obteniendo icono:", e), "";
+  }
+}
+const oe = { "data-tauri-drag-region": "" }, ue = ["src"], ce = { "data-tauri-drag-region": "" }, de = { "data-tauri-drag-region": "" }, he = ["src"], we = ["src"], be = ["src"], ge = /* @__PURE__ */ C({
+  __name: "TopBar",
+  props: {
+    title: String,
+    image: String
+  },
+  setup(i) {
+    const e = p(null), t = B(), l = p(""), s = p(""), d = p(""), a = i;
+    return F(async () => {
+      l.value = await W("window-close"), s.value = await W("window-minimize"), d.value = await W("window-maximize");
+    }), (ye, h) => (f(), v("div", {
+      "data-tauri-drag-region": "",
+      class: "flex h-8 px-4 py-1 bg-vsk-primary rounded-t-window justify-between align-center",
+      ref_key: "bar",
+      ref: e
+    }, [
+      u("div", oe, [
+        u("img", {
+          src: a.image,
+          "data-tauri-drag-region": "",
+          class: "h-6 w-auto"
+        }, null, 8, ue)
+      ]),
+      u("div", ce, U(a.title), 1),
+      u("div", de, [
+        u("span", {
+          class: "win-button",
+          onClick: h[0] || (h[0] = (I) => D(t).minimize())
+        }, [
+          u("img", {
+            src: s.value,
+            class: "h-6 w-6 inline-block",
+            alt: "Minimize"
+          }, null, 8, he)
+        ]),
+        u("span", {
+          class: "win-button",
+          onClick: h[1] || (h[1] = (I) => D(t).toggleMaximize())
+        }, [
+          u("img", {
+            src: d.value,
+            class: "h-6 w-6 inline-block",
+            alt: "Maximize"
+          }, null, 8, we)
+        ]),
+        u("span", {
+          class: "win-button",
+          onClick: h[2] || (h[2] = (I) => D(t).close())
+        }, [
+          u("img", {
+            src: l.value,
+            class: "h-6 w-6 inline-block",
+            alt: "Close"
+          }, null, 8, be)
+        ])
+      ])
+    ], 512));
+  }
+}), pe = /* @__PURE__ */ C({
+  __name: "WindowFrame",
+  props: {
+    title: {
+      type: String,
+      default: "Vasak"
+    },
+    image: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(i) {
+    const e = i;
+    return (t, l) => (f(), v(V, null, [
+      G(ge, {
+        title: e.title,
+        image: e.image
+      }, null, 8, ["title", "image"]),
+      R(t.$slots, "default")
+    ], 64));
+  }
+}), _e = [j, Y, pe], ve = {
+  install(i) {
+    _e.forEach((e) => {
+      i.component(e.name, e);
+    });
+  }
+};
+export {
+  j as SideBar,
+  Y as SideButton,
+  pe as WindowFrame,
+  ve as default
+};