@hywax/cms-console 1.0.0

package/dist/runtime/components/DatePicker.vue

@@ -0,0 +1,232 @@
+<template>
+  <UPopover v-model:open="isOpen" @update:open="onUpdateOpen">
+    <UButton
+      :id="id"
+      class="w-full"
+      :ui="{ base: `hover:bg-[unset] active:bg-[unset] ${modelValue ? '' : ' text-dimmed'}` }"
+      :name="name"
+      :color="color"
+      :icon="appConfig.ui.icons.calendar"
+      variant="outline"
+      :disabled="disabled"
+      :size="size"
+      v-bind="ariaAttrs"
+    >
+      <span class="truncate">{{ textValue }} </span>
+    </UButton>
+
+    <template #content>
+      <UCalendar
+        v-bind="calendarProps"
+        :model-value="calendarValue"
+        :range="range"
+        :disabled="disabled"
+        :prevent-deselect="false"
+        :ui="{ root: 'p-2' }"
+        :max-value="calendarMaxValue"
+        :min-value="calendarMinValue"
+        @update:model-value="handleCalendarUpdate($event)"
+      />
+
+      <template v-if="withTime">
+        <USeparator
+          orientation="horizontal"
+        />
+
+        <div class="p-2 flex justify-between items-center gap-2">
+          <div class="text-sm">
+            Время
+          </div>
+
+          <UInputTime
+            v-if="!range"
+            :model-value="calendarValue"
+            :disabled="disabled"
+            size="sm"
+            @update:model-value="handleTimeUpdate($event)"
+          />
+          <div v-else class="flex gap-2">
+            <UInputTime
+              :model-value="calendarValue?.start"
+              :disabled="disabled || !calendarValue?.start"
+              size="sm"
+              @update:model-value="handleTimeUpdate($event, 'start')"
+            />
+
+            <span class="text-sm text-dimmed self-center">—</span>
+
+            <UInputTime
+              :model-value="calendarValue?.end"
+              :disabled="disabled || !calendarValue?.end"
+              size="sm"
+              @update:model-value="handleTimeUpdate($event, 'end')"
+            />
+          </div>
+        </div>
+      </template>
+    </template>
+  </UPopover>
+</template>
+
+<script>
+import { useAppConfig } from "#imports";
+import { CalendarDateTime, getLocalTimeZone } from "@internationalized/date";
+import { useFormField } from "@nuxt/ui/composables/useFormField";
+import { reactiveOmit } from "@vueuse/core";
+import { useForwardProps } from "reka-ui";
+import { computed, ref } from "vue";
+import { formatDate, formatServerDateTime } from "../utils";
+function createCalendarDate(value, withTime = true) {
+  const date = new Date(value);
+  if (withTime) {
+    return new CalendarDateTime(date.getFullYear(), date.getMonth() + 1, date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds());
+  }
+  return new CalendarDateTime(date.getFullYear(), date.getMonth() + 1, date.getDate());
+}
+</script>
+
+<script setup>
+const props = defineProps({
+  modelValue: { type: null, required: true },
+  id: { type: String, required: false },
+  name: { type: String, required: false },
+  withTime: { type: Boolean, required: false, default: true },
+  minValue: { type: String, required: false },
+  maxValue: { type: String, required: false },
+  as: { type: null, required: false },
+  nextYearIcon: { type: null, required: false },
+  nextYear: { type: Object, required: false },
+  nextMonthIcon: { type: null, required: false },
+  nextMonth: { type: Object, required: false },
+  prevYearIcon: { type: null, required: false },
+  prevYear: { type: Object, required: false },
+  prevMonthIcon: { type: null, required: false },
+  prevMonth: { type: Object, required: false },
+  color: { type: null, required: false, default: "neutral" },
+  variant: { type: null, required: false },
+  size: { type: null, required: false },
+  range: { type: Boolean, required: false },
+  monthControls: { type: Boolean, required: false },
+  yearControls: { type: Boolean, required: false },
+  defaultValue: { type: null, required: false },
+  class: { type: null, required: false },
+  ui: { type: null, required: false },
+  defaultPlaceholder: { type: null, required: false },
+  placeholder: { type: null, required: false },
+  allowNonContiguousRanges: { type: Boolean, required: false },
+  pagedNavigation: { type: Boolean, required: false },
+  preventDeselect: { type: Boolean, required: false },
+  maximumDays: { type: Number, required: false },
+  weekStartsOn: { type: Number, required: false },
+  weekdayFormat: { type: String, required: false },
+  fixedWeeks: { type: Boolean, required: false },
+  numberOfMonths: { type: Number, required: false },
+  disabled: { type: Boolean, required: false },
+  readonly: { type: Boolean, required: false },
+  initialFocus: { type: Boolean, required: false },
+  isDateDisabled: { type: Function, required: false },
+  isDateUnavailable: { type: Function, required: false },
+  isDateHighlightable: { type: Function, required: false },
+  nextPage: { type: Function, required: false },
+  prevPage: { type: Function, required: false },
+  disableDaysOutsideCurrentView: { type: Boolean, required: false },
+  fixedDate: { type: String, required: false }
+});
+const emit = defineEmits(["update:modelValue", "change", "blur", "focus"]);
+const appConfig = useAppConfig();
+const calendarProps = useForwardProps(reactiveOmit(props, "modelValue", "id", "name", "withTime", "minValue", "maxValue"));
+const {
+  id,
+  name,
+  color,
+  disabled,
+  ariaAttrs,
+  size,
+  emitFormBlur,
+  emitFormChange,
+  emitFormFocus,
+  emitFormInput
+} = useFormField(props);
+const isOpen = ref(false);
+function isRange() {
+  return !!props.range;
+}
+const textValue = computed(() => {
+  if (!props.modelValue) {
+    return "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0434\u0430\u0442\u0443";
+  }
+  if (!isRange(props.modelValue)) {
+    return formatDate(props.modelValue);
+  }
+  return `${formatDate(props.modelValue.start)} - ${formatDate(props.modelValue.end)}`;
+});
+const calendarValue = computed(() => {
+  if (!props.modelValue) {
+    return void 0;
+  }
+  if (!isRange(props.modelValue)) {
+    return createCalendarDate(props.modelValue);
+  }
+  return {
+    start: createCalendarDate(props.modelValue.start),
+    end: createCalendarDate(props.modelValue.end)
+  };
+});
+const calendarMinValue = computed(
+  () => props.minValue ? createCalendarDate(props.minValue, false) : void 0
+);
+const calendarMaxValue = computed(
+  () => props.maxValue ? createCalendarDate(props.maxValue, false) : void 0
+);
+function onUpdateOpen(value) {
+  if (!value) {
+    const event = new FocusEvent("blur");
+    emit("blur", event);
+    emitFormBlur();
+  } else {
+    const event = new FocusEvent("focus");
+    emit("focus", event);
+    emitFormFocus();
+  }
+}
+function onUpdate(value) {
+  emit("update:modelValue", value);
+  emit("change", new Event("change", { target: { value } }));
+  emitFormChange();
+  emitFormInput();
+}
+function handleCalendarUpdate(calendarValue2, setInitialTime = true) {
+  if (!calendarValue2) {
+    onUpdate(void 0);
+    return;
+  }
+  if (isRange(calendarValue2) && (!calendarValue2.start || !calendarValue2.end)) {
+    return;
+  }
+  if (isRange(calendarValue2)) {
+    const endDate = calendarValue2.end.toDate(getLocalTimeZone());
+    setInitialTime && endDate.setHours(23, 59, 59, 999);
+    const value = {
+      start: formatServerDateTime(calendarValue2.start.toDate(getLocalTimeZone())),
+      end: formatServerDateTime(endDate)
+    };
+    onUpdate(value);
+  } else {
+    onUpdate(formatServerDateTime(calendarValue2.toDate(getLocalTimeZone())));
+  }
+}
+function handleTimeUpdate(timeValue, type) {
+  if (!timeValue) {
+    return;
+  }
+  if (!type) {
+    return handleCalendarUpdate(timeValue);
+  }
+  const otherType = type === "start" ? "end" : "start";
+  const value = {
+    [type]: timeValue,
+    [otherType]: calendarValue.value?.[otherType]
+  };
+  handleCalendarUpdate(value, false);
+}
+</script>

package/dist/runtime/components/DatePicker.vue.d.ts

@@ -0,0 +1,43 @@
+import type { DateValue } from '@internationalized/date';
+import type { CalendarProps } from '@nuxt/ui';
+import type { DateRange as CalendarDateRange } from 'reka-ui';
+import type { DateRange, DateType } from '../types';
+export type CalendarValue = DateValue | CalendarDateRange;
+export type ModelValue<R extends boolean> = (R extends true ? DateRange : DateType) | undefined;
+export interface DatePickerProps<R extends boolean> extends Omit<CalendarProps<R, false>, 'modelValue' | 'multiple' | 'minValue' | 'maxValue'> {
+    modelValue: ModelValue<R>;
+    id?: string;
+    name?: string;
+    withTime?: boolean;
+    minValue?: DateType;
+    maxValue?: DateType;
+}
+export interface DatePickerEmits<R extends boolean> {
+    'update:modelValue': [value: ModelValue<R>];
+    'change': [event: Event];
+    'blur': [event: FocusEvent];
+    'focus': [event: FocusEvent];
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <R extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<DatePickerProps<R> & {
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: ModelValue<R>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "blur", event: FocusEvent) => void) & ((evt: "change", event: Event) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "update:modelValue", value: ModelValue<R>) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/components/EditorFull.d.vue.ts

@@ -0,0 +1,13 @@
+import type { EditorCustomHandlers, EditorEmits, EditorProps } from '@nuxt/ui';
+export interface EditorFullProps extends Omit<EditorProps, 'autofocus' | 'contentType' | 'placeholder'> {
+    customHandlers?: EditorCustomHandlers;
+}
+export interface EditorFullEmits extends EditorEmits {
+}
+declare const __VLS_export: import("vue").DefineComponent<EditorFullProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("@tiptap/core").Content) => any;
+}, string, import("vue").PublicProps, Readonly<EditorFullProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("@tiptap/core").Content) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/EditorFull.vue

@@ -0,0 +1,139 @@
+<template>
+  <UEditor
+    v-slot="{ editor, handlers }"
+    v-bind="forwarded"
+    :extensions="extensions"
+    :handlers="customHandlers"
+    class="min-h-screen"
+    content-type="markdown"
+    placeholder="Введите '/' для выбора блока..."
+    autofocus
+  >
+    <UEditorDragHandle
+      v-slot="{ ui, onClick }"
+      :editor="editor"
+      @node-change="onNodeChange"
+    >
+      <UButton
+        :icon="appConfig.ui.icons.plus"
+        color="neutral"
+        variant="ghost"
+        size="sm"
+        :class="ui.handle()"
+        @click="(e) => {
+  e.stopPropagation();
+  const node = onClick();
+  handlers.suggestion?.execute(editor, { pos: node?.pos }).run();
+}"
+      />
+
+      <UDropdownMenu
+        v-slot="{ open }"
+        :modal="false"
+        :items="getDragHandleItems(editor)"
+        :content="{ side: 'left' }"
+        :ui="{ content: 'w-48', label: 'text-xs' }"
+        @update:open="editor.chain().setMeta('lockDragHandle', $event).run()"
+      >
+        <UButton
+          color="neutral"
+          variant="ghost"
+          active-variant="soft"
+          size="sm"
+          :icon="appConfig.ui.icons.drag"
+          :active="open"
+          :class="ui.handle()"
+        />
+      </UDropdownMenu>
+    </UEditorDragHandle>
+
+    <UEditorToolbar
+      layout="bubble"
+      :editor="editor"
+      :items="bubbleToolbarItems"
+      :should-show="({ view, state }) => {
+  if (editor.isActive('uploraImage')) {
+    return false;
+  }
+  const { selection } = state;
+  return view.hasFocus() && !selection.empty;
+}"
+    >
+      <template #link>
+        <EditorLinkPopover :editor="editor" />
+      </template>
+    </UEditorToolbar>
+
+    <UEditorSuggestionMenu
+      :editor="editor"
+      :items="suggestionItems"
+      :append-to-body="appendToBody"
+    />
+  </UEditor>
+</template>
+
+<script setup>
+import { useAppConfig } from "#imports";
+import { reactiveOmit } from "@vueuse/core";
+import { useForwardPropsEmits } from "reka-ui";
+import { computed } from "vue";
+import { useEditorDragHandle } from "../composables/useEditorDragHandle";
+import { useEditorSuggestions } from "../composables/useEditorSuggestions";
+import { useEditorToolbar } from "../composables/useEditorToolbar";
+import { UploraImage as UploraImageExtension, UploraImageHandlers } from "../editor/uplora-image/EditorUploraImage";
+import EditorLinkPopover from "./EditorLinkPopover.vue";
+const props = defineProps({
+  customHandlers: { type: Object, required: false },
+  as: { type: null, required: false },
+  modelValue: { type: null, required: false },
+  starterKit: { type: Object, required: false },
+  markdown: { type: Object, required: false },
+  image: { type: Object, required: false },
+  mention: { type: Object, required: false },
+  handlers: { type: null, required: false },
+  class: { type: null, required: false },
+  ui: { type: null, required: false },
+  extensions: { type: Array, required: false },
+  injectCSS: { type: Boolean, required: false },
+  injectNonce: { type: null, required: false },
+  editable: { type: Boolean, required: false },
+  textDirection: { type: String, required: false },
+  editorProps: { type: Object, required: false },
+  parseOptions: { type: Object, required: false },
+  coreExtensionOptions: { type: Object, required: false },
+  enableInputRules: { type: [Array, Boolean], required: false },
+  enablePasteRules: { type: [Array, Boolean], required: false },
+  enableCoreExtensions: { type: [Boolean, Object], required: false },
+  enableContentCheck: { type: Boolean, required: false },
+  emitContentError: { type: Boolean, required: false },
+  onBeforeCreate: { type: Function, required: false },
+  onCreate: { type: Function, required: false },
+  onMount: { type: Function, required: false },
+  onUnmount: { type: Function, required: false },
+  onContentError: { type: Function, required: false },
+  onUpdate: { type: Function, required: false },
+  onSelectionUpdate: { type: Function, required: false },
+  onTransaction: { type: Function, required: false },
+  onFocus: { type: Function, required: false },
+  onBlur: { type: Function, required: false },
+  onDestroy: { type: Function, required: false },
+  onPaste: { type: Function, required: false },
+  onDrop: { type: Function, required: false },
+  onDelete: { type: Function, required: false }
+});
+const emit = defineEmits(["update:modelValue"]);
+const forwarded = useForwardPropsEmits(reactiveOmit(props, "extensions", "customHandlers", "handlers"), emit);
+const appConfig = useAppConfig();
+const extensions = computed(() => [
+  UploraImageExtension,
+  ...props.extensions || []
+]);
+const customHandlers = computed(() => ({
+  ...props.customHandlers || {},
+  ...UploraImageHandlers
+}));
+const appendToBody = false ? () => document.body : void 0;
+const { items: suggestionItems } = useEditorSuggestions(customHandlers);
+const { getItems: getDragHandleItems, onNodeChange } = useEditorDragHandle(props.customHandlers);
+const { bubbleToolbarItems } = useEditorToolbar(props.customHandlers);
+</script>

package/dist/runtime/components/EditorFull.vue.d.ts

@@ -0,0 +1,13 @@
+import type { EditorCustomHandlers, EditorEmits, EditorProps } from '@nuxt/ui';
+export interface EditorFullProps extends Omit<EditorProps, 'autofocus' | 'contentType' | 'placeholder'> {
+    customHandlers?: EditorCustomHandlers;
+}
+export interface EditorFullEmits extends EditorEmits {
+}
+declare const __VLS_export: import("vue").DefineComponent<EditorFullProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("@tiptap/core").Content) => any;
+}, string, import("vue").PublicProps, Readonly<EditorFullProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("@tiptap/core").Content) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/EditorLinkPopover.d.vue.ts

@@ -0,0 +1,8 @@
+import type { Editor } from '@tiptap/vue-3';
+type __VLS_Props = {
+    editor: Editor;
+    autoOpen?: boolean;
+};
+declare const __VLS_export: 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: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/EditorLinkPopover.vue

@@ -0,0 +1,137 @@
+<template>
+  <UPopover
+    v-model:open="open"
+    :ui="{ content: 'p-0.5' }"
+  >
+    <UTooltip text="Ссылка">
+      <UButton
+        :icon="appConfig.ui.icons.link"
+        color="neutral"
+        active-color="primary"
+        variant="ghost"
+        active-variant="soft"
+        size="sm"
+        :active="active"
+        :disabled="disabled"
+      />
+    </UTooltip>
+
+    <template #content>
+      <UInput
+        v-model="url"
+        autofocus
+        name="url"
+        type="url"
+        variant="none"
+        placeholder="Выставить ссылку..."
+        @keydown="handleKeyDown"
+      >
+        <div class="flex items-center mr-0.5">
+          <UButton
+            :icon="appConfig.ui.icons.enter"
+            variant="ghost"
+            size="sm"
+            :disabled="!url && !active"
+            title="Выставить ссылку"
+            @click="setLink"
+          />
+
+          <USeparator
+            orientation="vertical"
+            class="h-6 mx-1"
+          />
+
+          <UButton
+            :icon="appConfig.ui.icons.external"
+            color="neutral"
+            variant="ghost"
+            size="sm"
+            :disabled="!url && !active"
+            title="Открыть в новом окне"
+            @click="openLink"
+          />
+
+          <UButton
+            :icon="appConfig.ui.icons.trash"
+            color="neutral"
+            variant="ghost"
+            size="sm"
+            :disabled="!url && !active"
+            title="Удалить ссылку"
+            @click="removeLink"
+          />
+        </div>
+      </UInput>
+    </template>
+  </UPopover>
+</template>
+
+<script setup>
+import { useAppConfig } from "#imports";
+import { computed, ref, watch } from "vue";
+const props = defineProps({
+  editor: { type: Object, required: true },
+  autoOpen: { type: Boolean, required: false }
+});
+const appConfig = useAppConfig();
+const open = ref(false);
+const url = ref("");
+const active = computed(() => props.editor.isActive("link"));
+const disabled = computed(() => {
+  if (!props.editor.isEditable) {
+    return true;
+  }
+  const { selection } = props.editor.state;
+  return selection.empty && !props.editor.isActive("link");
+});
+watch(() => props.editor, (editor, _, onCleanup) => {
+  if (!editor) {
+    return;
+  }
+  const updateUrl = () => {
+    const { href } = editor.getAttributes("link");
+    url.value = href || "";
+  };
+  updateUrl();
+  editor.on("selectionUpdate", updateUrl);
+  onCleanup(() => {
+    editor.off("selectionUpdate", updateUrl);
+  });
+}, { immediate: true });
+watch(active, (isActive) => {
+  if (isActive && props.autoOpen) {
+    open.value = true;
+  }
+});
+function setLink() {
+  if (!url.value) {
+    return;
+  }
+  const { selection } = props.editor.state;
+  const isEmpty = selection.empty;
+  let chain = props.editor.chain().focus();
+  chain = chain.extendMarkRange("link").setLink({ href: url.value });
+  if (isEmpty) {
+    chain = chain.insertContent({ type: "text", text: url.value });
+  }
+  chain.run();
+  open.value = false;
+}
+function removeLink() {
+  props.editor.chain().focus().extendMarkRange("link").unsetLink().setMeta("preventAutolink", true).run();
+  url.value = "";
+  open.value = false;
+}
+function openLink() {
+  if (!url.value) {
+    return;
+  }
+  window.open(url.value, "_blank", "noopener,noreferrer");
+}
+function handleKeyDown(event) {
+  if (event.key === "Enter") {
+    event.preventDefault();
+    setLink();
+  }
+}
+</script>

package/dist/runtime/components/EditorLinkPopover.vue.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from '@tiptap/vue-3';
+type __VLS_Props = {
+    editor: Editor;
+    autoOpen?: boolean;
+};
+declare const __VLS_export: 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: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/FormPanel.d.vue.ts

@@ -0,0 +1,47 @@
+import type { ComponentConfig } from '@hywax/cms-runtime';
+import type { AppConfig } from '@nuxt/schema';
+import type { FormData, FormSchema, FormSubmitEvent } from '@nuxt/ui';
+import type { RouteLocationRaw } from 'vue-router';
+import theme from '#build/cms-console/form-panel';
+type FormPanel = ComponentConfig<typeof theme, AppConfig, 'formPanel'>;
+export interface FormPanelProps<S extends FormSchema, T extends FormData<S> = FormData<S>> {
+    title?: string;
+    toBack?: RouteLocationRaw;
+    formId?: string;
+    schema: S;
+    state: Partial<T>;
+    loading?: boolean;
+    handler: (event: FormSubmitEvent<T>) => Promise<void>;
+    asideDivide?: boolean;
+    showReset?: boolean;
+    class?: any;
+    ui?: FormPanel['slots'];
+}
+export interface FormPanelEmits<S extends FormSchema, T extends FormData<S> = FormData<S>> {
+    'update:state': [value: T];
+}
+export interface FormPanelSlots {
+    default?: () => any;
+    sidebar?: () => any;
+    actions?: () => any;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <S extends FormSchema, T extends FormData<S> = FormData<S>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<FormPanelProps<S, T> & {
+        "onUpdate:state"?: ((value: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: FormPanelSlots;
+    emit: (evt: "update:state", value: T) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};