@chelone/vue 0.0.0-stage → 0.1.1

package/dist/components/admin/layout/resource-menu-item.vue.d.ts

@@ -0,0 +1,16 @@
+import type { Component } from "vue";
+/** Props for {@link ResourceMenuItem}. */
+export interface ResourceMenuItemProps {
+    /** The resource name (matches a `<Resource name>` registered in `<Admin>`). */
+    name: string;
+    /** Override the label. Defaults to the pluralized resource label. */
+    label?: string;
+    /** Override the icon. Defaults to the resource's registry icon or a list glyph. */
+    icon?: Component;
+    /** Extra CSS class appended to the underlying menu button. */
+    class?: string;
+    /** Click handler invoked alongside the default navigation (e.g. close the drawer). */
+    onClick?: () => void;
+}
+declare const _default: import("vue").DefineComponent<ResourceMenuItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResourceMenuItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/layout/resource-menu-item.vue.js

@@ -0,0 +1,48 @@
+import { defineComponent, computed, unref, openBlock, createBlock, normalizeClass, createCommentVNode } from "vue";
+import { useResourceRegistry } from "../../../admin/resource-registry.js";
+import { useGetResourceLabel } from "../../../label/use-get-resource-label.js";
+import _sfc_main$1 from "../../ui/skeleton.vue.js";
+import { ListIcon } from "./icons.js";
+import _sfc_main$2 from "./menu-item-link.vue.js";
+import { useMenuAccess } from "./use-menu-access.js";
+import { useCreatePath } from "../../../router/nav-composables.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "resource-menu-item",
+  props: {
+    name: {},
+    label: {},
+    icon: {},
+    class: {},
+    onClick: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const registry = useResourceRegistry();
+    const createPath = useCreatePath();
+    const getResourceLabel = useGetResourceLabel();
+    const to = createPath({ resource: props.name, type: "list" });
+    const label = computed(() => props.label ?? getResourceLabel(props.name, 2));
+    const icon = computed(
+      () => props.icon ?? registry.definitions[props.name]?.icon ?? ListIcon
+    );
+    const { canAccess, isPending: isAccessPending } = useMenuAccess(
+      computed(() => ({ action: "list", resource: props.name }))
+    );
+    return (_ctx, _cache) => {
+      return unref(isAccessPending) ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 0,
+        class: "h-8 w-full"
+      })) : unref(canAccess) ? (openBlock(), createBlock(_sfc_main$2, {
+        key: 1,
+        to: unref(to),
+        label: label.value,
+        icon: icon.value,
+        class: normalizeClass(props.class),
+        "on-click": __props.onClick
+      }, null, 8, ["to", "label", "icon", "class", "on-click"])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/resource-menu-item2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./resource-menu-item.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/theme-context.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Theme-mode context (light/dark/system) + `useTheme` — the non-component
+ * sibling of `theme-provider.vue`. The Vue analog of `@chelone/react`'s
+ * `layout/theme-context.ts` + `use-theme.ts`.
+ *
+ * DELIBERATE DIVERGENCE FROM THE REACT TWIN: React's `<ThemeProvider>` persists
+ * the mode through shadmin-core's `useStore` and the React twin's toggle is a
+ * reka/radix `<DropdownMenu>`; both lean on `next-themes`-style React infra that
+ * has no Vue equivalent. The Vue provider persists to `localStorage` directly
+ * (a UI-only concern that need not require a Chelone store) and provides a `Ref`
+ * under a typed `InjectionKey`. As in React, `Theme` is the runtime MODE, NOT a
+ * palette — palettes are pure CSS tokens shipped by the demo/registry.
+ */
+import { type InjectionKey, type Ref } from "vue";
+/** The user-selectable theme mode. `system` follows the OS preference. */
+export type Theme = "dark" | "light" | "system";
+/** A `Theme` resolved to a concrete mode (`system` collapsed to light/dark). */
+export type ResolvedTheme = Exclude<Theme, "system">;
+/** The reactive theme contract `<ThemeProvider>` provides. */
+export interface ThemeContext {
+    /** The active mode (light/dark/system). */
+    theme: Ref<Theme>;
+    /** Persist + apply a new mode. */
+    setTheme: (theme: Theme) => void;
+}
+/** The provide/inject key for the theme context. */
+export declare const ThemeContextKey: InjectionKey<ThemeContext>;
+/** Collapse `system` to a concrete mode via `matchMedia` (SSR/jsdom → light). */
+export declare function resolveTheme(theme: Theme): ResolvedTheme;
+/**
+ * Read the active theme mode + setter. Degrades to an inert default when no
+ * `<ThemeProvider>` is present (parity with the React twin's non-throwing
+ * `useTheme`), so a toggle used standalone renders without crashing.
+ */
+export declare function useTheme(): ThemeContext;

package/dist/components/admin/layout/theme-context.js

@@ -0,0 +1,22 @@
+import { inject, ref } from "vue";
+const ThemeContextKey = /* @__PURE__ */ Symbol("chelone-theme");
+function resolveTheme(theme) {
+  if (theme === "system") {
+    if (typeof window === "undefined" || !window.matchMedia) return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  }
+  return theme;
+}
+function useTheme() {
+  const ctx = inject(ThemeContextKey, null);
+  if (!ctx) {
+    return { theme: ref("system"), setTheme: () => {
+    } };
+  }
+  return ctx;
+}
+export {
+  ThemeContextKey,
+  resolveTheme,
+  useTheme
+};

package/dist/components/admin/layout/theme-mode-toggle.vue.d.ts

@@ -0,0 +1,4 @@
+/** Props for {@link ThemeModeToggle} (none — configuration is via the provider). */
+export type ThemeModeToggleProps = Record<string, never>;
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/admin/layout/theme-mode-toggle.vue.js

@@ -0,0 +1,91 @@
+import { defineComponent, computed, openBlock, createBlock, unref, withCtx, createElementBlock, createElementVNode, toDisplayString } from "vue";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import _sfc_main$1 from "../../ui/button.vue.js";
+import { useTheme } from "./theme-context.js";
+const _hoisted_1 = {
+  key: 0,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "2",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  class: "size-5",
+  "aria-hidden": "true"
+};
+const _hoisted_2 = {
+  key: 1,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "2",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  class: "size-5",
+  "aria-hidden": "true"
+};
+const _hoisted_3 = {
+  key: 2,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "2",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  class: "size-5",
+  "aria-hidden": "true"
+};
+const _hoisted_4 = { class: "sr-only" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "theme-mode-toggle",
+  setup(__props) {
+    const { theme, setTheme } = useTheme();
+    const translate = useTranslate();
+    const CYCLE = ["light", "dark", "system"];
+    function cycle() {
+      const index = CYCLE.indexOf(theme.value);
+      setTheme(CYCLE[(index + 1) % CYCLE.length] ?? "system");
+    }
+    const label = computed(
+      () => translate("ra.action.toggle_theme", { _: "Toggle theme" })
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        variant: "ghost",
+        size: "icon",
+        "data-theme-mode-toggle": "",
+        "data-theme": unref(theme),
+        "aria-label": label.value,
+        title: label.value,
+        onClick: cycle
+      }, {
+        default: withCtx(() => [
+          unref(theme) === "light" ? (openBlock(), createElementBlock("svg", _hoisted_1, [..._cache[0] || (_cache[0] = [
+            createElementVNode("circle", {
+              cx: "12",
+              cy: "12",
+              r: "4"
+            }, null, -1),
+            createElementVNode("path", { d: "M12 2v2M12 20v2M4.93 4.93l1.41 1.41M17.66 17.66l1.41 1.41M2 12h2M20 12h2M6.34 17.66l-1.41 1.41M19.07 4.93l-1.41 1.41" }, null, -1)
+          ])])) : unref(theme) === "dark" ? (openBlock(), createElementBlock("svg", _hoisted_2, [..._cache[1] || (_cache[1] = [
+            createElementVNode("path", { d: "M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z" }, null, -1)
+          ])])) : (openBlock(), createElementBlock("svg", _hoisted_3, [..._cache[2] || (_cache[2] = [
+            createElementVNode("rect", {
+              width: "20",
+              height: "14",
+              x: "2",
+              y: "3",
+              rx: "2"
+            }, null, -1),
+            createElementVNode("path", { d: "M8 21h8M12 17v4" }, null, -1)
+          ])])),
+          createElementVNode("span", _hoisted_4, toDisplayString(label.value), 1)
+        ]),
+        _: 1
+      }, 8, ["data-theme", "aria-label", "title"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/theme-mode-toggle2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./theme-mode-toggle.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/theme-provider.vue.d.ts

@@ -0,0 +1,20 @@
+import type { Theme } from "./theme-context.js";
+/** Props for {@link ThemeProvider}. */
+export interface ThemeProviderProps {
+    /** Initial mode when nothing is persisted yet. Defaults to `system`. */
+    defaultTheme?: Theme;
+    /** localStorage key the mode is persisted under. Defaults to `chelone-theme`. */
+    storageKey?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ThemeProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ThemeProviderProps> & Readonly<{}>, {
+    defaultTheme: Theme;
+    storageKey: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/layout/theme-provider.vue.js

@@ -0,0 +1,37 @@
+import { defineComponent, ref, watchEffect, provide, renderSlot } from "vue";
+import { resolveTheme, ThemeContextKey } from "./theme-context.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "theme-provider",
+  props: {
+    defaultTheme: { default: "system" },
+    storageKey: { default: "chelone-theme" }
+  },
+  setup(__props) {
+    const props = __props;
+    function readStored() {
+      if (typeof localStorage === "undefined") return props.defaultTheme;
+      const stored = localStorage.getItem(props.storageKey);
+      return stored === "light" || stored === "dark" || stored === "system" ? stored : props.defaultTheme;
+    }
+    const theme = ref(readStored());
+    function setTheme(value) {
+      theme.value = value;
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(props.storageKey, value);
+      }
+    }
+    watchEffect(() => {
+      if (typeof document === "undefined") return;
+      const root = document.documentElement;
+      root.classList.remove("light", "dark");
+      root.classList.add(resolveTheme(theme.value));
+    });
+    provide(ThemeContextKey, { theme, setTheme });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/theme-provider2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./theme-provider.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/title-portal-id.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The DOM id of the app-bar title portal target. `<TitlePortal>` reserves the
+ * element with this id; a page `<Title>` teleports into it. Kept in a `.ts`
+ * sibling so `title-portal.vue` stays component-only. Matches the React twin's
+ * `TITLE_PORTAL_ID` so the two adapters share the same portal contract.
+ */
+export declare const TITLE_PORTAL_ID = "chelone-title-portal";

package/dist/components/admin/layout/title-portal-id.js

@@ -0,0 +1,4 @@
+const TITLE_PORTAL_ID = "chelone-title-portal";
+export {
+  TITLE_PORTAL_ID
+};

package/dist/components/admin/layout/title-portal.vue.d.ts

@@ -0,0 +1,7 @@
+/** Props for {@link TitlePortal}. */
+export interface TitlePortalProps {
+    /** Extra class appended to the portal slot element. */
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<TitlePortalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TitlePortalProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/layout/title-portal.vue.js

@@ -0,0 +1,23 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, unref } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { TITLE_PORTAL_ID } from "./title-portal-id.js";
+const _hoisted_1 = ["id"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "title-portal",
+  props: {
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        id: unref(TITLE_PORTAL_ID),
+        class: normalizeClass(unref(cn)("flex min-w-0 flex-1 items-center", props.class)),
+        "data-slot": "title-portal"
+      }, null, 10, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/title-portal2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./title-portal.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/title.vue.d.ts

@@ -0,0 +1,23 @@
+/** Props for {@link Title}. */
+export interface TitleProps {
+    /**
+     * The title to display, translated via the i18n provider (with the string
+     * itself as the fallback). For a custom title node, use the default slot
+     * instead — the Vue idiom replacing the React twin's `title={<element>}`.
+     */
+    title?: string;
+    /** Fallback title used when `title` is undefined. Translated if present. */
+    defaultTitle?: string;
+    /** Optional CSS class applied to the rendered title element. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<TitleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TitleProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** A custom title node rendered verbatim (replaces the translated string). */
+    default?: () => unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/layout/title.vue.js

@@ -0,0 +1,45 @@
+import { defineComponent, useSlots, ref, onMounted, nextTick, computed, openBlock, createBlock, Teleport, renderSlot, createElementBlock, normalizeClass, unref, toDisplayString, createCommentVNode } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { TITLE_PORTAL_ID } from "./title-portal-id.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "title",
+  props: {
+    title: {},
+    defaultTitle: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const translate = useTranslate();
+    const target = ref(null);
+    onMounted(async () => {
+      const resolve = () => typeof document !== "undefined" ? document.getElementById(TITLE_PORTAL_ID) : null;
+      target.value = resolve();
+      if (!target.value) {
+        await nextTick();
+        target.value = resolve();
+      }
+    });
+    const value = computed(() => props.title ?? props.defaultTitle ?? "");
+    const translated = computed(
+      () => value.value ? translate(value.value, { _: value.value }) : ""
+    );
+    const hasCustom = computed(() => slots.default != null);
+    return (_ctx, _cache) => {
+      return target.value ? (openBlock(), createBlock(Teleport, {
+        key: 0,
+        to: target.value
+      }, [
+        hasCustom.value ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createElementBlock("h1", {
+          key: 1,
+          class: normalizeClass(unref(cn)("truncate text-lg font-semibold", props.class))
+        }, toDisplayString(translated.value), 3))
+      ], 8, ["to"])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/title2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./title.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/top-toolbar.vue.d.ts

@@ -0,0 +1,14 @@
+/** Props for {@link TopToolbar}. */
+export interface TopToolbarProps {
+    /** Extra class merged onto the toolbar div. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<TopToolbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TopToolbarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/layout/top-toolbar.vue.js

@@ -0,0 +1,21 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, unref, renderSlot } from "vue";
+import { cn } from "../../../lib/utils.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "top-toolbar",
+  props: {
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cn)("flex items-center justify-end gap-2 mb-2", props.class))
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/top-toolbar2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./top-toolbar.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/use-menu-access.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `useMenuAccess` — a no-throw `useCanAccess` for the sidebar menu + the CRUD
+ * action buttons. The Vue twin of `@chelone/react`'s
+ * `layout/use-menu-access.ts`.
+ *
+ * Chelone's `useCanAccess` calls `useCheloneAuthProvider()`, which THROWS when no
+ * `authProvider` is configured. A no-auth app must still render its resource menu
+ * + buttons, so this reads the provider OPTIONALLY (`useCheloneContext`) and only
+ * runs the access query when a provider WITH a `canAccess` method exists. With no
+ * provider — or no `canAccess` method — access is ALLOWED (ra-core parity:
+ * "access control not configured = allow").
+ *
+ * Vue idiom translation from the React twin: React re-derives `{ canAccess,
+ * isPending }` each render; Vue returns `ComputedRef`s off the vue-query result
+ * refs so a button/menu template re-renders reactively as the check settles. The
+ * `params` are accepted as a `MaybeRefOrGetter` so a record-scoped grant
+ * re-evaluates when an async-loading `<Show>`/`<Edit>` record flows in — the
+ * query options are wrapped in a `computed` so vue-query re-subscribes on a new
+ * queryKey (the reactive-options pattern), matching how the React twin re-keys on
+ * a changed `record` prop.
+ */
+import { type CanAccessParams } from "@chelone/core";
+import { type ComputedRef, type MaybeRefOrGetter } from "vue";
+export interface MenuAccessResult {
+    /** Whether the current user may perform the action (reactive). */
+    canAccess: ComputedRef<boolean>;
+    /** Whether the access check is still resolving (reactive; false with no auth). */
+    isPending: ComputedRef<boolean>;
+}
+/**
+ * Resolve `canAccess` for a menu item / button, tolerating a missing authProvider.
+ * `enabled` (default true) skips the access query while false, so a caller that
+ * does not need the answer fires no `canAccess` call; `isPending` is then false.
+ */
+export declare function useMenuAccess(params: MaybeRefOrGetter<CanAccessParams>, enabled?: MaybeRefOrGetter<boolean>): MenuAccessResult;

package/dist/components/admin/layout/use-menu-access.js

@@ -0,0 +1,33 @@
+import { canAccessQueryOptions } from "@chelone/core";
+import { useQuery } from "@tanstack/vue-query";
+import { computed, toValue } from "vue";
+import { useCheloneContext } from "../../../context.js";
+function useMenuAccess(params, enabled = true) {
+  const { authProvider } = useCheloneContext();
+  const hasControl = authProvider?.canAccess != null;
+  const query = useQuery(
+    computed(() => ({
+      // A stub provider satisfies the option factory's type when none is
+      // configured; the query is disabled in that case so it never runs.
+      ...canAccessQueryOptions(
+        authProvider ?? {},
+        toValue(params)
+      ),
+      enabled: hasControl && toValue(enabled)
+    }))
+  );
+  return {
+    // No provider (or no canAccess method) → allow, never pending. This must win
+    // over vue-query's own `isPending` (a disabled, never-fetched query reports
+    // `isPending: true` — the undefined-tolerant contract overrides that).
+    canAccess: computed(
+      () => !hasControl ? true : query.data.value ?? false
+    ),
+    isPending: computed(
+      () => !hasControl || !toValue(enabled) ? false : query.isPending.value
+    )
+  };
+}
+export {
+  useMenuAccess
+};

package/dist/components/admin/layout/user-menu-inner.vue.d.ts

@@ -0,0 +1,23 @@
+type __VLS_Props = {
+    /** aria-label override for the trigger (translated). */
+    label?: string;
+    /**
+     * Whether `<UserMenu>` received custom children (forwarded through the default
+     * slot). Threaded as a prop — not read off this component's own slots — so the
+     * extra separator shows only for real children, since the forwarded `<slot />`
+     * is always defined even when empty.
+     */
+    hasChildren?: boolean;
+};
+declare var __VLS_41: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_41) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};