@halo-dev/ui-shared 1.0.1 → 2.22.1

package/dist/index.d.ts

@@ -0,0 +1,1783 @@
+import { Attachment, Backup, DetailedUser, Extension, GetThumbnailByUriSizeEnum, ListedComment, ListedPost, ListedReply, ListedSinglePage, Plugin, Theme } from "@halo-dev/api-client";
+import * as pinia0 from "pinia";
+import * as vue0 from "vue";
+import { Component, Raw, Ref } from "vue";
+import * as mitt0 from "mitt";
+import { RouteLocationRaw, RouteRecordName, RouteRecordRaw } from "vue-router";
+import { AnyExtension } from "@halo-dev/richtext-editor";
+import _dayjs from "dayjs";
+
+//#region src/events/index.d.ts
+type Events = {
+  /**
+   * Emitted when a plugin's configuration map is updated.
+   */
+  "core:plugin:configMap:updated": {
+    pluginName: string;
+    group: string;
+  };
+};
+declare const events: mitt0.Emitter<Events>;
+//#endregion
+//#region src/plugin/types/attachment-selector.d.ts
+/**
+ * Represents a simplified attachment object with essential properties.
+ * Used for lightweight attachment representations without full API client dependencies.
+ */
+interface AttachmentSimple {
+  /**
+   * The URL of the attachment.
+   */
+  url: string;
+  /**
+   * The MIME type of the attachment (e.g., 'image/png', 'video/mp4').
+   */
+  mediaType?: string;
+  /**
+   * Alternative text for the attachment, used for accessibility.
+   */
+  alt?: string;
+  /**
+   * Caption or description for the attachment.
+   */
+  caption?: string;
+}
+/**
+ * Union type representing different forms of attachment references.
+ *
+ * @remarks
+ * This flexible type allows working with attachments in various formats:
+ * - Full `Attachment` object from the API client
+ * - Simplified `AttachmentSimple` object with basic properties
+ * - String URL directly referencing the attachment
+ */
+type AttachmentLike = Attachment | AttachmentSimple | string;
+/**
+ * Defines a custom attachment selector provider that plugins can register.
+ *
+ * @remarks
+ * Attachment selector providers allow plugins to create custom UI components
+ * for selecting attachments from different sources (e.g., local upload,
+ * external services, galleries, etc.).
+ */
+interface AttachmentSelectProvider {
+  /**
+   * Unique identifier for this attachment selector provider.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:selector-id').
+   */
+  id: string;
+  /**
+   * Display label for the attachment selector.
+   * This label will be shown in the UI where users can choose between different selectors.
+   */
+  label: string;
+  /**
+   * The Vue component that implements the attachment selection interface.
+   * Can be either a component definition or a component name string.
+   *
+   * @remarks
+   * The component should emit selected attachments through the provided callback
+   * or emit events that the parent component can handle.
+   */
+  component: Component | string;
+  /**
+   * Optional callback function invoked when attachments are selected.
+   *
+   * @param attachments - Array of selected attachments in various formats.
+   *
+   * @remarks
+   * This callback is triggered after the user confirms their selection.
+   * It allows the provider to handle post-selection logic like validation,
+   * transformation, or triggering additional actions.
+   */
+  callback?: (attachments: AttachmentLike[]) => void;
+}
+//#endregion
+//#region src/plugin/types/backup.d.ts
+/**
+ * Defines a custom tab for the backup management page.
+ *
+ * @remarks
+ * Backup tabs allow plugins to extend the backup interface with custom
+ * functionality such as cloud backup providers, automated backup schedules,
+ * or specialized restore operations.
+ */
+interface BackupTab {
+  /**
+   * Unique identifier for the backup tab.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:tab-id').
+   */
+  id: string;
+  /**
+   * Display label for the tab.
+   * This text will be shown in the tab navigation.
+   */
+  label: string;
+  /**
+   * The Vue component that renders the tab content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional array of permission identifiers required to view this tab.
+   * The tab will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+}
+//#endregion
+//#region src/plugin/types/comment.d.ts
+/**
+ * Represents the result of resolving a comment subject reference.
+ * Contains display information and navigation details for the commented content.
+ */
+interface CommentSubjectRefResult {
+  /**
+   * Short label or type identifier for the subject (e.g., 'Post', 'Page', 'Custom').
+   */
+  label: string;
+  /**
+   * The title or name of the content being commented on.
+   */
+  title: string;
+  /**
+   * Internal route location to navigate to the subject.
+   * Used for navigating within the Halo console.
+   */
+  route?: RouteLocationRaw;
+  /**
+   * External URL to the subject if it's hosted outside the console.
+   * Typically used for public-facing content.
+   */
+  externalUrl?: string;
+}
+/**
+ * Defines a provider that resolves comment subject references.
+ *
+ * @remarks
+ * Comment subject reference providers allow plugins to make their custom content types
+ * commentable. The provider resolves extension references into human-readable information
+ * that can be displayed in the comment management interface.
+ */
+type CommentSubjectRefProvider = {
+  /**
+   * The kind of the extension that this provider handles.
+   * Must match the `kind` field in the extension's metadata.
+   */
+  kind: string;
+  /**
+   * The API group of the extension that this provider handles.
+   * Must match the `group` field in the extension's metadata.
+   */
+  group: string;
+  /**
+   * Resolves an extension reference into displayable comment subject information.
+   *
+   * @param subject - The extension object representing the commented content.
+   * @returns The resolved subject information including label, title, and navigation details.
+   */
+  resolve: (subject: Extension) => CommentSubjectRefResult;
+};
+/**
+ * Defines a custom comment editor provider.
+ *
+ * @remarks
+ * Allows plugins to replace the default comment editor with a custom implementation.
+ * Useful for providing rich-text editing, markdown support, or specialized input methods.
+ */
+interface CommentEditorProvider {
+  /**
+   * The Vue component that implements the custom comment editor.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component should emit appropriate events for content changes and
+   * integrate with the parent form for submission handling.
+   */
+  component: Raw<Component>;
+}
+/**
+ * Defines a custom comment content renderer.
+ *
+ * @remarks
+ * Allows plugins to customize how comment content is displayed in comment lists.
+ * Useful when comments are stored in a custom format that requires special rendering.
+ */
+interface CommentContentProvider {
+  /**
+   * The Vue component that renders the comment content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component receives the comment content as props and should handle
+   * rendering, sanitization, and any interactive features.
+   */
+  component: Raw<Component>;
+}
+//#endregion
+//#region src/plugin/types/dashboard-widget.d.ts
+/**
+ * Defines responsive layout configurations for dashboard widgets across different screen sizes.
+ *
+ * @remarks
+ * Each breakpoint can have a different layout arrangement. If a breakpoint is not specified,
+ * it will fall back to the next larger breakpoint's layout.
+ */
+interface DashboardResponsiveLayout {
+  /**
+   * Layout for large screens (typically ≥ 1200px).
+   */
+  lg?: DashboardWidget[];
+  /**
+   * Layout for medium screens (typically ≥ 996px).
+   */
+  md?: DashboardWidget[];
+  /**
+   * Layout for small screens (typically ≥ 768px).
+   */
+  sm?: DashboardWidget[];
+  /**
+   * Layout for extra small screens (typically ≥ 480px).
+   */
+  xs?: DashboardWidget[];
+  /**
+   * Layout for double extra small screens (typically < 480px).
+   */
+  xxs?: DashboardWidget[];
+}
+/**
+ * Represents an instance of a dashboard widget with its position, size, and configuration.
+ *
+ * @remarks
+ * Dashboard widgets are arranged in a grid layout system. The grid typically has 12 columns,
+ * and widgets can span multiple rows and columns.
+ */
+interface DashboardWidget {
+  /**
+   * The x-coordinate (column position) in the grid, starting from 0.
+   */
+  x: number;
+  /**
+   * The y-coordinate (row position) in the grid, starting from 0.
+   */
+  y: number;
+  /**
+   * The width of the widget in grid columns.
+   */
+  w: number;
+  /**
+   * The height of the widget in grid rows.
+   */
+  h: number;
+  /**
+   * Unique identifier for this widget instance in the layout.
+   * Can be a number or string.
+   */
+  i: number | string;
+  /**
+   * Minimum width constraint in grid columns.
+   */
+  minW?: number;
+  /**
+   * Minimum height constraint in grid rows.
+   */
+  minH?: number;
+  /**
+   * Maximum width constraint in grid columns.
+   */
+  maxW?: number;
+  /**
+   * Maximum height constraint in grid rows.
+   */
+  maxH?: number;
+  /**
+   * Reference to the widget definition ID that this instance represents.
+   */
+  id: string;
+  /**
+   * User-specific configuration for this widget instance.
+   * The structure depends on the widget's definition schema.
+   */
+  config?: Record<string, unknown>;
+  /**
+   * Optional array of permission identifiers required to view this widget instance.
+   */
+  permissions?: string[];
+}
+/**
+ * Defines a dashboard widget type that can be added to the dashboard.
+ *
+ * @remarks
+ * Widget definitions serve as templates from which users can create widget instances.
+ * Each definition specifies the component, default configuration, and size constraints.
+ *
+ * @example
+ * ```typescript
+ * const widgetDef: DashboardWidgetDefinition = {
+ *   id: 'plugin-name:widget-id',
+ *   component: markRaw(MyWidgetComponent),
+ *   group: 'statistics',
+ *   defaultSize: { w: 4, h: 2, minW: 2, minH: 1 },
+ *   defaultConfig: { refreshInterval: 60000 },
+ *   configFormKitSchema: [
+ *     { $formkit: 'number', name: 'refreshInterval', label: 'Refresh Interval (ms)' }
+ *   ]
+ * };
+ * ```
+ */
+interface DashboardWidgetDefinition {
+  /**
+   * Unique identifier for the widget definition.
+   * Should follow a namespaced pattern (e.g., 'plugin-name:widget-id').
+   */
+  id: string;
+  /**
+   * The Vue component that renders the widget.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   */
+  component: Raw<Component>;
+  /**
+   * Category or group for organizing widgets in the selection interface.
+   * Common groups include 'statistics', 'content', 'system', etc.
+   */
+  group: string;
+  /**
+   * FormKit schema for the widget's configuration form.
+   * Can be an array, a function returning an array, or a function returning a Promise.
+   *
+   * @remarks
+   * Defines the editable settings that users can configure for widget instances.
+   * The schema uses FormKit's schema format.
+   */
+  configFormKitSchema?: Record<string, unknown>[] | (() => Promise<Record<string, unknown>[]>) | (() => Record<string, unknown>[]);
+  /**
+   * Default configuration values for new widget instances.
+   * These values will be used when a user first adds the widget to their dashboard.
+   */
+  defaultConfig?: Record<string, unknown>;
+  /**
+   * Default size and constraints for the widget.
+   *
+   * @remarks
+   * Specifies the initial dimensions and any size limitations when the widget is added.
+   */
+  defaultSize: {
+    /**
+     * Default width in grid columns.
+     */
+    w: number;
+    /**
+     * Default height in grid rows.
+     */
+    h: number;
+    /**
+     * Minimum width constraint in grid columns.
+     */
+    minW?: number;
+    /**
+     * Minimum height constraint in grid rows.
+     */
+    minH?: number;
+    /**
+     * Maximum width constraint in grid columns.
+     */
+    maxW?: number;
+    /**
+     * Maximum height constraint in grid rows.
+     */
+    maxH?: number;
+  };
+  /**
+   * Optional array of permission identifiers required to add or view this widget.
+   */
+  permissions?: string[];
+}
+/**
+ * Base interface for dashboard widget quick action items.
+ */
+interface DashboardWidgetQuickActionBaseItem {
+  /**
+   * Unique identifier for the quick action.
+   */
+  id: string;
+  /**
+   * Optional array of permission identifiers required to see this action.
+   */
+  permissions?: string[];
+}
+/**
+ * A quick action item that uses a custom component for rendering.
+ * Provides maximum flexibility for complex action UI.
+ */
+interface DashboardWidgetQuickActionComponentItem extends DashboardWidgetQuickActionBaseItem {
+  /**
+   * Custom Vue component for rendering the quick action.
+   * When provided, standard properties (icon, title, action) are optional.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional icon component displayed alongside the action.
+   */
+  icon?: Raw<Component>;
+  /**
+   * Optional title text for the action.
+   */
+  title?: string;
+  /**
+   * Optional click handler for the action.
+   */
+  action?: () => void;
+}
+/**
+ * A standard quick action item with icon, title, and action handler.
+ * Uses the default rendering style for consistency.
+ */
+interface DashboardWidgetQuickActionStandardItem extends DashboardWidgetQuickActionBaseItem {
+  /**
+   * Cannot provide a custom component for standard items.
+   */
+  component?: never;
+  /**
+   * Icon component displayed with the action (required for standard items).
+   */
+  icon: Raw<Component>;
+  /**
+   * Display title for the action (required for standard items).
+   */
+  title: string;
+  /**
+   * Click handler invoked when the action is triggered (required for standard items).
+   */
+  action: () => void;
+}
+/**
+ * A quick action item that navigates to a route when triggered.
+ */
+interface DashboardWidgetQuickActionRouteItem extends DashboardWidgetQuickActionBaseItem {
+  /**
+   * Cannot provide a custom component for route items.
+   */
+  component?: never;
+  /**
+   * Cannot provide an action handler for route items.
+   */
+  action?: never;
+  /**
+   * Icon component displayed with the action (required for route items).
+   */
+  icon: Raw<Component>;
+  /**
+   * Display title for the action (required for route items).
+   */
+  title: string;
+  /**
+   * Route to navigate to when the action is triggered (required for route items).
+   */
+  route: RouteLocationRaw;
+}
+/**
+ * Represents a quick action button that can be added to dashboard widgets.
+ *
+ * @remarks
+ * Quick actions provide shortcuts to common operations directly from the dashboard.
+ * They can either use a custom component for full control or follow the standard
+ * pattern with an icon, title, and action handler.
+ */
+type DashboardWidgetQuickActionItem = DashboardWidgetQuickActionComponentItem | DashboardWidgetQuickActionStandardItem | DashboardWidgetQuickActionRouteItem;
+//#endregion
+//#region src/plugin/types/editor-provider.d.ts
+/**
+ * Defines a custom content editor provider.
+ *
+ * @remarks
+ * Editor providers allow plugins to register alternative content editors beyond
+ * the default editor. This enables support for different content formats, editing
+ * experiences, and specialized workflows (e.g., Markdown, rich-text, code, visual builders).
+ *
+ * @example
+ * ```typescript
+ * const markdownEditor: EditorProvider = {
+ *   name: 'markdown-editor',
+ *   displayName: 'Markdown Editor',
+ *   logo: '/path/to/markdown-logo.svg',
+ *   component: MarkdownEditorComponent,
+ *   rawType: 'markdown'
+ * };
+ * ```
+ */
+interface EditorProvider {
+  /**
+   * Unique identifier for the editor provider.
+   * Should use kebab-case naming (e.g., 'markdown-editor', 'wysiwyg-editor').
+   */
+  name: string;
+  /**
+   * Human-readable display name shown in the editor selection UI.
+   */
+  displayName: string;
+  /**
+   * Optional URL or path to the editor's logo image.
+   * Displayed in the editor selection interface for visual identification.
+   */
+  logo?: string;
+  /**
+   * The Vue component that implements the editor interface.
+   *
+   * @remarks
+   * The component should handle content editing, emit appropriate events for
+   * content changes, and integrate with the parent form for validation and submission.
+   */
+  component: Component;
+  /**
+   * The content format or MIME type that this editor produces.
+   *
+   * @remarks
+   * This identifier is stored with the content to indicate which editor should be
+   * used when reopening for editing. Common values include:
+   * - 'markdown' for Markdown content
+   * - 'html' for HTML content
+   * - 'json' for structured JSON data
+   * - Custom identifiers for proprietary formats
+   */
+  rawType: string;
+}
+//#endregion
+//#region src/plugin/types/list-entity-field.d.ts
+/**
+ * Defines a custom field (column) that can be added to entity list views.
+ *
+ * @remarks
+ * Entity field items allow plugins to add custom columns or metadata displays
+ * to list views such as posts, pages, comments, etc. Fields can be positioned
+ * at the start or end of the list and can include custom rendering logic.
+ *
+ * @example
+ * ```typescript
+ * const customField: EntityFieldItem = {
+ *   priority: 10,
+ *   position: 'end',
+ *   component: markRaw(CustomFieldComponent),
+ *   props: { format: 'short' },
+ *   permissions: ['plugin:my-plugin:view']
+ * };
+ * ```
+ */
+interface EntityFieldItem {
+  /**
+   * Priority for ordering multiple custom fields.
+   * Higher priority fields are displayed first within their position group.
+   */
+  priority: number;
+  /**
+   * The position where this field should be inserted in the list.
+   * - 'start': Before the default fields
+   * - 'end': After the default fields
+   */
+  position: "start" | "end";
+  /**
+   * The Vue component that renders the field content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component typically receives the entity object as a prop and should
+   * render the custom field information in a list-friendly format.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional props to pass to the component.
+   * These can be used to configure the field's behavior or appearance.
+   */
+  props?: Record<string, unknown>;
+  /**
+   * Optional array of permission identifiers required to view this field.
+   * The field will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+  /**
+   * Whether the field should be hidden by default.
+   * Can be used to implement toggleable columns or conditional visibility.
+   */
+  hidden?: boolean;
+}
+//#endregion
+//#region src/plugin/types/list-operation.d.ts
+/**
+ * Defines a custom operation (action button or menu item) for entity list items.
+ *
+ * @remarks
+ * Operation items allow plugins to add custom actions to list rows across various
+ * entity types (posts, pages, comments, etc.). Operations can be standalone buttons
+ * or nested within dropdown menus, and can include permission checks and conditional visibility.
+ *
+ * @typeParam T - The type of entity this operation applies to (e.g., ListedPost, Plugin, Theme).
+ *
+ * @example
+ * ```typescript
+ * const exportOperation: OperationItem<ListedPost> = {
+ *   priority: 20,
+ *   component: markRaw(VButton),
+ *   label: 'Export',
+ *   action: (post) => {
+ *     console.log('Exporting post:', post.metadata.name);
+ *   },
+ *   permissions: ['plugin:export:use']
+ * };
+ *
+ * // Operation with children (dropdown menu)
+ * const shareOperation: OperationItem<ListedPost> = {
+ *   priority: 15,
+ *   component: markRaw(VDropdown),
+ *   label: 'Share',
+ *   children: [
+ *     {
+ *       priority: 10,
+ *       component: markRaw(VButton),
+ *       label: 'Share to Twitter',
+ *       action: (post) => { // ... }
+ *     },
+ *     {
+ *       priority: 20,
+ *       component: markRaw(VButton),
+ *       label: 'Copy Link',
+ *       action: (post) => { // ... }
+ *     }
+ *   ]
+ * };
+ * ```
+ */
+interface OperationItem<T> {
+  /**
+   * Priority for ordering multiple operations.
+   * Higher priority operations are displayed first (leftmost or at the top).
+   */
+  priority: number;
+  /**
+   * The Vue component that renders the operation.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * Common components include buttons, dropdown menus, or custom action components.
+   * The component receives props and should handle the visual representation and
+   * interaction of the operation.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional props to pass to the component.
+   * Can be used to configure appearance, behavior, or additional data.
+   */
+  props?: Record<string, unknown>;
+  /**
+   * Optional action handler invoked when the operation is triggered.
+   *
+   * @param item - The entity instance that this operation was triggered on.
+   *
+   * @remarks
+   * This is typically used for operations that need to perform actions on the entity,
+   * such as exporting, sharing, or custom processing. The handler can be async.
+   */
+  action?: (item?: T) => void;
+  /**
+   * Optional display label for the operation.
+   * Used for button text, menu items, or tooltips.
+   */
+  label?: string;
+  /**
+   * Whether the operation should be hidden by default.
+   * Can be used to implement conditional visibility based on entity state or user context.
+   */
+  hidden?: boolean;
+  /**
+   * Optional array of permission identifiers required to see this operation.
+   * The operation will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+  /**
+   * Optional nested operations for creating hierarchical menus.
+   *
+   * @remarks
+   * When provided, this operation becomes a dropdown menu or submenu containing
+   * the child operations. Useful for grouping related actions together.
+   */
+  children?: OperationItem<T>[];
+}
+//#endregion
+//#region src/plugin/types/plugin-installation-tab.d.ts
+/**
+ * Defines a custom tab for the plugin installation page.
+ *
+ * @remarks
+ * Plugin installation tabs allow plugins to provide alternative installation methods
+ * or additional functionality during the plugin installation process. Examples include
+ * installing from a URL, importing from a marketplace, or batch installation features.
+ *
+ * @example
+ * ```typescript
+ * const remoteInstallTab: PluginInstallationTab = {
+ *   id: 'remote-install',
+ *   label: 'Install from URL',
+ *   component: markRaw(RemoteInstallComponent),
+ *   priority: 10,
+ *   permissions: ['plugin:install:remote']
+ * };
+ * ```
+ */
+interface PluginInstallationTab {
+  /**
+   * Unique identifier for the installation tab.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:tab-id').
+   */
+  id: string;
+  /**
+   * Display label for the tab.
+   * This text will be shown in the tab navigation.
+   */
+  label: string;
+  /**
+   * The Vue component that renders the tab content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component should implement the installation interface and handle
+   * the complete installation workflow, including validation and error handling.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional props to pass to the component.
+   * Can be used to configure the installation behavior or provide additional context.
+   */
+  props?: Record<string, unknown>;
+  /**
+   * Optional array of permission identifiers required to view this tab.
+   * The tab will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+  /**
+   * Priority for ordering multiple installation tabs.
+   * Higher priority tabs appear first (leftmost) in the tab navigation.
+   */
+  priority: number;
+}
+//#endregion
+//#region src/plugin/types/plugin-tab.d.ts
+/**
+ * Defines a custom tab for a plugin's own detail/settings page.
+ *
+ * @remarks
+ * Plugin tabs allow plugins to organize their settings, configuration, and
+ * management interfaces into multiple sections. This is useful for plugins
+ * with extensive configuration options or multiple functional areas.
+ *
+ * @example
+ * ```typescript
+ * const settingsTab: PluginTab = {
+ *   id: 'settings',
+ *   label: 'Settings',
+ *   component: markRaw(SettingsComponent),
+ *   permissions: ['plugin:my-plugin:manage']
+ * };
+ * ```
+ */
+interface PluginTab {
+  /**
+   * Unique identifier for the plugin tab.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:tab-id').
+   */
+  id: string;
+  /**
+   * Display label for the tab.
+   * This text will be shown in the tab navigation.
+   */
+  label: string;
+  /**
+   * The Vue component that renders the tab content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component should implement the tab's functionality, which might include
+   * configuration forms, status displays, or management interfaces.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional array of permission identifiers required to view this tab.
+   * The tab will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+}
+//#endregion
+//#region src/plugin/types/theme-list-tab.d.ts
+/**
+ * Defines a custom tab for the theme list page.
+ *
+ * @remarks
+ * Theme list tabs allow plugins to extend the theme management interface with
+ * custom functionality such as theme marketplaces, remote theme browsers,
+ * theme backup/restore tools, or advanced theme customization interfaces.
+ *
+ * @example
+ * ```typescript
+ * const themeMarketplaceTab: ThemeListTab = {
+ *   id: 'marketplace',
+ *   label: 'Theme Marketplace',
+ *   component: markRaw(MarketplaceComponent),
+ *   priority: 20,
+ *   permissions: ['plugin:theme-marketplace:view']
+ * };
+ * ```
+ */
+interface ThemeListTab {
+  /**
+   * Unique identifier for the theme list tab.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:tab-id').
+   */
+  id: string;
+  /**
+   * Display label for the tab.
+   * This text will be shown in the tab navigation.
+   */
+  label: string;
+  /**
+   * The Vue component that renders the tab content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component should implement the theme-related functionality and integrate
+   * appropriately with the theme management system.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional props to pass to the component.
+   * Can be used to configure behavior or provide additional context.
+   */
+  props?: Record<string, unknown>;
+  /**
+   * Optional array of permission identifiers required to view this tab.
+   * The tab will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+  /**
+   * Priority for ordering multiple theme list tabs.
+   * Higher priority tabs appear first (leftmost) in the tab navigation.
+   */
+  priority: number;
+}
+//#endregion
+//#region src/plugin/types/user-tab.d.ts
+/**
+ * Defines a custom tab for the user detail page in the console.
+ *
+ * @remarks
+ * User tabs allow plugins to extend user management interfaces with custom
+ * functionality such as activity logs, custom user metadata, integration
+ * settings, or additional user management tools.
+ *
+ * @example
+ * ```typescript
+ * const activityTab: UserTab = {
+ *   id: 'activity-log',
+ *   label: 'Activity Log',
+ *   component: markRaw(ActivityLogComponent),
+ *   priority: 10,
+ *   permissions: ['system:users:view-activity']
+ * };
+ * ```
+ */
+interface UserTab {
+  /**
+   * Unique identifier for the user tab.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:tab-id').
+   */
+  id: string;
+  /**
+   * Display label for the tab.
+   * This text will be shown in the tab navigation.
+   */
+  label: string;
+  /**
+   * The Vue component that renders the tab content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component typically receives the user object as a prop and should
+   * implement user-related functionality or display user-specific information.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional array of permission identifiers required to view this tab.
+   * The tab will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+  /**
+   * Priority for ordering multiple user tabs.
+   * Higher priority tabs appear first (leftmost) in the tab navigation.
+   */
+  priority: number;
+}
+/**
+ * Defines a custom tab for the user profile page in the user center.
+ *
+ * @remarks
+ * User profile tabs allow plugins to extend the user-facing profile interface
+ * with custom sections such as social connections, preferences, achievements,
+ * subscription management, or personalization settings.
+ *
+ * @example
+ * ```typescript
+ * const preferencesTab: UserProfileTab = {
+ *   id: 'preferences',
+ *   label: 'Preferences',
+ *   component: markRaw(PreferencesComponent),
+ *   priority: 15
+ * };
+ * ```
+ */
+interface UserProfileTab {
+  /**
+   * Unique identifier for the user profile tab.
+   * Should follow a namespaced pattern to avoid conflicts (e.g., 'plugin-name:tab-id').
+   */
+  id: string;
+  /**
+   * Display label for the tab.
+   * This text will be shown in the tab navigation.
+   */
+  label: string;
+  /**
+   * The Vue component that renders the tab content.
+   * Must be wrapped with `markRaw` to prevent Vue from making it reactive.
+   *
+   * @remarks
+   * The component should provide user-facing functionality that allows users
+   * to view or modify their own profile information or settings.
+   */
+  component: Raw<Component>;
+  /**
+   * Optional array of permission identifiers required to view this tab.
+   * The tab will only be visible to users with at least one of these permissions.
+   */
+  permissions?: string[];
+  /**
+   * Priority for ordering multiple user profile tabs.
+   * Higher priority tabs appear first (leftmost) in the tab navigation.
+   */
+  priority: number;
+}
+//#endregion
+//#region src/plugin/types/ui-plugin-module.d.ts
+/**
+ * Represents a route record that will be appended to a parent route.
+ * Used to extend existing routes with additional child routes.
+ */
+interface RouteRecordAppend {
+  /**
+   * The name of the parent route to which this route will be appended.
+   */
+  parentName: NonNullable<RouteRecordName>;
+  /**
+   * The route definition to be appended as a child route.
+   */
+  route: RouteRecordRaw;
+}
+/**
+ * Defines extension points that plugins can hook into to extend Halo's functionality.
+ * Extension points follow a naming convention: `<feature>:<action>:<operation>`.
+ *
+ * @remarks
+ * Extension points are the primary mechanism for plugins to integrate with the Halo console and uc.
+ * Each extension point represents a specific place where plugins can inject custom functionality.
+ */
+interface ExtensionPoint {
+  /**
+   * Creates custom attachment selector providers.
+   * Allows plugins to provide alternative attachment selection interfaces.
+   *
+   * @returns An array of attachment select providers or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/attachment-selector-create
+   */
+  "attachment:selector:create"?: () => AttachmentSelectProvider[] | Promise<AttachmentSelectProvider[]>;
+  /**
+   * Creates custom editor providers.
+   * Allows plugins to register custom content editors.
+   *
+   * @returns An array of editor providers or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/editor-create
+   */
+  "editor:create"?: () => EditorProvider[] | Promise<EditorProvider[]>;
+  /**
+   * Creates tabs for the plugin's own settings page.
+   * Used to add configuration tabs within a plugin's detail view.
+   *
+   * @returns An array of plugin tabs or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/plugin-self-tabs-create
+   */
+  "plugin:self:tabs:create"?: () => PluginTab[] | Promise<PluginTab[]>;
+  /**
+   * Creates extensions for the default rich-text editor.
+   * Allows plugins to extend the editor with custom nodes, marks, or functionality.
+   *
+   * @returns An array of editor extensions or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/default-editor-extension-create
+   */
+  "default:editor:extension:create"?: () => AnyExtension[] | Promise<AnyExtension[]>;
+  /**
+   * Creates comment subject reference providers.
+   * Allows plugins to define custom content types that can receive comments.
+   *
+   * @returns An array of comment subject reference providers.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/comment-subject-ref-create
+   */
+  "comment:subject-ref:create"?: () => CommentSubjectRefProvider[];
+  /**
+   * Replaces the default comment editor.
+   * Allows plugins to provide a custom comment editing interface.
+   *
+   * @returns A comment editor provider or a promise resolving to it.
+   */
+  "comment:editor:replace"?: () => CommentEditorProvider | Promise<CommentEditorProvider>;
+  /**
+   * Replaces the default comment list item content display.
+   * Allows plugins to customize how comment content is rendered in lists.
+   *
+   * @returns A comment content provider or a promise resolving to it.
+   */
+  "comment:list-item:content:replace"?: () => CommentContentProvider | Promise<CommentContentProvider>;
+  /**
+   * Creates tabs for the backup management page.
+   * Allows plugins to add custom backup-related functionality.
+   *
+   * @returns An array of backup tabs or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/backup-tabs-create
+   */
+  "backup:tabs:create"?: () => BackupTab[] | Promise<BackupTab[]>;
+  /**
+   * Creates tabs for the plugin installation page.
+   * Allows plugins to add custom installation methods or configurations.
+   *
+   * @returns An array of plugin installation tabs or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/plugin-installation-tabs-create
+   */
+  "plugin:installation:tabs:create"?: () => PluginInstallationTab[] | Promise<PluginInstallationTab[]>;
+  /**
+   * Creates custom operations for post list items.
+   * Allows plugins to add action buttons or menu items to post list rows.
+   *
+   * @param post - A reactive reference to the post object.
+   * @returns An array of operation items for the post.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/post-list-item-operation-create
+   */
+  "post:list-item:operation:create"?: (post: Ref<ListedPost>) => OperationItem<ListedPost>[];
+  /**
+   * Creates custom operations for single page list items.
+   * Allows plugins to add action buttons or menu items to single page list rows.
+   *
+   * @param singlePage - A reactive reference to the single page object.
+   * @returns An array of operation items for the single page.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/single-page-list-item-operation-create
+   */
+  "single-page:list-item:operation:create"?: (singlePage: Ref<ListedSinglePage>) => OperationItem<ListedSinglePage>[];
+  /**
+   * Creates custom operations for comment list items.
+   * Allows plugins to add action buttons or menu items to comment list rows.
+   *
+   * @param comment - A reactive reference to the comment object.
+   * @returns An array of operation items for the comment.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/comment-list-item-operation-create
+   */
+  "comment:list-item:operation:create"?: (comment: Ref<ListedComment>) => OperationItem<ListedComment>[];
+  /**
+   * Creates custom operations for reply list items.
+   * Allows plugins to add action buttons or menu items to reply list rows.
+   *
+   * @param reply - A reactive reference to the reply object.
+   * @returns An array of operation items for the reply.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/reply-list-item-operation-create
+   */
+  "reply:list-item:operation:create"?: (reply: Ref<ListedReply>) => OperationItem<ListedReply>[];
+  /**
+   * Creates custom operations for plugin list items.
+   * Allows plugins to add action buttons or menu items to plugin list rows.
+   *
+   * @param plugin - A reactive reference to the plugin object.
+   * @returns An array of operation items for the plugin.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/plugin-list-item-operation-create
+   */
+  "plugin:list-item:operation:create"?: (plugin: Ref<Plugin>) => OperationItem<Plugin>[];
+  /**
+   * Creates custom operations for backup list items.
+   * Allows plugins to add action buttons or menu items to backup list rows.
+   *
+   * @param backup - A reactive reference to the backup object.
+   * @returns An array of operation items for the backup.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/backup-list-item-operation-create
+   */
+  "backup:list-item:operation:create"?: (backup: Ref<Backup>) => OperationItem<Backup>[];
+  /**
+   * Creates custom operations for attachment list items.
+   * Allows plugins to add action buttons or menu items to attachment list rows.
+   *
+   * @param attachment - A reactive reference to the attachment object.
+   * @returns An array of operation items for the attachment.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/attachment-list-item-operation-create
+   */
+  "attachment:list-item:operation:create"?: (attachment: Ref<Attachment>) => OperationItem<Attachment>[];
+  /**
+   * Creates custom fields for plugin list items.
+   * Allows plugins to add custom columns or metadata fields to the plugin list display.
+   *
+   * @param plugin - A reactive reference to the plugin object.
+   * @returns An array of entity field items for the plugin.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/plugin-list-item-field-create
+   */
+  "plugin:list-item:field:create"?: (plugin: Ref<Plugin>) => EntityFieldItem[];
+  /**
+   * Creates custom fields for post list items.
+   * Allows plugins to add custom columns or metadata fields to the post list display.
+   *
+   * @param post - A reactive reference to the post object.
+   * @returns An array of entity field items for the post.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/post-list-item-field-create
+   */
+  "post:list-item:field:create"?: (post: Ref<ListedPost>) => EntityFieldItem[];
+  /**
+   * Creates custom fields for single page list items.
+   * Allows plugins to add custom columns or metadata fields to the single page list display.
+   *
+   * @param singlePage - A reactive reference to the single page object.
+   * @returns An array of entity field items for the single page.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/single-page-list-item-field-create
+   */
+  "single-page:list-item:field:create"?: (singlePage: Ref<ListedSinglePage>) => EntityFieldItem[];
+  /**
+   * Creates tabs for the theme list page.
+   * Allows plugins to add custom theme management or configuration sections.
+   *
+   * @returns An array of theme list tabs or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/theme-list-tabs-create
+   */
+  "theme:list:tabs:create"?: () => ThemeListTab[] | Promise<ThemeListTab[]>;
+  /**
+   * Creates custom operations for theme list items.
+   * Allows plugins to add action buttons or menu items to theme list rows.
+   *
+   * @param theme - A reactive reference to the theme object.
+   * @returns An array of operation items for the theme.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/theme-list-item-operation-create
+   */
+  "theme:list-item:operation:create"?: (theme: Ref<Theme>) => OperationItem<Theme>[];
+  /**
+   * Creates tabs for the user detail page in the console.
+   * Allows plugins to add custom user management sections.
+   *
+   * @returns An array of user tabs or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/user-detail-tabs-create
+   */
+  "user:detail:tabs:create"?: () => UserTab[] | Promise<UserTab[]>;
+  /**
+   * Creates tabs for the user profile page in the user center.
+   * Allows plugins to extend user profile settings and information.
+   *
+   * @returns An array of user profile tabs or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/uc-user-profile-tabs-create
+   */
+  "uc:user:profile:tabs:create"?: () => UserProfileTab[] | Promise<UserProfileTab[]>;
+  /**
+   * Creates custom dashboard widgets for the console.
+   * Allows plugins to add informational or interactive widgets to the main dashboard.
+   *
+   * @returns An array of dashboard widget definitions or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/dashboard-widgets#consoledashboardwidgets
+   */
+  "console:dashboard:widgets:create"?: () => DashboardWidgetDefinition[] | Promise<DashboardWidgetDefinition[]>;
+  /**
+   * Creates quick action items for internal dashboard widgets.
+   * Allows plugins to add quick access buttons or shortcuts to dashboard widgets.
+   *
+   * @returns An array of dashboard widget quick action items or a promise resolving to them.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui/dashboard-widgets#consoledashboardwidgetsinternalquick-actionitem
+   */
+  "console:dashboard:widgets:internal:quick-action:item:create"?: () => DashboardWidgetQuickActionItem[] | Promise<DashboardWidgetQuickActionItem[]>;
+}
+/**
+ * Defines the structure of a UI plugin module for the Halo console and user center.
+ *
+ * @see https://docs.halo.run/developer-guide/plugin/basics/ui/entry
+ */
+interface PluginModule {
+  /**
+   * Components that will be globally registered when the plugin is activated.
+   * These components can be used throughout the Halo console without explicit imports.
+   *
+   * @remarks
+   * The key is the component name (in kebab-case is recommended),
+   * and the value is the Vue component definition.
+   */
+  components?: Record<string, Component>;
+  /**
+   * Console routes that will be registered when the plugin is activated.
+   * Can be either standalone routes or routes that append to existing parent routes.
+   *
+   * @remarks
+   * - Use `RouteRecordRaw[]` for standalone routes
+   * - Use `RouteRecordAppend[]` to append routes to existing parent routes
+   * @see https://docs.halo.run/developer-guide/plugin/api-reference/ui/route
+   */
+  routes?: RouteRecordRaw[] | RouteRecordAppend[];
+  /**
+   * User center routes that will be registered when the plugin is activated.
+   * These routes are specifically for the user-facing area (UC).
+   *
+   * @remarks
+   * - Use `RouteRecordRaw[]` for standalone routes
+   * - Use `RouteRecordAppend[]` to append routes to existing parent routes
+   * @see https://docs.halo.run/developer-guide/plugin/api-reference/ui/route
+   */
+  ucRoutes?: RouteRecordRaw[] | RouteRecordAppend[];
+  /**
+   * Extension points that the plugin hooks into.
+   * This is where plugins register their custom functionality to extend Halo.
+   *
+   * @remarks
+   * Each extension point can provide custom functionality that integrates
+   * with specific parts of the Halo console.
+   * @see https://docs.halo.run/developer-guide/plugin/extension-points/ui
+   */
+  extensionPoints?: ExtensionPoint;
+}
+//#endregion
+//#region src/plugin/types/ui-plugin-entry.d.ts
+/**
+ * Helper function to define a Halo UI plugin module with type safety.
+ *
+ * @param plugin - The plugin module definition containing components, routes, and extension points.
+ * @returns The same plugin module, properly typed for Halo's plugin system.
+ *
+ * @remarks
+ * This function is a type-safe wrapper that provides IDE support and type checking
+ * for plugin definitions. It doesn't perform any runtime transformations, but ensures
+ * that the plugin structure conforms to the expected interface.
+ *
+ * @example
+ * ```typescript
+ * import { definePlugin } from "@halo-dev/ui-shared";
+ * import { markRaw } from "vue";
+ *
+ * export default definePlugin({
+ *   components: {
+ *     "my-widget": MyWidgetComponent
+ *   },
+ *   routes: [
+ *     {
+ *       path: "/my-plugin",
+ *       name: "MyPlugin",
+ *       component: MyPluginView
+ *     }
+ *   ],
+ *   extensionPoints: {
+ *     "post:list-item:operation:create": (post) => [
+ *       {
+ *         priority: 10,
+ *         component: markRaw(VButton),
+ *         label: "Custom Action",
+ *         action: () => {
+ *           console.log("Action triggered");
+ *         }
+ *       }
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+declare function definePlugin(plugin: PluginModule): PluginModule;
+//#endregion
+//#region src/stores/types/slug.d.ts
+type ModeType = "UUID" | "shortUUID" | "timestamp" | "generateByTitle";
+declare enum FormType {
+  TAG = "Tag",
+  CATEGORY = "Category",
+  POST = "Post",
+  SINGLE_PAGE = "SinglePage",
+}
+//#endregion
+//#region src/stores/types/actuator.d.ts
+interface GlobalInfo {
+  externalUrl: string;
+  timeZone: string;
+  locale: string;
+  allowComments: boolean;
+  allowAnonymousComments: boolean;
+  allowRegistration: boolean;
+  favicon?: string;
+  postSlugGenerationStrategy: ModeType;
+  mustVerifyEmailOnRegistration: boolean;
+  siteTitle: string;
+}
+interface Info {
+  git?: Git;
+  build?: Build;
+  java: Java;
+  os: Os;
+  database: Database;
+}
+interface Database {
+  name: string;
+  version: string;
+}
+interface Commit {
+  id: string;
+  time: Date;
+}
+interface Git {
+  branch: string;
+  commit: Commit;
+}
+interface Build {
+  artifact: string;
+  name: string;
+  time: Date;
+  version: string;
+  group: string;
+}
+interface Vendor {
+  name: string;
+  version: string;
+}
+interface Runtime {
+  name: string;
+  version: string;
+}
+interface Jvm {
+  name: string;
+  vendor: string;
+  version: string;
+}
+interface Java {
+  version: string;
+  vendor: Vendor;
+  runtime: Runtime;
+  jvm: Jvm;
+}
+interface Os {
+  name: string;
+  version: string;
+  arch: string;
+}
+interface Tag {
+  key: string;
+  value: string;
+}
+interface StartupStep {
+  name: string;
+  id: number;
+  tags: Tag[];
+  parentId?: number;
+}
+interface Event {
+  endTime: Date;
+  duration: string;
+  startTime: Date;
+  startupStep: StartupStep;
+}
+interface Timeline {
+  startTime: Date;
+  events: Event[];
+}
+interface Startup {
+  springBootVersion: string;
+  timeline: Timeline;
+}
+//#endregion
+//#region src/stores/index.d.ts
+/**
+ * Collection of Pinia stores for shared application state.
+ *
+ * @remarks
+ * These stores provide centralized state management for common data
+ * that needs to be accessed across multiple components and plugins.
+ */
+declare const stores: {
+  /**
+   * Store for managing the current authenticated user's information.
+   *
+   * @remarks
+   * This store provides access to the current user's details and authentication state.
+   * It includes helper methods to fetch the latest user information from the server.
+   *
+   * @example
+   * ```typescript
+   * import { stores } from "@halo-dev/ui-shared";
+   *
+   * const userStore = stores.currentUser();
+   *
+   * // Fetch current user info
+   * await userStore.fetchCurrentUser();
+   *
+   * // Access user data
+   * console.log(userStore.currentUser?.user.metadata.name);
+   * console.log(userStore.isAnonymous); // Check if user is anonymous
+   * ```
+   */
+  currentUser: pinia0.StoreDefinition<"currentUser", Pick<{
+    currentUser: vue0.Ref<DetailedUser | undefined, DetailedUser | undefined>;
+    isAnonymous: vue0.Ref<boolean, boolean>;
+    fetchCurrentUser: () => Promise<void>;
+  }, "currentUser" | "isAnonymous">, Pick<{
+    currentUser: vue0.Ref<DetailedUser | undefined, DetailedUser | undefined>;
+    isAnonymous: vue0.Ref<boolean, boolean>;
+    fetchCurrentUser: () => Promise<void>;
+  }, never>, Pick<{
+    currentUser: vue0.Ref<DetailedUser | undefined, DetailedUser | undefined>;
+    isAnonymous: vue0.Ref<boolean, boolean>;
+    fetchCurrentUser: () => Promise<void>;
+  }, "fetchCurrentUser">>;
+  /**
+   * Store for managing global system information and configuration.
+   *
+   * @remarks
+   * This store provides access to global system settings, configuration,
+   * and metadata that are shared across the entire application.
+   *
+   * @example
+   * ```typescript
+   * import { stores } from "@halo-dev/ui-shared";
+   *
+   * const globalInfoStore = stores.globalInfo();
+   *
+   * // Fetch global info
+   * await globalInfoStore.fetchGlobalInfo();
+   *
+   * // Access global settings
+   * console.log(globalInfoStore.globalInfo?.externalUrl);
+   * console.log(globalInfoStore.globalInfo?.siteTitle);
+   * console.log(globalInfoStore.globalInfo?.allowRegistration);
+   * ```
+   */
+  globalInfo: pinia0.StoreDefinition<"global-info", Pick<{
+    globalInfo: vue0.Ref<GlobalInfo | undefined, GlobalInfo | undefined>;
+    fetchGlobalInfo: () => Promise<void>;
+  }, "globalInfo">, Pick<{
+    globalInfo: vue0.Ref<GlobalInfo | undefined, GlobalInfo | undefined>;
+    fetchGlobalInfo: () => Promise<void>;
+  }, never>, Pick<{
+    globalInfo: vue0.Ref<GlobalInfo | undefined, GlobalInfo | undefined>;
+    fetchGlobalInfo: () => Promise<void>;
+  }, "fetchGlobalInfo">>;
+};
+//#endregion
+//#region src/types/menus.d.ts
+type CoreMenuGroupId = "dashboard" | "content" | "interface" | "system" | "tool";
+interface MenuGroupType {
+  id: CoreMenuGroupId | string;
+  name?: string;
+  priority: number;
+  items?: MenuItemType[];
+}
+interface MenuItemType {
+  name: string;
+  path: string;
+  mobile?: boolean;
+  icon?: Component;
+  meta?: Record<string, unknown>;
+  children?: MenuItemType[];
+}
+//#endregion
+//#region src/utils/attachment.d.ts
+/**
+ * Mapping of thumbnail size enums to their corresponding widths in pixels
+ *
+ * @remarks
+ * - XL: 1600px - Extra large thumbnails
+ * - L: 1200px - Large thumbnails
+ * - M: 800px - Medium thumbnails
+ * - S: 400px - Small thumbnails
+ */
+declare const THUMBNAIL_WIDTH_MAP: Record<GetThumbnailByUriSizeEnum, number>;
+declare class AttachmentUtils {
+  /**
+   * Generates a thumbnail URL for the given image URL with the specified size
+   *
+   * @param url - The original image URL (can be absolute, relative, or external)
+   * @param size - The desired thumbnail size (XL, L, M, or S)
+   * @returns The thumbnail URL with width parameter, or original URL if size is invalid
+   *
+   * @remarks
+   * This method handles three scenarios:
+   * 1. If URL starts with current origin: Appends `?width={size}` query parameter
+   * 2. If URL is a relative path (starts with "/"): Appends `?width={size}` query parameter
+   * 3. If URL is external: Routes through Halo's thumbnail API endpoint
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   *
+   * // Local image
+   * utils.attachment.getThumbnailUrl("/uploads/image.jpg", "M");
+   * // Returns: "/uploads/image.jpg?width=800"
+   *
+   * // Same origin image
+   * utils.attachment.getThumbnailUrl("https://example.com/image.jpg", "S");
+   * // Returns: "https://example.com/image.jpg?width=400" (if current origin is example.com)
+   *
+   * // External image
+   * utils.attachment.getThumbnailUrl("https://external.com/image.jpg", "L");
+   * // Returns: "/apis/api.storage.halo.run/v1alpha1/thumbnails/-/via-uri?uri=https%3A%2F%2Fexternal.com%2Fimage.jpg&width=1200"
+   * ```
+   */
+  getThumbnailUrl(url: string, size: GetThumbnailByUriSizeEnum): string;
+  /**
+   * Extracts the URL from an attachment-like object
+   *
+   * @param attachment - The attachment object (can be a string URL, Attachment object, or AttachmentSimple)
+   * @returns The URL string extracted from the attachment
+   * @throws {Error} When the attachment type is invalid or unrecognized
+   *
+   * @remarks
+   * This method handles three types of attachments:
+   * 1. String: Returns the string directly as URL
+   * 2. Attachment object (with "spec"): Returns the permalink from status
+   * 3. AttachmentSimple (with "url"): Returns the url property
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   *
+   * // String URL
+   * utils.attachment.getUrl("https://example.com/image.jpg");
+   * // Returns: "https://example.com/image.jpg"
+   *
+   * // Attachment object
+   * utils.attachment.getUrl(attachmentObject);
+   * // Returns: attachmentObject.status?.permalink
+   *
+   * // AttachmentSimple object
+   * utils.attachment.getUrl({ url: "https://example.com/image.jpg" });
+   * // Returns: "https://example.com/image.jpg"
+   * ```
+   */
+  getUrl(attachment: AttachmentLike): string | undefined;
+  /**
+   * Converts an attachment-like object to a simplified attachment format
+   *
+   * @param attachment - The attachment object to convert (can be a string URL, Attachment object, or AttachmentSimple)
+   * @returns A simplified attachment object with url, alt, and mediaType properties, or undefined
+   * @throws {Error} When the attachment type is invalid or unrecognized
+   *
+   * @remarks
+   * This method normalizes different attachment formats into a consistent AttachmentSimple structure:
+   * 1. String: Converts to object with only url property
+   * 2. Attachment object (with "spec"): Extracts permalink, displayName, and mediaType
+   * 3. AttachmentSimple (with "url"): Returns as-is since it's already in the correct format
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   *
+   * // String URL
+   * utils.attachment.convertToSimple("https://example.com/image.jpg");
+   * // Returns: { url: "https://example.com/image.jpg" }
+   *
+   * // Attachment object
+   * utils.attachment.convertToSimple(attachmentObject);
+   * // Returns: {
+   * //   url: attachmentObject.status?.permalink || "",
+   * //   alt: attachmentObject.spec.displayName,
+   * //   mediaType: attachmentObject.spec.mediaType
+   * // }
+   *
+   * // AttachmentSimple object
+   * utils.attachment.convertToSimple({ url: "https://example.com/image.jpg", alt: "Image" });
+   * // Returns: { url: "https://example.com/image.jpg", alt: "Image" }
+   * ```
+   */
+  convertToSimple(attachment: AttachmentLike): AttachmentSimple | undefined;
+}
+//#endregion
+//#region src/utils/date.d.ts
+declare class DateUtils {
+  readonly dayjs: typeof _dayjs;
+  constructor();
+  /**
+   * Formats a date to a string according to the specified format
+   *
+   * @param date - The date to format (string, Date object, or null/undefined)
+   * @param format - The format string (defaults to "YYYY-MM-DD HH:mm")
+   * @returns The formatted date string, or empty string if date is null/undefined
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   * utils.date.format(new Date()); // "2025-10-22 14:30"
+   * utils.date.format("2025-10-22", "YYYY/MM/DD"); // "2025/10/22"
+   * ```
+   */
+  format(date: string | Date | undefined | null, format?: string): string;
+  /**
+   * Converts a date to ISO 8601 format string
+   *
+   * @param date - The date to convert (string, Date object, or null/undefined)
+   * @returns The ISO 8601 formatted date string, or empty string if date is null/undefined
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   * utils.date.toISOString(new Date("2025-10-22")); // "2025-10-22T00:00:00.000Z"
+   * ```
+   */
+  toISOString(date: string | Date | undefined | null): string;
+  /**
+   * Converts a date to HTML5 datetime-local input format
+   *
+   * @param date - The date to convert (string, Date object, or null/undefined)
+   * @returns The datetime-local formatted string (YYYY-MM-DDTHH:mm), or empty string if date is null/undefined
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#the_y10k_problem_often_client-side
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   * utils.date.toDatetimeLocal(new Date("2025-10-22 14:30")); // "2025-10-22T14:30"
+   * ```
+   */
+  toDatetimeLocal(date: string | Date | undefined | null): string;
+  /**
+   * Gets the relative time from now to the specified date
+   *
+   * @param date - The target date (string, Date object, or null/undefined)
+   * @returns A human-readable relative time string (e.g., "in 2 hours", "3 days ago"), or undefined if date is null/undefined
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   * // Assuming now is 2025-10-22
+   * utils.date.timeAgo("2025-10-23"); // "in a day"
+   * utils.date.timeAgo("2025-10-21"); // "a day ago"
+   * utils.date.timeAgo("2025-11-22"); // "in a month"
+   * ```
+   */
+  timeAgo(date: string | Date | undefined | null): string | undefined;
+  /**
+   * Sets the locale for date formatting
+   *
+   * @param locale - The locale code (e.g., "en", "zh", "en-US", "zh-CN", "zh-TW")
+   *
+   * @remarks
+   * Supported locales:
+   * - "en" or "en-US" → English
+   * - "zh" or "zh-CN" → Simplified Chinese
+   * - "zh-TW" → Traditional Chinese
+   *
+   * Defaults to English if the locale is not supported.
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   * utils.date.setLocale("zh-CN");
+   * utils.date.timeAgo("2025-10-21"); // "1 天前"
+   * utils.date.setLocale("en");
+   * utils.date.timeAgo("2025-10-21"); // "a day ago"
+   * ```
+   */
+  setLocale(locale: string): void;
+}
+// See https://github.com/iamkun/dayjs/issues/364
+declare module "dayjs" {
+  interface Dayjs {
+    fromNow(withoutSuffix?: boolean): string;
+    from(compared: _dayjs.ConfigType, withoutSuffix?: boolean): string;
+    toNow(withoutSuffix?: boolean): string;
+    to(compared: _dayjs.ConfigType, withoutSuffix?: boolean): string;
+  }
+}
+declare module "dayjs" {
+  interface Dayjs {
+    tz(timezone?: string, keepLocalTime?: boolean): _dayjs.Dayjs;
+    offsetName(type?: "short" | "long"): string | undefined;
+  }
+  interface DayjsTimezone {
+    (date?: _dayjs.ConfigType, timezone?: string): _dayjs.Dayjs;
+    (date: _dayjs.ConfigType, format: string, timezone?: string): _dayjs.Dayjs;
+    guess(): string;
+    setDefault(timezone?: string): void;
+  }
+}
+declare module "dayjs" {
+  interface Dayjs {
+    utc(keepLocalTime?: boolean): _dayjs.Dayjs;
+    local(): _dayjs.Dayjs;
+    isUTC(): boolean;
+    utcOffset(offset: number | string, keepLocalTime?: boolean): _dayjs.Dayjs;
+  }
+  function utc(config?: _dayjs.ConfigType, format?: string, strict?: boolean): _dayjs.Dayjs;
+}
+//#endregion
+//#region src/utils/id.d.ts
+/**
+ * Utilities for generating unique identifiers that remain sortable over time.
+ *
+ * Relies on the `uuid` package for RFC 4122 compliant UUID generation.
+ */
+declare class IdUtils {
+  /**
+   * Generates a RFC 4122 version 7 UUID string using the `uuid` package.
+   *
+   * UUID v7 keeps the order of creation roughly aligned with chronological order,
+   * making it a good fit for persistence stores or log entries that benefit from
+   * monotonic sorting.
+   *
+   * @returns A lowercase UUIDv7 string such as "018f1c2e-4fcb-7d04-9f21-1a2b3c4d5e6f".
+   */
+  uuid(): string;
+}
+//#endregion
+//#region src/utils/permission.d.ts
+/**
+ * Utility class for checking user permissions.
+ */
+declare class PermissionUtils {
+  private userPermissions?;
+  /**
+   * Creates a new PermissionUtils instance.
+   * @param userPermissions - Array of permissions that the user has
+   */
+  constructor(userPermissions?: Array<string>);
+  /**
+   * Checks if the user has the required permissions.
+   *
+   * @param permissions - Array of permissions to check against user's permissions
+   * @param any - If true, returns true when ANY of the required permissions match.
+   *              If false, returns true only when ALL required permissions match.
+   *              Defaults to true.
+   * @returns true if the permission check passes, false otherwise
+   *
+   * @throws Error if user permissions are not set
+   *
+   * @example
+   * ```ts
+   * import { utils } from "@halo-dev/ui-shared"
+   *
+   * // Check if user has any of the permissions
+   * utils.permission.has(['core:posts:manage'], true);
+   *
+   * // Check if user has all of the permissions
+   * utils.permission.has(['core:posts:view', 'core:attachments:view'], false);
+   * ```
+   */
+  has(permissions: Array<string>, any?: boolean): boolean;
+  /**
+   * Retrieves the current user permissions.
+   * @returns Array of user permissions or undefined if not set
+   */
+  getUserPermissions(): Array<string> | undefined;
+  /**
+   * Updates the user permissions.
+   * @param userPermissions - Array of permissions to set for the user
+   */
+  setUserPermissions(userPermissions: Array<string>): void;
+}
+//#endregion
+//#region src/utils/index.d.ts
+declare const utils: {
+  date: DateUtils;
+  attachment: AttachmentUtils;
+  permission: PermissionUtils;
+  id: IdUtils;
+};
+//#endregion
+export { AttachmentLike, AttachmentSelectProvider, AttachmentSimple, BackupTab, Build, CommentContentProvider, CommentEditorProvider, CommentSubjectRefProvider, CommentSubjectRefResult, Commit, CoreMenuGroupId, DashboardResponsiveLayout, DashboardWidget, DashboardWidgetDefinition, DashboardWidgetQuickActionItem, Database, EditorProvider, EntityFieldItem, Event, ExtensionPoint, FormType, Git, GlobalInfo, Info, Java, Jvm, MenuGroupType, MenuItemType, ModeType, OperationItem, Os, PluginInstallationTab, PluginModule, PluginTab, RouteRecordAppend, Runtime, Startup, StartupStep, THUMBNAIL_WIDTH_MAP, Tag, ThemeListTab, Timeline, UserProfileTab, UserTab, Vendor, definePlugin, events, stores, utils };