@atscript/vue-form 0.1.58

package/dist/as-form-DAIkyt7H.cjs

@@ -0,0 +1,448 @@
+const require_use_form_context = require("./use-form-context-Dwr8Ai1v.cjs");
+const require_use_as_nested_sections_store = require("./use-as-nested-sections-store-jdMRxjBE.cjs");
+const require_use_as_value_help = require("./use-as-value-help-uANI3zWa.cjs");
+const require_as_field = require("./as-field-wLYoaZnT.cjs");
+let vue = require("vue");
+let _atscript_ui = require("@atscript/ui");
+//#region src/composables/use-as-external-errors.ts
+/**
+* Local dismissal state for externally-supplied errors.
+*
+* - `dismissAt(path)` hides a leaf error until either the user un-dismisses
+*   it or a *fresh* errors object arrives (new identity).
+* - `dismissForm()` hides the `__form` banner. Same identity-reset rule, but
+*   never cleared by leaf calls.
+* - In-place mutation of the source object does NOT reset dismissals; only
+*   identity changes do. A fresh response (`errors.value = { ... }`) re-arms
+*   everything, while in-place tweaks (rare) deliberately preserve them.
+*
+* The composable is pure — it does NOT call `provide()`. The owning form
+* composable wires `dismissAt` into the form's inject contract.
+*/
+function useAsExternalErrors(options) {
+	const dismissedPaths = (0, vue.ref)(/* @__PURE__ */ new Set());
+	const formDismissed = (0, vue.ref)(false);
+	function reset() {
+		if (dismissedPaths.value.size > 0) dismissedPaths.value = /* @__PURE__ */ new Set();
+		if (formDismissed.value) formDismissed.value = false;
+	}
+	(0, vue.watch)(() => options.source(), reset);
+	const effective = (0, vue.computed)(() => {
+		const errs = options.source();
+		if (!errs) return void 0;
+		const dismissed = dismissedPaths.value;
+		if (dismissed.size === 0 && errs.__form === void 0) return errs;
+		const out = {};
+		for (const k in errs) {
+			if (k === "__form") continue;
+			if (dismissed.has(k)) continue;
+			out[k] = errs[k];
+		}
+		return out;
+	});
+	const formError = (0, vue.computed)(() => {
+		if (formDismissed.value) return void 0;
+		return options.source()?.__form;
+	});
+	const isFormDismissed = (0, vue.computed)(() => formDismissed.value);
+	function dismissAt(path) {
+		if (!path) return;
+		if (dismissedPaths.value.has(path)) return;
+		const next = new Set(dismissedPaths.value);
+		next.add(path);
+		dismissedPaths.value = next;
+	}
+	function dismissForm() {
+		if (!formDismissed.value) formDismissed.value = true;
+	}
+	return {
+		effective,
+		formError,
+		isFormDismissed,
+		dismissAt,
+		dismissForm,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/use-as-state.ts
+function useAsState(opts) {
+	const fieldsById = /* @__PURE__ */ new Map();
+	const register = (id, registration) => {
+		fieldsById.set(id, registration);
+		if (formState.firstSubmitHappened) formState.freshFields.add(id);
+	};
+	const unregister = (id) => {
+		fieldsById.delete(id);
+		formState.freshFields.delete(id);
+	};
+	const formState = (0, vue.reactive)({
+		firstSubmitHappened: false,
+		firstValidation: (0, vue.toValue)(opts.firstValidation) ?? "on-change",
+		freshFields: /* @__PURE__ */ new Set(),
+		register,
+		unregister
+	});
+	(0, vue.watchEffect)(() => {
+		const v = (0, vue.toValue)(opts.firstValidation) ?? "on-change";
+		if (formState.firstValidation !== v) formState.firstValidation = v;
+	});
+	(0, vue.provide)(require_use_form_context.FORM_STATE_KEY, formState);
+	(0, vue.provide)(require_use_form_context.FORM_DATA_KEY, (0, vue.computed)(() => (0, vue.toValue)(opts.formData)));
+	(0, vue.provide)(require_use_form_context.FORM_CONTEXT_KEY, (0, vue.computed)(() => opts.formContext ? (0, vue.toValue)(opts.formContext) : void 0));
+	function clearErrors() {
+		formState.firstSubmitHappened = false;
+		formState.freshFields.clear();
+		for (const reg of fieldsById.values()) reg.callbacks.clearErrors();
+	}
+	async function reset() {
+		for (const reg of fieldsById.values()) reg.callbacks.reset();
+		await (0, vue.nextTick)();
+		clearErrors();
+	}
+	function submit() {
+		formState.firstSubmitHappened = true;
+		formState.freshFields.clear();
+		if (formState.firstValidation === "none") return true;
+		if (opts.submitValidator) {
+			const errors = opts.submitValidator();
+			const entries = Object.entries(errors);
+			if (entries.length === 0) return true;
+			setErrors(errors);
+			return entries.map(([path, message]) => ({
+				path,
+				message
+			}));
+		}
+		const errors = [];
+		for (const reg of fieldsById.values()) {
+			const result = reg.callbacks.validate();
+			if (result !== true) {
+				const path = reg.path();
+				errors.push({
+					path,
+					message: result
+				});
+			}
+		}
+		return errors.length > 0 ? errors : true;
+	}
+	function setErrors(errors) {
+		for (const reg of fieldsById.values()) {
+			const p = reg.path();
+			reg.callbacks.setExternalError(errors[p]);
+		}
+	}
+	return {
+		clearErrors,
+		reset,
+		submit,
+		setErrors,
+		formState
+	};
+}
+//#endregion
+//#region src/composables/use-as-form.ts
+/**
+* Composable backing `<AsForm>`. Owns the entire form state machine —
+* data container, internal validator, external-error dismissal, action
+* routing, change merging, descendant counts, auto-open, and all
+* provide/inject wiring. Customers building a custom form root can
+* call this directly and render their own `<form>` template.
+*
+* MUST be called from a component's `<script setup>` (it issues
+* `provide()` calls that need an active component instance).
+*/
+function useAsForm(options) {
+	const _data = (0, vue.ref)({});
+	const data = (0, vue.computed)(() => {
+		return options.formData?.() ?? _data.value;
+	});
+	/**
+	* Unwraps domain data from the form data container. Form data is
+	* `{ value: domainData }` — getByPath/setByPath handle this wrapper
+	* automatically, but scope/validator callers need the inner value.
+	*/
+	function getDomainData() {
+		return data.value.value;
+	}
+	const domainData = () => (0, vue.toRaw)(getDomainData());
+	const formContext = (0, vue.computed)(() => options.formContext?.());
+	const formValidator = (0, vue.computed)(() => (0, _atscript_ui.getFormValidator)(options.def(), { errorLimit: Number.MAX_SAFE_INTEGER }));
+	const { clearErrors, reset: resetState, submit, setErrors } = useAsState({
+		formData: data,
+		formContext,
+		firstValidation: (0, vue.computed)(() => options.firstValidation?.()),
+		submitValidator: () => formValidator.value({
+			data: getDomainData(),
+			context: formContext.value ?? {}
+		})
+	});
+	(0, vue.provide)(require_use_form_context.ROOT_DATA_KEY, data);
+	(0, vue.provide)(require_use_form_context.PATH_PREFIX_KEY, (0, vue.computed)(() => ""));
+	(0, vue.provide)(require_use_form_context.TYPES_KEY, (0, vue.computed)(() => options.types()));
+	(0, vue.provide)(require_use_form_context.COMPONENTS_KEY, (0, vue.computed)(() => options.components?.()));
+	(0, vue.provide)(require_use_form_context.HIDE_ROOT_TITLE_KEY, options.hideRootTitle?.() === true);
+	const ext = useAsExternalErrors({ source: () => options.errors?.() });
+	(0, vue.provide)(require_use_form_context.ERRORS_KEY, ext.effective);
+	(0, vue.provide)(require_use_form_context.DISMISS_EXTERNAL_AT_KEY, ext.dismissAt);
+	const sectionsStore = require_use_as_nested_sections_store.useAsNestedSectionsStore() ?? require_use_as_nested_sections_store.provideAsNestedSectionsStore();
+	const cf = options.clientFactory?.();
+	if (cf) (0, vue.provide)(require_use_as_value_help.CLIENT_FACTORY_KEY, cf);
+	const internalErrors = (0, vue.ref)({});
+	const allErrors = (0, vue.computed)(() => (0, _atscript_ui.mergeErrorMaps)(ext.effective.value, internalErrors.value));
+	(0, vue.provide)(require_use_as_nested_sections_store.DESCENDANT_ERROR_COUNTS_KEY, (0, vue.computed)(() => (0, _atscript_ui.buildDescendantErrorCounts)(allErrors.value)));
+	(0, vue.watch)(allErrors, (errors) => {
+		for (const errPath of Object.keys(errors)) for (const ancestor of (0, _atscript_ui.iteratePathAncestors)(errPath)) sectionsStore.setOpen(ancestor, true);
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	const ctx = (0, vue.computed)(() => ({
+		v: void 0,
+		data: getDomainData(),
+		context: formContext.value ?? {},
+		entry: void 0
+	}));
+	const submitText = (0, vue.computed)(() => (0, _atscript_ui.resolveFormProp)(options.def().type, _atscript_ui.UI_FORM_FN_SUBMIT_TEXT, _atscript_ui.UI_FORM_SUBMIT_TEXT, ctx.value) ?? "Submit");
+	const submitDisabled = (0, vue.computed)(() => (0, _atscript_ui.resolveFormProp)(options.def().type, _atscript_ui.UI_FORM_FN_SUBMIT_DISABLED, void 0, ctx.value) ?? false);
+	function supportsAction(def, actionId) {
+		return def.fields.some((f) => {
+			if ((0, _atscript_ui.getFieldMeta)(f.prop, _atscript_ui.UI_FORM_ACTION)?.id === actionId) return true;
+			return (0, _atscript_ui.getFieldMeta)(f.prop, _atscript_ui.WF_ACTION_WITH_DATA) === actionId;
+		});
+	}
+	function invokeAction(name) {
+		if (supportsAction(options.def(), name)) options.emits?.action?.(name, domainData());
+		else options.emits?.unsupportedAction?.(name, domainData());
+	}
+	(0, vue.provide)(require_use_form_context.ACTION_HANDLER_KEY, invokeAction);
+	function handleChange(type, path, value) {
+		ext.dismissAt(path);
+		const errors = internalErrors.value;
+		let stale = null;
+		let next = null;
+		for (const key in errors) {
+			if (!stale) stale = new Set((0, _atscript_ui.iteratePathAncestors)(path));
+			if (stale.has(key)) {
+				if (!next) next = { ...errors };
+				delete next[key];
+			}
+		}
+		if (next) {
+			internalErrors.value = next;
+			setErrors(next);
+		}
+		options.emits?.change?.(type, path, value, domainData());
+	}
+	(0, vue.provide)(require_use_form_context.CHANGE_HANDLER_KEY, handleChange);
+	function onSubmit() {
+		const result = submit();
+		if (result === true) {
+			internalErrors.value = {};
+			options.emits?.submit?.(domainData());
+		} else {
+			const errs = {};
+			for (const e of result) errs[e.path] = e.message;
+			internalErrors.value = errs;
+			options.emits?.error?.(result);
+		}
+	}
+	return {
+		data,
+		errors: ext.effective,
+		formError: ext.formError,
+		internalErrors,
+		reset: resetState,
+		clearErrors,
+		setErrors,
+		onSubmit,
+		submitText,
+		submitDisabled,
+		invokeAction,
+		dismissError: ext.dismissAt,
+		dismissFormError: ext.dismissForm,
+		formContext,
+		handleChange
+	};
+}
+//#endregion
+//#region src/components/as-form.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["inert"];
+const _hoisted_2 = {
+	role: "alert",
+	class: "as-form-error"
+};
+const _hoisted_3 = { class: "as-form-error-message" };
+const _hoisted_4 = ["disabled"];
+const _hoisted_5 = {
+	key: 2,
+	class: "as-form-overlay"
+};
+//#endregion
+//#region src/components/as-form.vue
+var as_form_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "as-form",
+	props: {
+		def: {
+			type: Object,
+			required: true
+		},
+		formData: {
+			type: null,
+			required: false
+		},
+		formContext: {
+			type: null,
+			required: false
+		},
+		firstValidation: {
+			type: String,
+			required: false
+		},
+		components: {
+			type: Object,
+			required: false
+		},
+		types: {
+			type: Object,
+			required: true
+		},
+		errors: {
+			type: Object,
+			required: false
+		},
+		clientFactory: {
+			type: Function,
+			required: false
+		},
+		hideRootTitle: {
+			type: Boolean,
+			required: false
+		},
+		hideSubmit: {
+			type: Boolean,
+			required: false
+		},
+		loading: {
+			type: Boolean,
+			required: false
+		}
+	},
+	emits: [
+		"submit",
+		"error",
+		"action",
+		"unsupported-action",
+		"change"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const form = useAsForm({
+			def: () => props.def,
+			formData: () => props.formData,
+			formContext: () => props.formContext,
+			firstValidation: () => props.firstValidation,
+			components: () => props.components,
+			types: () => props.types,
+			errors: () => props.errors,
+			clientFactory: () => props.clientFactory,
+			hideRootTitle: () => props.hideRootTitle,
+			emits: {
+				submit: (data) => emit("submit", data),
+				error: (errors) => emit("error", errors),
+				action: (name, data) => emit("action", name, data),
+				unsupportedAction: (name, data) => emit("unsupported-action", name, data),
+				change: (type, path, value, formData) => emit("change", type, path, value, formData)
+			}
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("form", {
+				class: "as-form",
+				inert: __props.loading,
+				onSubmit: _cache[1] || (_cache[1] = (0, vue.withModifiers)((...args) => (0, vue.unref)(form).onSubmit && (0, vue.unref)(form).onSubmit(...args), ["prevent"]))
+			}, [
+				(0, vue.renderSlot)(_ctx.$slots, "form.header", {
+					clearErrors: (0, vue.unref)(form).clearErrors,
+					reset: (0, vue.unref)(form).reset,
+					setErrors: (0, vue.unref)(form).setErrors,
+					formContext: __props.formContext,
+					disabled: (0, vue.unref)(form).submitDisabled.value
+				}),
+				(0, vue.renderSlot)(_ctx.$slots, "form.before", {
+					clearErrors: (0, vue.unref)(form).clearErrors,
+					reset: (0, vue.unref)(form).reset,
+					setErrors: (0, vue.unref)(form).setErrors,
+					formContext: __props.formContext,
+					disabled: (0, vue.unref)(form).submitDisabled.value
+				}),
+				(0, vue.createVNode)(require_as_field.as_field_default, { field: __props.def.rootField }, null, 8, ["field"]),
+				(0, vue.renderSlot)(_ctx.$slots, "form.after", {
+					clearErrors: (0, vue.unref)(form).clearErrors,
+					reset: (0, vue.unref)(form).reset,
+					setErrors: (0, vue.unref)(form).setErrors,
+					disabled: (0, vue.unref)(form).submitDisabled.value,
+					formContext: __props.formContext
+				}),
+				(0, vue.unref)(form).formError.value ? (0, vue.renderSlot)(_ctx.$slots, "form.error", {
+					key: 0,
+					message: (0, vue.unref)(form).formError.value,
+					dismiss: (0, vue.unref)(form).dismissFormError
+				}, () => [(0, vue.createElementVNode)("div", _hoisted_2, [(0, vue.createElementVNode)("span", _hoisted_3, (0, vue.toDisplayString)((0, vue.unref)(form).formError.value), 1), (0, vue.createElementVNode)("button", {
+					type: "button",
+					class: "as-form-error-dismiss",
+					onClick: _cache[0] || (_cache[0] = (...args) => (0, vue.unref)(form).dismissFormError && (0, vue.unref)(form).dismissFormError(...args))
+				}, " Dismiss ")])]) : (0, vue.createCommentVNode)("v-if", true),
+				!__props.hideSubmit ? (0, vue.renderSlot)(_ctx.$slots, "form.submit", {
+					key: 1,
+					disabled: (0, vue.unref)(form).submitDisabled.value,
+					text: (0, vue.unref)(form).submitText.value,
+					clearErrors: (0, vue.unref)(form).clearErrors,
+					reset: (0, vue.unref)(form).reset,
+					setErrors: (0, vue.unref)(form).setErrors,
+					formContext: __props.formContext
+				}, () => [(0, vue.createElementVNode)("button", {
+					class: "as-submit-btn",
+					disabled: (0, vue.unref)(form).submitDisabled.value
+				}, (0, vue.toDisplayString)((0, vue.unref)(form).submitText.value), 9, _hoisted_4)]) : (0, vue.createCommentVNode)("v-if", true),
+				(0, vue.renderSlot)(_ctx.$slots, "form.footer", {
+					disabled: (0, vue.unref)(form).submitDisabled.value,
+					clearErrors: (0, vue.unref)(form).clearErrors,
+					reset: (0, vue.unref)(form).reset,
+					setErrors: (0, vue.unref)(form).setErrors,
+					formContext: __props.formContext
+				}),
+				__props.loading ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_5, [(0, vue.renderSlot)(_ctx.$slots, "form.loading", {}, () => [_cache[2] || (_cache[2] = (0, vue.createElementVNode)("span", {
+					class: "as-form-overlay-icon",
+					"aria-hidden": "true"
+				}, null, -1))])])) : (0, vue.createCommentVNode)("v-if", true)
+			], 40, _hoisted_1);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "as_form_default", {
+	enumerable: true,
+	get: function() {
+		return as_form_default;
+	}
+});
+Object.defineProperty(exports, "useAsExternalErrors", {
+	enumerable: true,
+	get: function() {
+		return useAsExternalErrors;
+	}
+});
+Object.defineProperty(exports, "useAsForm", {
+	enumerable: true,
+	get: function() {
+		return useAsForm;
+	}
+});
+Object.defineProperty(exports, "useAsState", {
+	enumerable: true,
+	get: function() {
+		return useAsState;
+	}
+});

package/dist/as-form.cjs

@@ -0,0 +1,7 @@
+require("./use-form-context-Dwr8Ai1v.cjs");
+require("./use-as-nested-sections-store-jdMRxjBE.cjs");
+require("./use-as-value-help-uANI3zWa.cjs");
+const require_as_form = require("./as-form-DAIkyt7H.cjs");
+require("./as-field-wLYoaZnT.cjs");
+require("./use-as-locale-C4z5stwD.cjs");
+module.exports = require_as_form.as_form_default;

package/dist/as-form.d.cts

@@ -0,0 +1,2 @@
+import { n as _default, t as Props } from "./as-form.vue-B4Bn0pbC.cjs";
+export { Props, _default as default };

package/dist/as-form.d.mts

@@ -0,0 +1,2 @@
+import { n as _default, t as Props } from "./as-form.vue-DRrb_yoj.mjs";
+export { Props, _default as default };

package/dist/as-form.mjs

@@ -0,0 +1,7 @@
+import "./use-form-context-bAj7UoSe.mjs";
+import "./use-as-nested-sections-store-lhi0z5z1.mjs";
+import "./use-as-value-help-CBykDEjZ.mjs";
+import { t as as_form_default } from "./as-form-CWwgyvfw.mjs";
+import "./as-field-CXVjrEPQ.mjs";
+import "./use-as-locale-BrFdAgnU.mjs";
+export { as_form_default as default };

package/dist/as-form.vue-B4Bn0pbC.d.cts

@@ -0,0 +1,158 @@
+import { a as TAsTypeComponents, i as TAsComponentProps, n as TAsChangeType } from "./types-C4HRSxgV.cjs";
+import * as vue from "vue";
+import { Component } from "vue";
+import { ClientFactory, FormDef } from "@atscript/ui";
+
+//#region src/composables/types.d.ts
+type TFormRule<TValue, TFormData, TContext> = (v: TValue, data?: TFormData, context?: TContext) => boolean | string;
+interface TFormFieldCallbacks {
+  validate: () => boolean | string;
+  clearErrors: () => void;
+  reset: () => void;
+  setExternalError: (msg?: string) => void;
+}
+interface TFormFieldRegistration {
+  path: () => string;
+  callbacks: TFormFieldCallbacks;
+}
+interface TFormState {
+  firstSubmitHappened: boolean;
+  firstValidation: "on-change" | "touched-on-blur" | "on-blur" | "on-submit" | "none";
+  /**
+   * Fields registered AFTER `firstSubmitHappened` flipped to true. They stay
+   * in this set until either the user edits the field (model watch removes
+   * the id) or the next submit fires (set is cleared). Live validation is
+   * suppressed for these fields so a freshly-added array item doesn't render
+   * red required-field errors before the user has had a chance to type.
+   */
+  freshFields: Set<symbol>;
+  register: (id: symbol, registration: TFormFieldRegistration) => void;
+  unregister: (id: symbol) => void;
+}
+//#endregion
+//#region src/components/as-form.vue.d.ts
+interface Props<TF, TC> {
+  def: FormDef;
+  formData?: TF;
+  formContext?: TC;
+  firstValidation?: TFormState["firstValidation"];
+  components?: Record<string, Component<TAsComponentProps>>;
+  /**
+   * Type-to-component map for field rendering. Maps field types to Vue components.
+   * Must include entries for all built-in field types. Use `createDefaultTypes()`
+   * for a pre-filled map, or supply your own.
+   */
+  types: TAsTypeComponents;
+  errors?: Record<string, string | undefined>;
+  /**
+   * Per-form client factory override. Creates `Client` instances from URL paths
+   * for FK value-help pickers inside this form. Falls back to the app-wide
+   * default (`setDefaultClientFactory`) and then to the built-in `new Client(url)`
+   * factory when unset.
+   */
+  clientFactory?: ClientFactory;
+  /**
+   * Suppress the root field's title rendering. Use when the form is mounted
+   * inside a chrome that already shows the form's `@meta.label` (e.g. a
+   * dialog header). Nested fields keep their own headings.
+   */
+  hideRootTitle?: boolean;
+  /**
+   * Suppress the default submit button. Use when the host chrome owns the
+   * submit affordance (e.g. a dialog footer with its own submit button
+   * wired via HTML5 `<button form="...">`). Vue 3 treats an empty
+   * `<template #form.submit />` as "slot not provided" and falls back to
+   * the default button — this prop is the explicit way to skip it.
+   */
+  hideSubmit?: boolean;
+  /**
+   * When true, freezes the form: the body becomes `inert` (blocks pointer
+   * events + keyboard focus) and a loading overlay paints over the entire
+   * form area. Used by `<AsWfForm>` to lock interaction during a server
+   * round-trip so the user can't edit a field whose response is racing in.
+   * Visual is shared with `<AsTable>`'s query overlay via vunor
+   * `inner-loading`.
+   */
+  loading?: boolean;
+}
+declare const __VLS_export: <TFormData = any, TFormContext = any>(__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: vue.PublicProps & __VLS_PrettifyLocal<Props<TFormData, TFormContext> & {
+    onError?: ((errors: {
+      path: string;
+      message: string;
+    }[]) => any) | undefined;
+    onAction?: ((name: string, data: TFormData) => any) | undefined;
+    onSubmit?: ((data: TFormData) => any) | undefined;
+    "onUnsupported-action"?: ((name: string, data: TFormData) => any) | undefined;
+    onChange?: ((type: TAsChangeType, path: string, value: unknown, formData: TFormData) => any) | undefined;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    'form.header'?: (props: {
+      clearErrors: () => void;
+      reset: () => Promise<void>;
+      setErrors: (errors: Record<string, string>) => void;
+      formContext: TFormContext | undefined;
+      disabled: boolean;
+    }) => any;
+  } & {
+    'form.before'?: (props: {
+      clearErrors: () => void;
+      reset: () => Promise<void>;
+      setErrors: (errors: Record<string, string>) => void;
+      formContext: TFormContext | undefined;
+      disabled: boolean;
+    }) => any;
+  } & {
+    'form.after'?: (props: {
+      clearErrors: () => void;
+      reset: () => Promise<void>;
+      setErrors: (errors: Record<string, string>) => void;
+      disabled: boolean;
+      formContext: TFormContext | undefined;
+    }) => any;
+  } & {
+    'form.error'?: (props: {
+      message: string;
+      dismiss: () => void;
+    }) => any;
+  } & {
+    'form.submit'?: (props: {
+      disabled: boolean;
+      text: string;
+      clearErrors: () => void;
+      reset: () => Promise<void>;
+      setErrors: (errors: Record<string, string>) => void;
+      formContext: TFormContext | undefined;
+    }) => any;
+  } & {
+    'form.footer'?: (props: {
+      disabled: boolean;
+      clearErrors: () => void;
+      reset: () => Promise<void>;
+      setErrors: (errors: Record<string, string>) => void;
+      formContext: TFormContext | undefined;
+    }) => any;
+  } & {
+    'form.loading'?: (props: {}) => any;
+  };
+  emit: {
+    (e: "submit", data: TFormData): void;
+    (e: "error", errors: {
+      path: string;
+      message: string;
+    }[]): void;
+    (e: "action", name: string, data: TFormData): void;
+    (e: "unsupported-action", name: string, data: TFormData): void;
+    (e: "change", type: TAsChangeType, path: string, value: unknown, formData: TFormData): void;
+  };
+}>) => vue.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+export { TFormRule as a, TFormFieldRegistration as i, _default as n, TFormState as o, TFormFieldCallbacks as r, Props as t };