@chelone/vue 0.6.0 → 0.9.0

package/dist/components/admin/inputs/file-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,194 @@
+import { useInput } from "../../../form/use-input.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { shallowEqual as shallowEqual$1 } from "../../../lib/shallow-equal.js";
+import { Field, FieldDescription, FieldError, FieldLabel } from "../../ui/field.js";
+import validation_error_default from "../common/validation-error.js";
+import file_input_preview_default from "./file-input-preview.js";
+import { humanizeSource } from "./label-text.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, ref, renderList, renderSlot, toDisplayString, unref, useSlots, withCtx, withModifiers } from "vue";
+import { fileEntryKey, toFileEntries, toFileSelection } from "@chelone/core";
+// src/components/admin/inputs/file-input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { key: 0 };
+var _hoisted_2 = [
+	"id",
+	"name",
+	"accept",
+	"multiple",
+	"disabled",
+	"aria-invalid"
+];
+var _hoisted_3 = { class: "text-sm" };
+var _hoisted_4 = {
+	key: 2,
+	"data-slot": "file-input-previews",
+	class: "previews flex flex-col gap-1"
+};
+var file_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "file-input",
+	props: {
+		resource: {},
+		helperText: {},
+		format: {},
+		parse: {},
+		accept: {},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		placeholder: {},
+		labelMultiple: { default: "ra.input.file.upload_several" },
+		labelSingle: { default: "ra.input.file.upload_single" },
+		class: {},
+		source: {},
+		label: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		defaultValue: {},
+		validate: {}
+	},
+	setup(__props) {
+		/**
+		* `<FileInput>` — a file-upload input with drag-and-drop + previews, the Vue
+		* analog of `@chelone/react`'s `inputs/file-input.tsx`.
+		*
+		* ## Divergence: native drag-drop, NOT react-dropzone
+		* The React twin is powered by `react-dropzone` (React-only). Vue cannot use it,
+		* so the drop UI is hand-rolled from native events: a `dragover`/`drop`-handling
+		* dropzone `<div>` plus a hidden `<input type=file>` triggered on click. The
+		* VALUE logic is unchanged from the twin — the same `transformFiles` `format`/
+		* `parse` (a dropped `File` → `{ rawFile, src, title }`), the same `multiple`
+		* append semantics, and the same `shallowEqual`-based removal. Only the drop
+		* SURFACE differs; the form binding is shared through {@link useInput}.
+		*
+		* Each existing/dropped file is published to a preview slot through a per-file
+		* {@link FileInputPreview} (which provides the file as the ambient record), so a
+		* preview child (a field, an `<img>`) renders it. `<ImageInput>` wraps this.
+		*/
+		const props = __props;
+		const translate = useTranslate();
+		const slots = useSlots();
+		const fileInputRef = ref(null);
+		const isDragging = ref(false);
+		/** Turn a browser `File` into the expected preview record (twin parity). */
+		function transformFile(file) {
+			if (!(file instanceof File)) return file;
+			return {
+				rawFile: file,
+				src: typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : "",
+				title: file.name
+			};
+		}
+		function transformFiles(files) {
+			if (!files) return props.multiple ? [] : null;
+			if (Array.isArray(files)) return files.map(transformFile);
+			return transformFile(files);
+		}
+		const { id, name, value, setValue, blur, error, touched, isRequired } = useInput({
+			source: props.source,
+			defaultValue: props.defaultValue,
+			validate: props.validate
+		});
+		const format = (selection) => (props.format ?? transformFiles)(selection);
+		const parse = (selection) => (props.parse ?? transformFiles)(selection);
+		const files = computed(() => toFileEntries(format(toFileSelection(value.value))));
+		const invalid = computed(() => touched.value && error.value != null);
+		const labelText = computed(() => props.label === false ? null : props.label ?? humanizeSource(props.source));
+		const promptText = computed(() => props.placeholder ?? translate(props.multiple ? props.labelMultiple : props.labelSingle, { _: props.multiple ? "Drop files to upload, or click to select one." : "Drop a file to upload, or click to select it." }));
+		const hasPreview = computed(() => slots.default != null);
+		const isDisabled = computed(() => props.disabled === true || props.readonly === true);
+		function commit(newFiles) {
+			if (newFiles.length === 0) return;
+			if (props.multiple) setValue(parse([...files.value, ...newFiles]));
+			else setValue(parse(newFiles[0] ?? null));
+			blur();
+		}
+		function onFileChange(event) {
+			const input = event.target;
+			commit(input.files ? Array.from(input.files) : []);
+			input.value = "";
+		}
+		function onDrop(event) {
+			isDragging.value = false;
+			if (isDisabled.value) return;
+			commit(event.dataTransfer?.files ? Array.from(event.dataTransfer.files) : []);
+		}
+		function onDragOver() {
+			if (!isDisabled.value) isDragging.value = true;
+		}
+		function onDragLeave() {
+			isDragging.value = false;
+		}
+		function openPicker() {
+			if (!isDisabled.value) fileInputRef.value?.click();
+		}
+		function onRemove(file) {
+			if (props.multiple) setValue(parse(files.value.filter((stateFile) => !shallowEqual$1(stateFile, file))));
+			else setValue(parse(null));
+			blur();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Field), {
+				class: normalizeClass([props.class, "w-full"]),
+				"data-invalid": invalid.value
+			}, {
+				default: withCtx(() => [
+					createVNode(unref(FieldLabel), {
+						"html-for": unref(id),
+						class: normalizeClass(isDisabled.value ? "cursor-default" : "cursor-pointer")
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(labelText.value), 1), unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)]),
+						_: 1
+					}, 8, ["html-for", "class"]),
+					createElementVNode("div", {
+						"data-slot": "file-input-dropzone",
+						class: normalizeClass([
+							"rounded-lg border-2 border-dashed p-6 text-center transition-colors",
+							isDisabled.value ? "cursor-not-allowed bg-muted" : "cursor-pointer bg-muted text-muted-foreground hover:border-sidebar-ring",
+							invalid.value && "border-destructive",
+							isDragging.value && "border-sidebar-ring"
+						]),
+						onClick: openPicker,
+						onDragover: withModifiers(onDragOver, ["prevent"]),
+						onDragleave: withModifiers(onDragLeave, ["prevent"]),
+						onDrop: withModifiers(onDrop, ["prevent"])
+					}, [createElementVNode("input", {
+						id: unref(id),
+						ref_key: "fileInputRef",
+						ref: fileInputRef,
+						type: "file",
+						class: "hidden",
+						name: unref(name),
+						accept: __props.accept,
+						multiple: __props.multiple,
+						disabled: isDisabled.value,
+						"aria-invalid": invalid.value || void 0,
+						onChange: onFileChange
+					}, null, 40, _hoisted_2), createElementVNode("p", _hoisted_3, toDisplayString(promptText.value), 1)], 34),
+					__props.helperText ? (openBlock(), createBlock(unref(FieldDescription), { key: 0 }, {
+						default: withCtx(() => [createTextVNode(toDisplayString(__props.helperText), 1)]),
+						_: 1
+					})) : createCommentVNode("", true),
+					invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+						default: withCtx(() => [createVNode(validation_error_default, { error: unref(error) }, null, 8, ["error"])]),
+						_: 1
+					})) : createCommentVNode("", true),
+					hasPreview.value ? (openBlock(), createElementBlock("div", _hoisted_4, [(openBlock(true), createElementBlock(Fragment, null, renderList(files.value, (file, index) => {
+						return openBlock(), createBlock(file_input_preview_default, {
+							key: unref(fileEntryKey)(file, index),
+							file,
+							onRemove: ($event) => onRemove(file)
+						}, {
+							default: withCtx(() => [renderSlot(_ctx.$slots, "default", { record: file })]),
+							_: 2
+						}, 1032, ["file", "onRemove"]);
+					}), 128))])) : createCommentVNode("", true)
+				]),
+				_: 3
+			}, 8, ["class", "data-invalid"]);
+		};
+	}
+});
+export { file_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/image-input-thumbnail.js

@@ -0,0 +1,4 @@
+import image_input_thumbnail_vue_vue_type_script_setup_true_lang_default from "./image-input-thumbnail.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/image-input-thumbnail.vue
+var image_input_thumbnail_default = image_input_thumbnail_vue_vue_type_script_setup_true_lang_default;
+export { image_input_thumbnail_default as default };

package/dist/components/admin/inputs/image-input-thumbnail.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/admin/inputs/image-input-thumbnail.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,32 @@
+import { useRecordContext } from "../../../record/record-context.js";
+import { createCommentVNode, createElementBlock, defineComponent, openBlock, unref } from "vue";
+import { fileEntryImage } from "@chelone/core";
+// src/components/admin/inputs/image-input-thumbnail.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"src",
+	"title",
+	"alt"
+];
+var image_input_thumbnail_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "image-input-thumbnail",
+	setup(__props) {
+		/**
+		* `<ImageInputThumbnail>` — the default per-file preview for `<ImageInput>`, the
+		* Vue analog of `@chelone/react`'s internal `ImageInputThumbnail`. It reads the
+		* ambient file record (`{ src, title }`) that `<FileInput>` publishes (via
+		* {@link provideRecordContext}) and renders it as a thumbnail `<img>`. A stand-in
+		* for a ported `<ImageField>` default child; pass an explicit slot to override.
+		*/
+		const image = fileEntryImage(useRecordContext());
+		return (_ctx, _cache) => {
+			return unref(image) ? (openBlock(), createElementBlock("img", {
+				key: 0,
+				src: unref(image).src,
+				title: unref(image).title,
+				alt: unref(image).title,
+				class: "h-24 w-24 rounded-md object-cover"
+			}, null, 8, _hoisted_1)) : createCommentVNode("", true);
+		};
+	}
+});
+export { image_input_thumbnail_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/image-input.js

@@ -0,0 +1,4 @@
+import image_input_vue_vue_type_script_setup_true_lang_default from "./image-input.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/image-input.vue
+var image_input_default = image_input_vue_vue_type_script_setup_true_lang_default;
+export { image_input_default as default };

package/dist/components/admin/inputs/image-input.vue.d.ts

@@ -1,16 +1,18 @@
 import type { FileInputProps } from "./file-input.vue.js";
 /** Props for {@link ImageInput} — the {@link FileInputProps} surface. */
 export type ImageInputProps = FileInputProps;
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FileInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FileInputProps> & Readonly<{}>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ImageInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ImageInputProps> & Readonly<{}>, {
+    label: string | false;
     accept: string;
     labelMultiple: string;
     labelSingle: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {
-        record: import("@chelone/core").LooseRecord;
+        record: import("@chelone/core").FileEntry;
     }) => any;
 }>;
-export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/admin/inputs/image-input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,49 @@
+import file_input_default from "./file-input.js";
+import image_input_thumbnail_default from "./image-input-thumbnail.js";
+import { computed, createBlock, createVNode, defineComponent, guardReactiveProps, normalizeProps, openBlock, renderSlot, withCtx } from "vue";
+// src/components/admin/inputs/image-input.vue?vue&type=script&setup=true&lang.ts
+var image_input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "image-input",
+	props: {
+		resource: {},
+		helperText: {},
+		format: {},
+		parse: {},
+		accept: { default: "image/*" },
+		multiple: { type: Boolean },
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		placeholder: {},
+		labelMultiple: { default: "ra.input.image.upload_several" },
+		labelSingle: { default: "ra.input.image.upload_single" },
+		class: {},
+		source: {},
+		label: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		defaultValue: {},
+		validate: {}
+	},
+	setup(__props) {
+		/**
+		* `<ImageInput>` — an image-upload input with thumbnail previews, the Vue analog
+		* of `@chelone/react`'s `inputs/image-input.tsx`. A thin wrapper around
+		* {@link FileInput} that defaults `accept` to `"image/*"` and, when no preview
+		* slot is supplied, renders an inline `<img>` thumbnail per file
+		* ({@link ImageInputThumbnail}, reading the per-file ambient record).
+		*
+		* Divergence note (inherited from `<FileInput>`): the drop UI is native
+		* drag-drop, not react-dropzone; `accept` is the native string form.
+		*/
+		const props = __props;
+		const fileProps = computed(() => ({ ...props }));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(file_input_default, normalizeProps(guardReactiveProps(fileProps.value)), {
+				default: withCtx(({ record }) => [renderSlot(_ctx.$slots, "default", { record }, () => [createVNode(image_input_thumbnail_default)])]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+export { image_input_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/in-place-editor-form.js

@@ -0,0 +1,4 @@
+import in_place_editor_form_vue_vue_type_script_setup_true_lang_default from "./in-place-editor-form.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/in-place-editor-form.vue
+var in_place_editor_form_default = in_place_editor_form_vue_vue_type_script_setup_true_lang_default;
+export { in_place_editor_form_default as default };

package/dist/components/admin/inputs/in-place-editor-form.vue.d.ts

@@ -0,0 +1,33 @@
+import type { LooseRecord, ResourceRecord } from "@chelone/core";
+/** Props for {@link InPlaceEditorForm}. */
+export interface InPlaceEditorFormProps<TRecord extends ResourceRecord = LooseRecord> {
+    /** The record as it is when editing starts: the form's starting values and the save's `previousData`. */
+    record: TRecord;
+    /** Cancel on a focus move out of the editor; when false, save instead. */
+    cancelOnBlur: boolean;
+    /** Show Save and Cancel buttons beside the input. */
+    showButtons: boolean;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <TRecord extends ResourceRecord = LooseRecord>(__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<InPlaceEditorFormProps<TRecord> & {
+        onCancel?: (() => any) | undefined;
+        onSave?: ((before: TRecord, dirty: Partial<TRecord>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "cancel") => void) & ((evt: "save", before: TRecord, dirty: Partial<TRecord>) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<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/components/admin/inputs/in-place-editor-form.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,82 @@
+import { useForm } from "../../../form/use-form.js";
+import form_groups_provider_default from "../../../form/form-groups-provider.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import button_default from "../../ui/button.js";
+import { Fragment, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, onMounted, openBlock, ref, renderSlot, toDisplayString, unref, withCtx, withKeys, withModifiers } from "vue";
+import { getDirtyFormValues } from "@chelone/core";
+// src/components/admin/inputs/in-place-editor-form.vue?vue&type=script&setup=true&lang.ts
+var in_place_editor_form_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "in-place-editor-form",
+	props: {
+		record: {},
+		cancelOnBlur: { type: Boolean },
+		showButtons: { type: Boolean }
+	},
+	emits: ["save", "cancel"],
+	setup(__props, { emit: __emit }) {
+		/**
+		* The editing state of `<InPlaceEditor>`. It mounts when editing starts and
+		* holds the form, so the form starts from the record as it is then and never
+		* carries an edit over. `useForm` provides the form to its descendants when it
+		* is set up, which is why this is a component of its own.
+		*
+		* Emits `save` with the record as it was and the dirty fields, and `cancel`.
+		*/
+		const props = __props;
+		const emit = __emit;
+		const translate = useTranslate();
+		const formElement = ref(null);
+		const before = props.record;
+		const { form, submit } = useForm({
+			record: before,
+			resetOnSuccess: false,
+			onSubmit: async () => {
+				emit("save", before, getDirtyFormValues(form.store.state.values, form.store.state.fieldMeta));
+			}
+		});
+		onMounted(() => {
+			formElement.value?.querySelector("[autofocus]")?.focus();
+		});
+		function onFocusOut(event) {
+			const next = event.relatedTarget;
+			const root = formElement.value?.closest("[data-slot=\"in-place-editor\"]");
+			if (next instanceof Node && root?.contains(next)) return;
+			if (props.cancelOnBlur) emit("cancel");
+			else submit();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(form_groups_provider_default, null, {
+				default: withCtx(() => [createElementVNode("form", {
+					ref_key: "formElement",
+					ref: formElement,
+					"data-slot": "in-place-editor-editing",
+					class: "flex items-center gap-2 [&>:first-child]:min-w-0 [&>:first-child]:flex-1",
+					onClick: _cache[3] || (_cache[3] = withModifiers(() => {}, ["stop"])),
+					onSubmit: _cache[4] || (_cache[4] = withModifiers(($event) => unref(submit)(), ["prevent", "stop"])),
+					onKeydown: _cache[5] || (_cache[5] = withKeys(withModifiers(($event) => emit("cancel"), ["prevent", "stop"]), ["esc"])),
+					onFocusout: onFocusOut
+				}, [renderSlot(_ctx.$slots, "default"), __props.showButtons ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createVNode(button_default, {
+					type: "submit",
+					size: "sm",
+					"aria-label": unref(translate)("ra.action.save", { _: "Save" }),
+					onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {}, ["prevent"]))
+				}, {
+					default: withCtx(() => [createTextVNode(toDisplayString(unref(translate)("ra.action.save", { _: "Save" })), 1)]),
+					_: 1
+				}, 8, ["aria-label"]), createVNode(button_default, {
+					type: "button",
+					size: "sm",
+					variant: "outline",
+					"aria-label": unref(translate)("ra.action.cancel", { _: "Cancel" }),
+					onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {}, ["prevent"])),
+					onClick: _cache[2] || (_cache[2] = ($event) => emit("cancel"))
+				}, {
+					default: withCtx(() => [createTextVNode(toDisplayString(unref(translate)("ra.action.cancel", { _: "Cancel" })), 1)]),
+					_: 1
+				}, 8, ["aria-label"])], 64)) : createCommentVNode("", true)], 544)]),
+				_: 3
+			});
+		};
+	}
+});
+export { in_place_editor_form_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/inputs/in-place-editor.js

@@ -0,0 +1,4 @@
+import in_place_editor_vue_vue_type_script_setup_true_lang_default from "./in-place-editor.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/inputs/in-place-editor.vue
+var in_place_editor_default = in_place_editor_vue_vue_type_script_setup_true_lang_default;
+export { in_place_editor_default as default };

package/dist/components/admin/inputs/in-place-editor.vue.d.ts

@@ -0,0 +1,51 @@
+import type { LooseRecord, MutationMode, ResourceRecord, SourceProp } from "@chelone/core";
+/** Props for {@link InPlaceEditor}. */
+export interface InPlaceEditorProps<TRecord extends ResourceRecord = LooseRecord> {
+    /**
+     * The field to show and edit. Required unless both the default slot and the
+     * `#editor` slot are given.
+     */
+    source?: SourceProp<TRecord>;
+    /** Default is `useUpdate`'s own. */
+    mutationMode?: MutationMode;
+    /** Sent with the update. */
+    meta?: Record<string, unknown>;
+    /** Cancel on a focus move out of the editor; when false, save instead. Default `true`. */
+    cancelOnBlur?: boolean;
+    /** Show Save and Cancel buttons beside the input. Default `false`. */
+    showButtons?: boolean;
+    /** Notify `chelone.notification.updated` on success. Undoable mode always notifies, with Undo. Default `false`. */
+    notifyOnSuccess?: boolean;
+    /** Override the ambient resource. */
+    resource?: string;
+    class?: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <TRecord extends ResourceRecord = LooseRecord>(__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<InPlaceEditorProps<TRecord> & {
+        onError?: ((error: unknown) => any) | undefined;
+        onSuccess?: ((record: TRecord) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        editor?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "error", error: unknown) => void) & ((evt: "success", record: TRecord) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<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];
+}) & {};