@dazhicheng/ui 1.5.13 → 1.5.15

package/dist/components/tt-validate/src/Form.d.ts

@@ -1,271 +0,0 @@
-import { PropType, UnwrapRef, VNode } from 'vue';
-import { FormContext, FormErrors, FormMeta, GenericObject, InvalidSubmissionHandler, SubmissionHandler } from './types';
-export type FormSlotProps = UnwrapRef<Pick<FormContext, 'meta' | 'errors' | 'errorBag' | 'values' | 'isSubmitting' | 'isValidating' | 'submitCount' | 'validate' | 'validateField' | 'handleReset' | 'setErrors' | 'setFieldError' | 'setFieldValue' | 'setValues' | 'setFieldTouched' | 'setTouched' | 'resetForm' | 'resetField' | 'controlledValues'>> & {
-    handleSubmit: (evt: Event | SubmissionHandler, onSubmit?: SubmissionHandler) => Promise<unknown>;
-    submitForm: (evt?: Event) => void;
-    getValues: <TValues extends GenericObject = GenericObject>() => TValues;
-    getMeta: <TValues extends GenericObject = GenericObject>() => FormMeta<TValues>;
-    getErrors: <TValues extends GenericObject = GenericObject>() => FormErrors<TValues>;
-};
-declare const FormImpl: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    /**
-     * 指定表单组件渲染时使用的标签或组件名称。
-     * 默认为 'form'，表示渲染为 HTML 的 form 标签。
-     * @type {string | null}
-     * @default 'form'
-     */
-    as: {
-        type: PropType<string | null>;
-        default: string;
-    };
-    /**
-     * 表单验证的规则模式。
-     * 该对象定义了表单字段的验证规则。
-     * 默认值为 undefined，表示不使用验证模式。
-     * @type {object}
-     * @default undefined
-     */
-    validationSchema: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 表单的初始值。
-     * 该对象包含表单字段的初始值。
-     * 默认值为 undefined，表示没有初始值。
-     * @type {object}
-     * @default undefined
-     */
-    initialValues: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 表单的初始错误信息。
-     * 该对象包含表单字段的初始错误信息。
-     * 默认值为 undefined，表示没有初始错误。
-     * @type {object}
-     * @default undefined
-     */
-    initialErrors: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 表单字段的初始触碰状态。
-     * 该对象包含表单字段的初始触碰状态。
-     * 默认值为 undefined，表示没有初始触碰状态。
-     * @type {object}
-     * @default undefined
-     */
-    initialTouched: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 指示是否在表单挂载时进行验证。
-     * 如果设置为 true，则在表单挂载时立即验证表单。
-     * 默认值为 false。
-     * @type {boolean}
-     * @default false
-     */
-    validateOnMount: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * 表单提交时的回调函数。
-     * 该函数在表单提交且验证通过时调用。
-     * 默认值为 undefined，表示没有提交回调。
-     * @type {Function}
-     * @default undefined
-     */
-    onSubmit: {
-        type: PropType<SubmissionHandler<GenericObject>>;
-        default: undefined;
-    };
-    /**
-     * 表单提交验证失败时的回调函数。
-     * 该函数在表单提交但验证不通过时调用。
-     * 默认值为 undefined，表示没有无效提交回调。
-     * @type {Function}
-     * @default undefined
-     */
-    onInvalidSubmit: {
-        type: PropType<InvalidSubmissionHandler>;
-        default: undefined;
-    };
-    /**
-     * 指示是否在表单卸载时保留表单值。
-     * 如果设置为 true，则在表单卸载时保留表单值。
-     * 默认值为 false。
-     * @type {boolean}
-     * @default false
-     */
-    keepValues: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * 表单的名称。
-     * 用于标识表单，默认为 'Form'。
-     * @type {string}
-     * @default 'Form'
-     */
-    name: {
-        type: StringConstructor;
-        default: string;
-    };
-}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}>[] | {
-    default: () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
-        [key: string]: any;
-    }>[] | undefined;
-} | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    /**
-     * 指定表单组件渲染时使用的标签或组件名称。
-     * 默认为 'form'，表示渲染为 HTML 的 form 标签。
-     * @type {string | null}
-     * @default 'form'
-     */
-    as: {
-        type: PropType<string | null>;
-        default: string;
-    };
-    /**
-     * 表单验证的规则模式。
-     * 该对象定义了表单字段的验证规则。
-     * 默认值为 undefined，表示不使用验证模式。
-     * @type {object}
-     * @default undefined
-     */
-    validationSchema: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 表单的初始值。
-     * 该对象包含表单字段的初始值。
-     * 默认值为 undefined，表示没有初始值。
-     * @type {object}
-     * @default undefined
-     */
-    initialValues: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 表单的初始错误信息。
-     * 该对象包含表单字段的初始错误信息。
-     * 默认值为 undefined，表示没有初始错误。
-     * @type {object}
-     * @default undefined
-     */
-    initialErrors: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 表单字段的初始触碰状态。
-     * 该对象包含表单字段的初始触碰状态。
-     * 默认值为 undefined，表示没有初始触碰状态。
-     * @type {object}
-     * @default undefined
-     */
-    initialTouched: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    /**
-     * 指示是否在表单挂载时进行验证。
-     * 如果设置为 true，则在表单挂载时立即验证表单。
-     * 默认值为 false。
-     * @type {boolean}
-     * @default false
-     */
-    validateOnMount: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * 表单提交时的回调函数。
-     * 该函数在表单提交且验证通过时调用。
-     * 默认值为 undefined，表示没有提交回调。
-     * @type {Function}
-     * @default undefined
-     */
-    onSubmit: {
-        type: PropType<SubmissionHandler<GenericObject>>;
-        default: undefined;
-    };
-    /**
-     * 表单提交验证失败时的回调函数。
-     * 该函数在表单提交但验证不通过时调用。
-     * 默认值为 undefined，表示没有无效提交回调。
-     * @type {Function}
-     * @default undefined
-     */
-    onInvalidSubmit: {
-        type: PropType<InvalidSubmissionHandler>;
-        default: undefined;
-    };
-    /**
-     * 指示是否在表单卸载时保留表单值。
-     * 如果设置为 true，则在表单卸载时保留表单值。
-     * 默认值为 false。
-     * @type {boolean}
-     * @default false
-     */
-    keepValues: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * 表单的名称。
-     * 用于标识表单，默认为 'Form'。
-     * @type {string}
-     * @default 'Form'
-     */
-    name: {
-        type: StringConstructor;
-        default: string;
-    };
-}>> & Readonly<{}>, {
-    onSubmit: SubmissionHandler<GenericObject>;
-    name: string;
-    initialValues: Record<string, any>;
-    as: string | null;
-    validateOnMount: boolean;
-    validationSchema: Record<string, any>;
-    initialErrors: Record<string, any>;
-    initialTouched: Record<string, any>;
-    onInvalidSubmit: InvalidSubmissionHandler;
-    keepValues: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export declare const Form: typeof FormImpl & {
-    new (): {
-        setFieldError: FormContext["setFieldError"];
-        setErrors: FormContext["setErrors"];
-        setFieldValue: FormContext["setFieldValue"];
-        setValues: FormContext["setValues"];
-        setFieldTouched: FormContext["setFieldTouched"];
-        setTouched: FormContext["setTouched"];
-        resetForm: FormContext["resetForm"];
-        resetField: FormContext["resetField"];
-        validate: FormContext["validate"];
-        validateField: FormContext["validateField"];
-        getValues: FormSlotProps["getValues"];
-        getMeta: FormSlotProps["getMeta"];
-        getErrors: FormSlotProps["getErrors"];
-        meta: FormSlotProps["meta"];
-        values: FormSlotProps["values"];
-        errors: FormSlotProps["errors"];
-        $slots: {
-            default: (arg: FormSlotProps) => VNode[];
-        };
-    };
-};
-export {};

package/dist/components/tt-validate/src/config.d.ts

@@ -1,14 +0,0 @@
-import { ValidationMessageGenerator } from './types/shared';
-export type VeeValidateConfig = {
-    bails: boolean;
-    generateMessage: ValidationMessageGenerator;
-    validateOnInput: boolean;
-    validateOnChange: boolean;
-    validateOnBlur: boolean;
-    validateOnModelUpdate: boolean;
-};
-export declare let currentConfig: VeeValidateConfig;
-export declare const getConfig: () => VeeValidateConfig;
-declare function setConfig(newConf: Partial<VeeValidateConfig>): void;
-export declare const configure: typeof setConfig;
-export {};

package/dist/components/tt-validate/src/defineRule.d.ts

@@ -1,9 +0,0 @@
-import { SimpleValidationRuleFunction, ValidationRuleFunction } from './types/shared';
-/**
- * Adds a custom validator to the list of validation rules.
- */
-export declare function defineRule<TValue = unknown, TParams = any[] | Record<string, any>>(id: string, validator: ValidationRuleFunction<TValue, TParams> | SimpleValidationRuleFunction<TValue, TParams>): void;
-/**
- * Gets an already defined rule
- */
-export declare function resolveRule(id: string): ValidationRuleFunction | SimpleValidationRuleFunction | undefined;

package/dist/components/tt-validate/src/index.d.ts

@@ -1,36 +0,0 @@
-export { configure } from './config';
-export { defineRule } from './defineRule';
-export { ErrorMessage } from './ErrorMessage';
-export { type ComponentFieldBindingObject, Field, type FieldBindingObject, type FieldSlotProps, } from './Field';
-export { FieldArray } from './FieldArray';
-export { Form, type FormSlotProps } from './Form';
-export * from './symbols';
-export * from './types';
-export { type FieldOptions, type RuleExpression, useField } from './useField';
-export { useFieldArray } from './useFieldArray';
-export { useFieldError } from './useFieldError';
-export { useFieldValue } from './useFieldValue';
-export { type FormOptions, useForm, useFormContext } from './useForm';
-export { useFormErrors } from './useFormErrors';
-export { useFormValues } from './useFormValues';
-export { useIsFieldDirty } from './useIsFieldDirty';
-export { useIsFieldTouched } from './useIsFieldTouched';
-export { useIsFieldValid } from './useIsFieldValid';
-export { useIsFormDirty } from './useIsFormDirty';
-export { useIsFormTouched } from './useIsFormTouched';
-export { useIsFormValid } from './useIsFormValid';
-export { useIsSubmitting } from './useIsSubmitting';
-export { useIsValidating } from './useIsValidating';
-export { useResetForm } from './useResetForm';
-export { useSetFieldError } from './useSetFieldError';
-export { useSetFieldTouched } from './useSetFieldTouched';
-export { useSetFieldValue } from './useSetFieldValue';
-export { useSetFormErrors } from './useSetFormErrors';
-export { useSetFormTouched } from './useSetFormTouched';
-export { useSetFormValues } from './useSetFormValues';
-export { useSubmitCount } from './useSubmitCount';
-export { useSubmitForm } from './useSubmitForm';
-export { useValidateField } from './useValidateField';
-export { useValidateForm } from './useValidateForm';
-export { cleanupNonNestedPath, isNotNestedPath, normalizeRules } from './utils';
-export { validate, validateObjectSchema as validateObject } from './validate';

package/dist/components/tt-validate/src/symbols.d.ts

@@ -1,6 +0,0 @@
-import { InjectionKey } from 'vue';
-import { FormContext, PrivateFieldContext, PrivateFormContext } from './types';
-export declare const FormContextKey: InjectionKey<PrivateFormContext>;
-export declare const PublicFormContextKey: InjectionKey<FormContext>;
-export declare const FieldContextKey: InjectionKey<PrivateFieldContext<unknown>>;
-export declare const IS_ABSENT: unique symbol;

package/dist/components/tt-validate/src/types/common.d.ts

@@ -1,11 +0,0 @@
-import { MaybeRef, Ref } from 'vue';
-import { Path, PathValue } from './paths';
-export type GenericObject = Record<string, any>;
-export type MaybeArray<T> = T | T[];
-export type MaybePromise<T> = T | Promise<T>;
-export type FlattenAndSetPathsType<TRecord, TType> = {
-    [K in Path<TRecord>]: TType;
-};
-export type MapValuesPathsToRefs<TValues extends GenericObject, TPaths extends readonly [...MaybeRef<Path<TValues>>[]]> = {
-    readonly [K in keyof TPaths]: TPaths[K] extends MaybeRef<infer TKey> ? TKey extends Path<TValues> ? Ref<PathValue<TValues, TKey>> : Ref<unknown> : Ref<unknown>;
-};

package/dist/components/tt-validate/src/types/forms.d.ts

@@ -1,280 +0,0 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { PartialDeep } from 'type-fest';
-import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
-import { FlattenAndSetPathsType, GenericObject, MapValuesPathsToRefs, MaybeArray, MaybePromise } from './common';
-import { Path, PathValue } from './paths';
-import { FieldValidationMetaInfo } from './shared';
-export type ValidationResult<TValue = unknown> = {
-    errors: string[];
-    valid: boolean;
-    value?: TValue;
-};
-export type FlattenAndMapPathsValidationResult<TInput extends GenericObject, TOutput extends GenericObject> = {
-    [K in Path<TInput>]: ValidationResult<TOutput[K]>;
-};
-export type Locator = {
-    __locatorRef: string;
-} & ((values: GenericObject) => unknown);
-export interface FieldMeta<TValue> {
-    touched: boolean;
-    dirty: boolean;
-    valid: boolean;
-    validated: boolean;
-    pending: boolean;
-    initialValue?: TValue;
-}
-export interface FormMeta<TValues extends GenericObject> {
-    touched: boolean;
-    dirty: boolean;
-    valid: boolean;
-    pending: boolean;
-    initialValues?: Partial<TValues>;
-}
-export interface FieldState<TValue = unknown> {
-    value: TValue;
-    touched: boolean;
-    errors: string[];
-}
-export type InputType = 'checkbox' | 'radio' | 'default';
-/**
- * validated-only: only mutate the previously validated fields
- * silent: do not mutate any field
- * force: validate all fields and mutate their state
- */
-export type SchemaValidationMode = 'validated-only' | 'silent' | 'force' | 'no-validated';
-export type ValidationOptions = {
-    mode: SchemaValidationMode;
-    warn: boolean;
-};
-export type FieldValidator<TOutput> = (opts?: Partial<ValidationOptions>) => Promise<ValidationResult<TOutput>>;
-export type PathStateConfig<TOutput> = {
-    bails: boolean;
-    label: MaybeRefOrGetter<string | undefined>;
-    type: InputType;
-    validate: FieldValidator<TOutput>;
-    schema?: MaybeRefOrGetter<StandardSchemaV1 | undefined>;
-    /**
-     * 在判断 dirty 状态时需要排除的字段列表（仅对对象类型有效）
-     * @example
-     * excludeKeys: ['_timestamp']
-     */
-    excludeKeys?: string[];
-};
-export type IssueCollection<TPath = string> = {
-    path: TPath;
-    messages: string[];
-};
-export type PathState<TInput = unknown, TOutput = TInput> = {
-    id: number | number[];
-    path: string;
-    touched: boolean;
-    dirty: boolean;
-    valid: boolean;
-    validated: boolean;
-    pending: boolean;
-    initialValue: TInput | undefined;
-    value: TInput | undefined;
-    errors: string[];
-    bails: boolean;
-    label: string | undefined;
-    type: InputType;
-    multiple: boolean;
-    fieldsCount: number;
-    __flags: {
-        pendingUnmount: Record<string, boolean>;
-        pendingReset: boolean;
-    };
-    validate?: FieldValidator<TOutput>;
-};
-export type FieldEntry<TValue = unknown> = {
-    value: TValue;
-    key: string | number;
-    isFirst: boolean;
-    isLast: boolean;
-};
-export type FieldArrayContext<TValue = unknown> = {
-    fields: Ref<FieldEntry<TValue>[]>;
-    remove: (idx: number) => void;
-    replace: (newArray: TValue[]) => void;
-    update: (idx: number, value: TValue) => void;
-    push: (value: TValue) => void;
-    swap: (indexA: number, indexB: number) => void;
-    insert: (idx: number, value: TValue) => void;
-    prepend: (value: TValue) => void;
-    move: (oldIdx: number, newIdx: number) => void;
-};
-export type PrivateFieldArrayContext<TValue = unknown> = {
-    reset: () => void;
-    path: MaybeRefOrGetter<string>;
-} & FieldArrayContext<TValue>;
-export type PrivateFieldContext<TInput = unknown, TOutput = TInput> = {
-    id: number;
-    name: MaybeRef<string>;
-    value: Ref<TInput>;
-    meta: FieldMeta<TInput>;
-    errors: Ref<string[]>;
-    errorMessage: Ref<string | undefined>;
-    label?: MaybeRefOrGetter<string | undefined>;
-    type?: string;
-    bails?: boolean;
-    keepValueOnUnmount?: MaybeRefOrGetter<boolean | undefined>;
-    checkedValue?: MaybeRefOrGetter<TInput>;
-    uncheckedValue?: MaybeRefOrGetter<TInput>;
-    checked?: Ref<boolean>;
-    resetField: (state?: Partial<FieldState<TInput>>) => void;
-    handleReset: () => void;
-    validate: FieldValidator<TOutput>;
-    handleChange: (e: Event | unknown, shouldValidate?: boolean) => void;
-    handleBlur: (e?: Event, shouldValidate?: boolean) => void;
-    handleFocus: (e?: Event) => void;
-    setState: (state: Partial<FieldState<TInput>>) => void;
-    setTouched: (isTouched: boolean) => void;
-    setErrors: (message: string | string[]) => void;
-    setValue: (value: TInput, shouldValidate?: boolean) => void;
-};
-export type FieldContext<TValue = unknown> = Omit<PrivateFieldContext<TValue>, 'id' | 'instances'>;
-export type GenericValidateFunction<TValue = unknown> = (value: TValue, ctx: FieldValidationMetaInfo) => MaybePromise<boolean | MaybeArray<string>>;
-export interface FormState<TValues> {
-    values: PartialDeep<TValues>;
-    errors: Partial<Record<Path<TValues>, string | undefined>>;
-    touched: Partial<Record<Path<TValues>, boolean>>;
-    submitCount: number;
-}
-export type FormErrors<TValues extends GenericObject> = Partial<Record<Path<TValues> | '', string | undefined>>;
-export type FormErrorBag<TValues extends GenericObject> = Partial<Record<Path<TValues> | '', string[]>>;
-export interface ResetFormOpts {
-    force?: boolean;
-}
-export interface FormActions<TValues extends GenericObject, _TOutput = TValues> {
-    setFieldValue: <T extends Path<TValues>>(field: T, value: PathValue<TValues, T>, shouldValidate?: boolean) => void;
-    setFieldError: (field: Path<TValues>, message: string | string[] | undefined) => void;
-    setErrors: (fields: Partial<FlattenAndSetPathsType<TValues, string | string[] | undefined>>) => void;
-    setValues: (fields: Partial<TValues>, shouldValidate?: boolean) => void;
-    setFieldTouched: (field: Path<TValues>, isTouched: boolean) => void;
-    setTouched: (fields: Partial<Record<Path<TValues>, boolean>> | boolean) => void;
-    resetForm: (state?: Partial<FormState<TValues>>, opts?: Partial<ResetFormOpts>) => void;
-    resetField: (field: Path<TValues>, state?: Partial<FieldState>) => void;
-}
-export interface FormValidationResult<TInput extends GenericObject, TOutput extends GenericObject = TInput> {
-    valid: boolean;
-    results: Partial<FlattenAndMapPathsValidationResult<TInput, TOutput>>;
-    errors: Partial<Record<Path<TInput>, string>>;
-    values?: Partial<TOutput>;
-    source: 'schema' | 'fields' | 'none';
-}
-export interface SubmissionContext<TInput extends GenericObject = GenericObject> extends FormActions<TInput> {
-    evt?: Event;
-    controlledValues: Partial<TInput>;
-}
-export type SubmissionHandler<TInput extends GenericObject = GenericObject, TOutput = TInput, TReturn = unknown> = (values: TOutput, ctx: SubmissionContext<TInput>) => TReturn;
-export interface InvalidSubmissionContext<TInput extends GenericObject = GenericObject, TOutput extends GenericObject = TInput> {
-    values: TInput;
-    evt?: Event;
-    errors: Partial<Record<Path<TInput>, string>>;
-    results: FormValidationResult<TInput, TOutput>['results'];
-}
-export type InvalidSubmissionHandler<TInput extends GenericObject = GenericObject, TOutput extends GenericObject = TInput> = (ctx: InvalidSubmissionContext<TInput, TOutput>) => void;
-export type RawFormSchema<TValues> = Record<Path<TValues>, string | GenericValidateFunction | GenericObject>;
-export type FieldPathLookup<TValues extends GenericObject = GenericObject> = Partial<Record<Path<TValues>, PrivateFieldContext | PrivateFieldContext[]>>;
-type HandleSubmitFactory<TValues extends GenericObject, TOutput extends GenericObject = TValues> = <TReturn = unknown>(cb: SubmissionHandler<TValues, TOutput, TReturn>, onSubmitValidationErrorCb?: InvalidSubmissionHandler<TValues, TOutput>) => (e?: Event) => Promise<TReturn | undefined>;
-export type PublicPathState<TValue = unknown> = Omit<PathState<TValue>, 'bails' | 'label' | 'multiple' | 'fieldsCount' | 'validate' | 'id' | 'type' | '__flags'>;
-export interface BaseFieldProps {
-    onBlur: () => void;
-    onChange: () => void;
-    onInput: () => void;
-}
-export interface InputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> {
-    props: (state: PublicPathState<TValue>) => TExtraProps;
-    validateOnBlur: boolean;
-    label: MaybeRefOrGetter<string>;
-    validateOnChange: boolean;
-    validateOnInput: boolean;
-    validateOnModelUpdate: boolean;
-}
-export type LazyInputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> = (state: PublicPathState<TValue>) => Partial<{
-    props: TExtraProps;
-    validateOnBlur: boolean;
-    validateOnChange: boolean;
-    validateOnInput: boolean;
-    validateOnModelUpdate: boolean;
-}>;
-export interface ComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject, TModel extends string = 'modelValue'> {
-    mapProps: (state: PublicPathState<TValue>) => TExtraProps;
-    validateOnBlur: boolean;
-    validateOnModelUpdate: boolean;
-    model: TModel;
-}
-export type LazyComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject, TModel extends string = 'modelValue'> = (state: PublicPathState<TValue>) => Partial<{
-    props: TExtraProps;
-    validateOnBlur: boolean;
-    validateOnModelUpdate: boolean;
-    model: TModel;
-}>;
-export interface ComponentModellessBinds {
-    onBlur: () => void;
-}
-export type ComponentModelBinds<TValue = any, TModel extends string = 'modelValue'> = ComponentModellessBinds & {
-    [TKey in `onUpdate:${TModel}`]: (value: TValue) => void;
-};
-export type BaseComponentBinds<TValue = any, TModel extends string = 'modelValue'> = ComponentModelBinds<TValue, TModel> & {
-    [k in TModel]: TValue;
-};
-export interface BaseInputBinds<TValue = unknown> {
-    value: TValue | undefined;
-    onBlur: (e: Event) => void;
-    onChange: (e: Event) => void;
-    onInput: (e: Event) => void;
-}
-export interface PrivateFormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues> extends FormActions<TValues> {
-    name: string;
-    formId: number;
-    values: TValues;
-    initialValues: Ref<Partial<TValues>>;
-    controlledValues: Ref<TValues>;
-    fieldArrays: PrivateFieldArrayContext[];
-    submitCount: Ref<number>;
-    schema?: MaybeRef<RawFormSchema<TValues> | StandardSchemaV1<TValues, TOutput> | undefined>;
-    errorBag: Ref<FormErrorBag<TValues>>;
-    errors: ComputedRef<FormErrors<TValues>>;
-    meta: ComputedRef<FormMeta<TValues>>;
-    isSubmitting: Ref<boolean>;
-    isValidating: Ref<boolean>;
-    keepValuesOnUnmount: MaybeRef<boolean>;
-    validateSchema?: (mode: SchemaValidationMode) => Promise<FormValidationResult<TValues, TOutput>>;
-    validate: (opts?: Partial<ValidationOptions>) => Promise<FormValidationResult<TValues, TOutput>>;
-    validateField: <TPath extends Path<TValues>>(field: TPath, opts?: Partial<ValidationOptions>) => Promise<ValidationResult<TOutput[TPath]>>;
-    stageInitialValue: (path: string, value: unknown, updateOriginal?: boolean) => void;
-    unsetInitialValue: (path: string) => void;
-    handleSubmit: HandleSubmitFactory<TValues, TOutput> & {
-        withControlled: HandleSubmitFactory<TValues, TOutput>;
-    };
-    setFieldInitialValue: (path: string, value: unknown, updateOriginal?: boolean) => void;
-    createPathState: <TPath extends Path<TValues>>(path: MaybeRef<TPath>, config?: Partial<PathStateConfig<TOutput[TPath]>>) => PathState<PathValue<TValues, TPath>>;
-    getPathState: <TPath extends Path<TValues>>(path: TPath) => PathState<PathValue<TValues, TPath>> | undefined;
-    getAllPathStates: () => PathState[];
-    removePathState: <TPath extends Path<TValues>>(path: TPath, id: number) => void;
-    unsetPathValue: <TPath extends Path<TValues>>(path: TPath) => void;
-    destroyPath: (path: string) => void;
-    isFieldTouched: <TPath extends Path<TValues>>(path: TPath) => boolean;
-    isFieldDirty: <TPath extends Path<TValues>>(path: TPath) => boolean;
-    isFieldValid: <TPath extends Path<TValues>>(path: TPath) => boolean;
-    defineField: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>) => [Ref<TValue>, Ref<BaseFieldProps & TExtras>];
-    /**
-     * @deprecated use defineField instead
-     */
-    useFieldModel: (<TPath extends Path<TValues>>(path: TPath) => Ref<PathValue<TValues, TPath>>) & (<TPaths extends readonly [...MaybeRef<Path<TValues>>[]]>(paths: TPaths) => MapValuesPathsToRefs<TValues, TPaths>);
-    /**
-     * @deprecated use defineField instead
-     */
-    defineComponentBinds: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TModel extends string = 'modelValue', TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<ComponentBindsConfig<TValue, TExtras, TModel>> | LazyComponentBindsConfig<TValue, TExtras, TModel>) => Ref<BaseComponentBinds<TValue, TModel> & TExtras>;
-    /**
-     * @deprecated use defineField instead
-     */
-    defineInputBinds: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>) => Ref<BaseInputBinds<TValue> & TExtras>;
-}
-export interface FormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues> extends Omit<PrivateFormContext<TValues, TOutput>, 'formId' | 'schema' | 'initialValues' | 'getPathState' | 'getAllPathStates' | 'removePathState' | 'unsetPathValue' | 'validateSchema' | 'stageInitialValue' | 'setFieldInitialValue' | 'unsetInitialValue' | 'fieldArrays' | 'markForUnmount' | 'keepValuesOnUnmount' | 'values'> {
-    values: TValues;
-    handleReset: () => void;
-    submitForm: (e?: unknown) => Promise<void>;
-}
-export {};

package/dist/components/tt-validate/src/types/index.d.ts

@@ -1,3 +0,0 @@
-export * from './common';
-export * from './forms';
-export * from './paths';