@lupinum/ginko-content 0.1.0

package/dist/runtime/app/components/internal/MarkdownRenderer.d.ts

@@ -0,0 +1,90 @@
+import type { PropType, VNode } from 'vue';
+import type { MarkdownRoot } from '../../../../types/content';
+export declare function localizeMarkdownNodeProps(props: Record<string, any>, locale?: string, defaultLocale?: string, locales?: string[]): Record<string, any>;
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    tree: {
+        type: PropType<MarkdownRoot>;
+        required: true;
+    };
+    components: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    prose: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: {
+        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    dataContentId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultLocale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    locales: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    tree: {
+        type: PropType<MarkdownRoot>;
+        required: true;
+    };
+    components: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    prose: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: {
+        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    dataContentId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultLocale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    locales: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    defaultLocale: string;
+    locales: string[];
+    locale: string;
+    class: string | unknown[] | Record<string, any>;
+    components: Record<string, any>;
+    prose: boolean | undefined;
+    tag: string;
+    dataContentId: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/app/components/internal/MarkdownRenderer.js

@@ -0,0 +1,191 @@
+import { defineComponent, getCurrentInstance, h } from "vue";
+import { kebabCase, pascalCase } from "scule";
+import htmlTags from "../../../../integrations/vue/html-tags.js";
+import { localizeLinkProps } from "../../../../features/localization/links";
+function parsePropValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+export function localizeMarkdownNodeProps(props, locale, defaultLocale, locales = []) {
+  if (!locale || props == null || Object.keys(props).length === 0) {
+    return props;
+  }
+  const localizedProps = structuredClone(props);
+  localizeLinkProps(localizedProps, locale, defaultLocale, locales);
+  return localizedProps;
+}
+function resolveVueComponent(name, components, registry, prose, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(name)) {
+    return null;
+  }
+  seen.add(name);
+  const candidates = [
+    name,
+    pascalCase(name),
+    kebabCase(name)
+  ];
+  if (prose !== false) {
+    candidates.unshift(`Prose${pascalCase(name)}`);
+  }
+  for (const candidate of candidates) {
+    const explicit = components[candidate];
+    if (explicit) {
+      if (typeof explicit === "string" && explicit !== candidate && !htmlTags.includes(explicit)) {
+        return resolveVueComponent(explicit, components, registry, prose, seen) || explicit;
+      }
+      return explicit;
+    }
+  }
+  for (const candidate of candidates) {
+    const registered = registry[candidate];
+    if (registered) {
+      return registered;
+    }
+  }
+  return null;
+}
+function renderNode(node, options, key, parent) {
+  if (node.type === "text") {
+    return node.value || "";
+  }
+  const tag = node.tag;
+  if (!tag) {
+    return null;
+  }
+  const nodeProps = localizeMarkdownNodeProps(
+    node.props || {},
+    options.locale,
+    options.defaultLocale,
+    options.locales
+  );
+  const children = node.children || [];
+  let component = tag;
+  if (parent?.tag === "pre") {
+    component = tag;
+  } else {
+    const resolvedAs = typeof nodeProps.as === "string" ? resolveVueComponent(nodeProps.as, options.components, options.registry, options.prose) : null;
+    const resolvedComponent = resolvedAs || resolveVueComponent(tag, options.components, options.registry, options.prose);
+    if (resolvedComponent) {
+      component = resolvedComponent;
+    } else if (htmlTags.includes(tag)) {
+      component = tag;
+    }
+  }
+  const props = {};
+  for (const propKey in nodeProps) {
+    if (propKey === "$") {
+      continue;
+    }
+    if (propKey === "className") {
+      props.class = nodeProps[propKey];
+    } else if (propKey.startsWith(":") && typeof nodeProps[propKey] === "string") {
+      props[propKey.slice(1)] = parsePropValue(nodeProps[propKey]);
+    } else {
+      props[propKey] = nodeProps[propKey];
+    }
+  }
+  if (key !== void 0) {
+    props.key = key;
+  }
+  if (component?.props?.__node || component?.__asyncResolved?.props?.__node) {
+    props.__node = node;
+  }
+  if (children.length === 0) {
+    return h(component, props);
+  }
+  const slots = {};
+  const regularChildren = [];
+  for (let index = 0; index < children.length; index++) {
+    const child = children[index];
+    if (child == null) {
+      continue;
+    }
+    const childTag = child.tag;
+    const childProps = child.props || {};
+    if (childTag === "template") {
+      const slotName = typeof childProps.name === "string" ? childProps.name : Object.keys(childProps).find((key2) => key2.startsWith("v-slot:"))?.slice(7);
+      if (slotName) {
+        const slotChildren = (child.children || []).map((slotChild, slotIndex) => renderNode(slotChild, options, slotIndex, node)).filter((slotChild) => slotChild !== null);
+        slots[slotName] = () => slotChildren;
+        continue;
+      }
+    }
+    const rendered = renderNode(child, options, index, node);
+    if (rendered !== null) {
+      regularChildren.push(rendered);
+    }
+  }
+  if (typeof component !== "string" || !htmlTags.includes(component)) {
+    if (regularChildren.length > 0) {
+      slots.default = () => regularChildren;
+    }
+    return h(component, props, slots);
+  }
+  return h(component, props, regularChildren);
+}
+export default defineComponent({
+  name: "MarkdownRenderer",
+  props: {
+    tree: {
+      type: Object,
+      required: true
+    },
+    components: {
+      type: Object,
+      default: () => ({})
+    },
+    prose: {
+      type: Boolean,
+      default: void 0
+    },
+    tag: {
+      type: String,
+      default: "div"
+    },
+    class: {
+      type: [String, Array, Object],
+      default: void 0
+    },
+    dataContentId: {
+      type: String,
+      default: void 0
+    },
+    locale: {
+      type: String,
+      default: void 0
+    },
+    defaultLocale: {
+      type: String,
+      default: void 0
+    },
+    locales: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(props) {
+    const registry = getCurrentInstance()?.appContext?.components || {};
+    const attrs = getCurrentInstance()?.attrs || {};
+    return () => {
+      const children = (props.tree.children || []).map((node, index) => renderNode(node, {
+        components: props.components,
+        registry,
+        prose: props.prose,
+        locale: props.locale,
+        defaultLocale: props.defaultLocale,
+        locales: props.locales
+      }, index)).filter((child) => child !== null);
+      return h(props.tag, {
+        class: props.class,
+        "data-content-id": props.dataContentId,
+        ...attrs
+      }, children);
+    };
+  }
+});

package/dist/runtime/app/composables/async-data

@@ -0,0 +1 @@
+export * from './async-data.js'

package/dist/runtime/app/composables/async-data.d.ts

@@ -0,0 +1,2 @@
+import { useAsyncData } from '#imports';
+export declare function useContentAsyncData<T>(...args: Parameters<typeof useAsyncData<T>>): any;

package/dist/runtime/app/composables/async-data.js

@@ -0,0 +1,4 @@
+import { useAsyncData } from "#imports";
+export function useContentAsyncData(...args) {
+  return useAsyncData(...args);
+}

package/dist/runtime/app/composables/content-i18n

@@ -0,0 +1 @@
+export * from './content-i18n.js'

package/dist/runtime/app/composables/content-i18n.d.ts

@@ -0,0 +1,5 @@
+declare module '#build/content-i18n.mjs' {
+  export function useRouteBaseName(): (route: { name?: unknown } | unknown) => string | undefined
+  export function useSetI18nParams(): (params: Record<string, unknown>) => void
+  export function useSwitchLocalePath(): (locale: string) => string
+}

package/dist/runtime/app/composables/content-i18n.js

@@ -0,0 +1 @@
+export { useRouteBaseName, useSetI18nParams, useSwitchLocalePath } from "#build/content-i18n.mjs";

package/dist/runtime/app/composables/head

@@ -0,0 +1 @@
+export * from './head.js'

package/dist/runtime/app/composables/head.d.ts

@@ -0,0 +1,11 @@
+import type { RouteLocationNormalized, RouteLocationNormalizedLoaded } from 'vue-router';
+import type { Ref } from 'vue';
+import type { ParsedContent } from '../../../types/content';
+/**
+ * Apply sensible page head defaults from a parsed content document.
+ *
+ * The composable merges explicit `content.head` values with common fallbacks
+ * from the document (`title`, `description`, `image`) and adds canonical /
+ * Open Graph URL metadata when a public site URL is configured.
+ */
+export declare const useContentHead: (_content: ParsedContent | Ref<ParsedContent>, to?: RouteLocationNormalized | RouteLocationNormalizedLoaded) => void;

package/dist/runtime/app/composables/head.js

@@ -0,0 +1,98 @@
+import { hasProtocol, joinURL, withoutTrailingSlash } from "ufo";
+import { useRoute, nextTick, useHead, unref, watch, useRuntimeConfig } from "#imports";
+function isHeadImageObject(image) {
+  return typeof image === "object" && image !== null;
+}
+export const useContentHead = (_content, to = useRoute()) => {
+  const content = unref(_content);
+  const config = useRuntimeConfig();
+  const appConfig = config.app;
+  const applyHead = (head) => useHead(head);
+  const refreshHead = (data = content) => {
+    if (!to.path || !data) {
+      return;
+    }
+    const head = Object.assign({}, data?.head || {});
+    head.meta = [...head.meta || []];
+    head.link = [...head.link || []];
+    const title = head.title || data?.title;
+    if (title) {
+      head.title = title;
+      if (import.meta.server && !head.meta.some((m) => m.property === "og:title")) {
+        head.meta.push({
+          property: "og:title",
+          content: title
+        });
+      }
+    }
+    const siteUrl = typeof config.public.siteUrl === "string" ? withoutTrailingSlash(config.public.siteUrl) : void 0;
+    if (import.meta.server && siteUrl) {
+      const url = withoutTrailingSlash(joinURL(siteUrl, appConfig.baseURL, to.fullPath));
+      if (!head.meta.some((m) => m.property === "og:url")) {
+        head.meta.push({
+          property: "og:url",
+          content: url
+        });
+      }
+      if (!head.link.some((m) => m.rel === "canonical")) {
+        head.link.push({
+          rel: "canonical",
+          href: url
+        });
+      }
+    }
+    const description = head?.description || data?.description;
+    if (description && head.meta.filter((m) => m.name === "description").length === 0) {
+      head.meta.push({
+        name: "description",
+        content: description
+      });
+    }
+    if (import.meta.server && description && !head.meta.some((m) => m.property === "og:description")) {
+      head.meta.push({
+        property: "og:description",
+        content: description
+      });
+    }
+    const image = head?.image || data?.image;
+    if (import.meta.server && image && head.meta.filter((m) => m.property === "og:image").length === 0) {
+      if (typeof image === "string") {
+        head.meta.push({
+          property: "og:image",
+          content: siteUrl && !hasProtocol(image) ? new URL(joinURL(appConfig.baseURL, image), siteUrl).href : image
+        });
+      }
+      if (isHeadImageObject(image)) {
+        const imageKeys = [
+          "src",
+          "secure_url",
+          "type",
+          "width",
+          "height",
+          "alt"
+        ];
+        for (const key of imageKeys) {
+          if (key === "src" && image.src) {
+            const isAbsoluteURL = hasProtocol(image.src);
+            const imageURL = isAbsoluteURL ? image.src : joinURL(appConfig.baseURL, image.src ?? "/");
+            head.meta.push({
+              property: "og:image",
+              content: siteUrl && !isAbsoluteURL ? new URL(imageURL, siteUrl).href : imageURL
+            });
+          } else if (image[key]) {
+            head.meta.push({
+              property: `og:image:${key}`,
+              content: image[key]
+            });
+          }
+        }
+      }
+    }
+    if (import.meta.client) {
+      nextTick(() => applyHead(head));
+    } else {
+      applyHead(head);
+    }
+  };
+  watch(() => unref(_content), refreshHead, { immediate: true });
+};

package/dist/runtime/app/composables/locale

@@ -0,0 +1 @@
+export * from './locale.js'

package/dist/runtime/app/composables/locale-context

@@ -0,0 +1 @@
+export * from './locale-context.js'

package/dist/runtime/app/composables/locale-context.d.ts

@@ -0,0 +1,5 @@
+export declare function getLocaleContext(): {
+    route: any;
+    nuxtApp: any;
+    resolvedLocaleState: any;
+};

package/dist/runtime/app/composables/locale-context.js

@@ -0,0 +1,8 @@
+import { useNuxtApp, useRoute, useState } from "#imports";
+export function getLocaleContext() {
+  return {
+    route: useRoute(),
+    nuxtApp: useNuxtApp(),
+    resolvedLocaleState: useState("$si18n:resolved-locale")
+  };
+}

package/dist/runtime/app/composables/locale.d.ts

@@ -0,0 +1,8 @@
+import { normalizeContentPath } from '../../../features/localization/path';
+export { normalizeContentPath };
+export declare const resolveActiveLocale: (locales: string[], defaultLocale?: string) => any;
+export declare const resolveRouteContent: (path: string, locales: string[], defaultLocale?: string) => {
+    locale: string | undefined;
+    path: string;
+    routePath: string;
+};

package/dist/runtime/app/composables/locale.js

@@ -0,0 +1,15 @@
+import { getLocaleContext } from "./locale-context.js";
+import { normalizeContentPath, resolveRouteContent as resolveLocalizedRouteContent } from "../../../features/localization/path";
+export { normalizeContentPath };
+export const resolveActiveLocale = (locales, defaultLocale) => {
+  const { route, nuxtApp, resolvedLocaleState } = getLocaleContext();
+  const i18nLocale = nuxtApp.$i18n?.locale;
+  const explicitLocale = typeof i18nLocale === "string" ? i18nLocale : i18nLocale?.value || resolvedLocaleState.value;
+  if (explicitLocale && locales.includes(explicitLocale)) {
+    return explicitLocale;
+  }
+  const segments = route.path.split("/").filter(Boolean);
+  const routeLocale = segments[0] && locales.includes(segments[0]) ? segments[0] : void 0;
+  return routeLocale || defaultLocale;
+};
+export const resolveRouteContent = (path, locales, defaultLocale) => resolveLocalizedRouteContent(path, locales, defaultLocale, resolveActiveLocale(locales, defaultLocale));

package/dist/runtime/app/composables/navigation

@@ -0,0 +1 @@
+export * from './navigation.js'

package/dist/runtime/app/composables/navigation.d.ts

@@ -0,0 +1,3 @@
+import type { NavItem } from '../../../types/content';
+import type { ContentQueryRequest } from '../../../types/query';
+export declare const fetchNavigationPayload: (queryBuilder: ContentQueryRequest) => Promise<Array<NavItem>>;

package/dist/runtime/app/composables/navigation.js

@@ -0,0 +1,7 @@
+import { fetchContentApi, getContentApiFetcher } from "./utils.js";
+export const fetchNavigationPayload = async (queryBuilder) => {
+  const params = queryBuilder.params();
+  return await fetchContentApi("navigation", params, {
+    fetcher: getContentApiFetcher()
+  });
+};

package/dist/runtime/app/composables/preview

@@ -0,0 +1 @@
+export * from './preview.js'

package/dist/runtime/app/composables/preview.d.ts

@@ -0,0 +1,5 @@
+export declare const useContentPreview: () => {
+    isEnabled: () => boolean;
+    getPreviewToken: () => any;
+    setPreviewToken: (token: string | undefined) => void;
+};

package/dist/runtime/app/composables/preview.js

@@ -0,0 +1,52 @@
+const lookupGlobal = (name) => {
+  const fn = globalThis[name];
+  return typeof fn === "function" ? fn : void 0;
+};
+const cookie = (name) => {
+  const useCookie = lookupGlobal("useCookie");
+  return useCookie ? useCookie(name) : { value: null };
+};
+const route = () => {
+  const useRoute = lookupGlobal("useRoute");
+  return useRoute ? useRoute() : { query: {} };
+};
+let showWarning = true;
+export const useContentPreview = () => {
+  const getPreviewToken = () => {
+    return cookie("previewToken").value || import.meta.client && sessionStorage.getItem("previewToken") || void 0;
+  };
+  const setPreviewToken = (token) => {
+    cookie("previewToken").value = token ?? null;
+    route().query.preview = token || "";
+    if (import.meta.client) {
+      if (token) {
+        sessionStorage.setItem("previewToken", token);
+      } else {
+        sessionStorage.removeItem("previewToken");
+      }
+      window.location.reload();
+    }
+  };
+  const isEnabled = () => {
+    const query = route().query;
+    if (Object.prototype.hasOwnProperty.call(query, "preview") && !query.preview) {
+      return false;
+    }
+    if (query.preview || cookie("previewToken").value) {
+      if (import.meta.dev && showWarning) {
+        console.warn("[content] Preview mode enabled since a preview token is set (either in query or cookie).");
+        showWarning = false;
+      }
+      return true;
+    }
+    if (import.meta.client && sessionStorage.getItem("previewToken")) {
+      return true;
+    }
+    return false;
+  };
+  return {
+    isEnabled,
+    getPreviewToken,
+    setPreviewToken
+  };
+};

package/dist/runtime/app/composables/query-api

@@ -0,0 +1 @@
+export * from './query-api.js'

package/dist/runtime/app/composables/query-api.d.ts

@@ -0,0 +1,27 @@
+import type { ParsedContent } from '../../../types/content';
+import type { ContentCollectionHandle } from '../../../types/config';
+import type { ContentVariant, ContentTreeItem, BacklinksOptions, BacklinksResult, BacklinkSource, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../../types/query';
+import { type ContentQueryContext } from '../../query/unified';
+export declare const createClientContentQueryContext: () => ContentQueryContext;
+export declare function resolveOne<const H extends ContentCollectionHandle | string, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(handle: H, options: O): Promise<ResolveOneResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+export declare function one<const H extends ContentCollectionHandle | string, O extends OneOptions<H, PopulateSpec | undefined>>(handle: H, options: O): Promise<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>> | null>;
+export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(handle: H, options?: O & ManyOptions<H, PopulateSpec | undefined>): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
+export declare function paginate<const H extends ContentCollectionHandle | string, O extends PaginationOptions<H, PopulateSpec | undefined>>(handle: H, options: O): Promise<PaginationResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+export declare function backlinks<const Target extends ContentCollectionHandle | string, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(handle: Target, options: BacklinksOptions<Target, Source, P>): Promise<BacklinksResult<Source, P>>;
+export declare function variants<H extends ContentCollectionHandle | string>(handle: H, options: VariantsOptions<H>): Promise<Array<ContentVariant<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>>;
+export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+    fields?: Fields;
+}): Promise<ContentTreeItem<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent, Fields>[]>;
+export declare function neighbors<H extends ContentCollectionHandle | string>(handle: H, options: NeighborsOptions<H>): Promise<NeighborsResult<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>;

package/dist/runtime/app/composables/query-api.js

@@ -0,0 +1,46 @@
+import { fetchContentApi, getContentApiFetcher } from "./utils.js";
+import { getContentRuntime } from "./runtime.js";
+import {
+  backlinks as backlinksWithContext,
+  many as manyWithContext,
+  neighbors as neighborsWithContext,
+  one as oneWithContext,
+  paginate as paginateWithContext,
+  resolveOne as resolveOneWithContext,
+  tree as treeWithContext,
+  variants as variantsWithContext
+} from "../../query/unified.js";
+export const createClientContentQueryContext = () => {
+  const runtime = getContentRuntime();
+  const fetcher = getContentApiFetcher();
+  return {
+    runtime,
+    transport: async (endpoint, params) => {
+      return await fetchContentApi(endpoint, params, { fetcher, runtime });
+    }
+  };
+};
+export async function resolveOne(handle, options) {
+  return await resolveOneWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function one(handle, options) {
+  return await oneWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function many(handle, options = {}) {
+  return await manyWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function paginate(handle, options) {
+  return await paginateWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function backlinks(handle, options) {
+  return await backlinksWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function variants(handle, options) {
+  return await variantsWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function tree(handle, options = {}) {
+  return await treeWithContext(createClientContentQueryContext(), handle, options);
+}
+export async function neighbors(handle, options) {
+  return await neighborsWithContext(createClientContentQueryContext(), handle, options);
+}

package/dist/runtime/app/composables/route

@@ -0,0 +1 @@
+export * from './route.js'

package/dist/runtime/app/composables/route.d.ts

@@ -0,0 +1,11 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+import type { ContentPageResult, ContentRouteMeta } from '../../../types/query';
+type ContentRouteValue = ContentRouteMeta | ContentPageResult | null | undefined;
+export declare function useContentSwitchLocalePath(): (locale: string) => string;
+export declare function useContentRoute(value: MaybeRefOrGetter<ContentRouteValue>): {
+    switchLocalePath: (locale: string) => string;
+    localePaths: ComputedRef<Record<string, string>>;
+    canonicalPath: ComputedRef<string | undefined>;
+    path: ComputedRef<string | undefined>;
+};
+export {};