@vunk/plus 1.13.1 → 1.15.0

package/ant/form/FormItem.d.ts

@@ -0,0 +1,191 @@
+import type { PropType, ExtractPropTypes, ComputedRef, Ref, ComponentPublicInstance, HTMLAttributes } from 'vue';
+import type { ColProps } from '../grid/Col';
+import type { CustomSlotsType } from '../_util/type';
+import type { FormLabelAlign, InternalNamePath, Rule, RuleError, ValidateOptions } from './interface';
+declare const ValidateStatuses: ["success", "warning", "error", "validating", ""];
+export type ValidateStatus = (typeof ValidateStatuses)[number];
+export interface FieldExpose {
+    fieldValue: Ref<any>;
+    fieldId: ComputedRef<any>;
+    fieldName: ComputedRef<any>;
+    resetField: () => void;
+    clearValidate: () => void;
+    namePath: ComputedRef<InternalNamePath>;
+    rules?: ComputedRef<Rule[]>;
+    validateRules: (options: ValidateOptions) => Promise<void> | Promise<RuleError[]>;
+}
+export declare const formItemProps: () => {
+    htmlFor: StringConstructor;
+    prefixCls: StringConstructor;
+    label: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    help: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    extra: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    labelCol: {
+        type: PropType<ColProps & HTMLAttributes>;
+    };
+    wrapperCol: {
+        type: PropType<ColProps & HTMLAttributes>;
+    };
+    hasFeedback: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colon: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    labelAlign: PropType<FormLabelAlign>;
+    prop: {
+        type: PropType<string | number | Array<string | number>>;
+    };
+    name: {
+        type: PropType<string | number | Array<string | number>>;
+    };
+    rules: PropType<Rule[] | Rule>;
+    autoLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    validateFirst: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    validateStatus: import("vue-types").VueTypeDef<string>;
+    validateTrigger: {
+        type: PropType<string | string[]>;
+    };
+    messageVariables: {
+        type: PropType<Record<string, string>>;
+    };
+    hidden: BooleanConstructor;
+    noStyle: BooleanConstructor;
+    tooltip: StringConstructor;
+};
+export type FormItemProps = Partial<ExtractPropTypes<ReturnType<typeof formItemProps>>>;
+export type FormItemExpose = {
+    onFieldBlur: () => void;
+    onFieldChange: () => void;
+    clearValidate: () => void;
+    resetField: () => void;
+};
+export type FormItemInstance = ComponentPublicInstance<FormItemProps, FormItemExpose>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    htmlFor: StringConstructor;
+    prefixCls: StringConstructor;
+    label: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    help: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    extra: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    labelCol: {
+        type: PropType<ColProps & HTMLAttributes>;
+    };
+    wrapperCol: {
+        type: PropType<ColProps & HTMLAttributes>;
+    };
+    hasFeedback: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colon: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    labelAlign: PropType<FormLabelAlign>;
+    prop: {
+        type: PropType<string | number | Array<string | number>>;
+    };
+    name: {
+        type: PropType<string | number | Array<string | number>>;
+    };
+    rules: PropType<Rule[] | Rule>;
+    autoLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    validateFirst: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    validateStatus: import("vue-types").VueTypeDef<string>;
+    validateTrigger: {
+        type: PropType<string | string[]>;
+    };
+    messageVariables: {
+        type: PropType<Record<string, string>>;
+    };
+    hidden: BooleanConstructor;
+    noStyle: BooleanConstructor;
+    tooltip: StringConstructor;
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    htmlFor: StringConstructor;
+    prefixCls: StringConstructor;
+    label: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    help: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    extra: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    labelCol: {
+        type: PropType<ColProps & HTMLAttributes>;
+    };
+    wrapperCol: {
+        type: PropType<ColProps & HTMLAttributes>;
+    };
+    hasFeedback: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colon: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    labelAlign: PropType<FormLabelAlign>;
+    prop: {
+        type: PropType<string | number | Array<string | number>>;
+    };
+    name: {
+        type: PropType<string | number | Array<string | number>>;
+    };
+    rules: PropType<Rule[] | Rule>;
+    autoLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    validateFirst: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    validateStatus: import("vue-types").VueTypeDef<string>;
+    validateTrigger: {
+        type: PropType<string | string[]>;
+    };
+    messageVariables: {
+        type: PropType<Record<string, string>>;
+    };
+    hidden: BooleanConstructor;
+    noStyle: BooleanConstructor;
+    tooltip: StringConstructor;
+}>> & Readonly<{}>, {
+    required: boolean;
+    hidden: boolean;
+    colon: boolean;
+    hasFeedback: boolean;
+    autoLink: boolean;
+    validateFirst: boolean;
+    noStyle: boolean;
+}, CustomSlotsType<{
+    help: any;
+    label: any;
+    extra: any;
+    default: any;
+    tooltip: any;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/ant/form/FormItemContext.d.ts

@@ -0,0 +1,32 @@
+import type { ComputedRef } from 'vue';
+import type { ValidateStatus } from './FormItem';
+export type FormItemContext = {
+    id: ComputedRef<string>;
+    onFieldBlur: () => void;
+    onFieldChange: () => void;
+    clearValidate: () => void;
+};
+export declare const useProvideFormItemContext: (props: FormItemContext, useValidation?: ComputedRef<boolean>) => void;
+export declare const useInjectFormItemContext: () => FormItemContext;
+declare const _default: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+export interface FormItemStatusContextProps {
+    isFormItemInput?: boolean;
+    status?: ValidateStatus;
+    hasFeedback?: boolean;
+    feedbackIcon?: any;
+}
+export declare const FormItemInputContext: {
+    useProvide: (props: FormItemStatusContextProps, newProps?: FormItemStatusContextProps) => {
+        isFormItemInput?: boolean;
+        status?: ValidateStatus;
+        hasFeedback?: boolean;
+        feedbackIcon?: any;
+    };
+    useInject: () => FormItemStatusContextProps;
+};
+export declare const NoFormStatus: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/ant/form/FormItemInput.d.ts

@@ -0,0 +1,44 @@
+import type { ColProps } from '../grid/Col';
+import type { ValidateStatus } from './FormItem';
+import type { CustomSlotsType, VueNode } from '../_util/type';
+export interface FormItemInputMiscProps {
+    prefixCls: string;
+    errors: VueNode[];
+    hasFeedback?: boolean;
+    validateStatus?: ValidateStatus;
+}
+export interface FormItemInputProps {
+    wrapperCol?: ColProps;
+    help?: VueNode;
+    extra?: VueNode;
+    status?: ValidateStatus;
+}
+declare const FormItemInput: import("vue").DefineComponent<{
+    errors?: any;
+    marginBottom?: any;
+    help?: any;
+    prefixCls?: any;
+    status?: any;
+    onErrorVisibleChanged?: any;
+    hasFeedback?: any;
+    onDomErrorVisibleChange?: any;
+    wrapperCol?: any;
+    extra?: any;
+}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    errors?: any;
+    marginBottom?: any;
+    help?: any;
+    prefixCls?: any;
+    status?: any;
+    onErrorVisibleChanged?: any;
+    hasFeedback?: any;
+    onDomErrorVisibleChange?: any;
+    wrapperCol?: any;
+    extra?: any;
+}> & Readonly<{}>, {}, CustomSlotsType<{
+    help: any;
+    errors: any;
+    extra: any;
+    default: any;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default FormItemInput;

package/ant/form/FormItemLabel.d.ts

@@ -0,0 +1,19 @@
+import type { ColProps } from '../grid/Col';
+import type { FormLabelAlign } from './interface';
+import type { RequiredMark } from './Form';
+import type { VueNode } from '../_util/type';
+import type { FunctionalComponent, HTMLAttributes } from 'vue';
+export interface FormItemLabelProps {
+    colon?: boolean;
+    htmlFor?: string;
+    label?: VueNode;
+    labelAlign?: FormLabelAlign;
+    labelCol?: ColProps & HTMLAttributes;
+    requiredMark?: RequiredMark;
+    required?: boolean;
+    prefixCls: string;
+    onClick: Function;
+    tooltip: string;
+}
+declare const FormItemLabel: FunctionalComponent<FormItemLabelProps>;
+export default FormItemLabel;

package/ant/form/context.d.ts

@@ -0,0 +1,35 @@
+import type { InjectionKey, ComputedRef } from 'vue';
+import type { ColProps } from '../grid';
+import type { RequiredMark } from './Form';
+import type { ValidateStatus, FieldExpose } from './FormItem';
+import type { FormLabelAlign, Rule, ValidateMessages } from './interface';
+export interface FormContextProps {
+    model?: ComputedRef<any>;
+    vertical: ComputedRef<boolean>;
+    name?: ComputedRef<string>;
+    colon?: ComputedRef<boolean>;
+    labelAlign?: ComputedRef<FormLabelAlign>;
+    labelWrap?: ComputedRef<boolean>;
+    labelCol?: ComputedRef<ColProps>;
+    wrapperCol?: ComputedRef<ColProps>;
+    requiredMark?: ComputedRef<RequiredMark>;
+    addField: (eventKey: string, field: FieldExpose) => void;
+    removeField: (eventKey: string) => void;
+    validateTrigger?: ComputedRef<string | string[]>;
+    rules?: ComputedRef<{
+        [k: string]: Rule[] | Rule;
+    }>;
+    onValidate: (name: string | number | Array<string | number>, status: boolean, errors: string[] | null) => void;
+    validateMessages: ComputedRef<ValidateMessages>;
+}
+export declare const FormContextKey: InjectionKey<FormContextProps>;
+export declare const useProvideForm: (state: FormContextProps) => void;
+export declare const useInjectForm: () => FormContextProps;
+/** Used for ErrorList only */
+export interface FormItemPrefixContextProps {
+    prefixCls: ComputedRef<string>;
+    status?: ComputedRef<ValidateStatus>;
+}
+export declare const FormItemPrefixContextKey: InjectionKey<FormItemPrefixContextProps>;
+export declare const useProvideFormItemPrefix: (state: FormItemPrefixContextProps) => void;
+export declare const useInjectFormItemPrefix: () => FormItemPrefixContextProps;

package/ant/form/index.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from 'vue';
+import Form, { formProps } from './Form';
+import FormItem, { formItemProps } from './FormItem';
+import useForm from './useForm';
+import FormItemRest, { useInjectFormItemContext } from './FormItemContext';
+export type { Rule, RuleObject } from './interface';
+export type { FormProps, FormInstance } from './Form';
+export type { FormItemProps, FormItemInstance } from './FormItem';
+export { FormItem, formItemProps, formProps, FormItemRest, useForm, useInjectFormItemContext };
+declare const _default: typeof Form & Plugin & {
+    readonly Item: typeof Form.Item;
+    readonly ItemRest: typeof FormItemRest;
+    readonly useForm: typeof useForm;
+    readonly useInjectFormItemContext: typeof useInjectFormItemContext;
+};
+export default _default;

package/ant/form/interface.d.ts

@@ -0,0 +1,171 @@
+import type { VueNode } from '../_util/type';
+export type FormLabelAlign = 'left' | 'right';
+export type InternalNamePath = (string | number)[];
+export type NamePath = string | number | InternalNamePath;
+export type StoreValue = any;
+export interface Store {
+    [name: string]: StoreValue;
+}
+export interface Meta {
+    touched: boolean;
+    validating: boolean;
+    errors: string[];
+    name: InternalNamePath;
+}
+export interface InternalFieldData extends Meta {
+    value: StoreValue;
+}
+/**
+ * Used by `setFields` config
+ */
+export interface FieldData extends Partial<Omit<InternalFieldData, 'name'>> {
+    name: NamePath;
+}
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'object' | 'enum' | 'date' | 'url' | 'hex' | 'email';
+type Validator = (rule: RuleObject, value: StoreValue, callback: (error?: string) => void) => Promise<void> | void;
+export interface ValidatorRule {
+    warningOnly?: boolean;
+    message?: string | VueNode;
+    /** custom validate function (Note: callback must be called) */
+    validator: Validator;
+}
+interface BaseRule {
+    warningOnly?: boolean;
+    /** validate the value from a list of possible values */
+    enum?: StoreValue[];
+    /** validate the exact length of a field */
+    len?: number;
+    /** validate the max length of a field */
+    max?: number;
+    /** validation error message */
+    message?: string | VueNode;
+    /** validate the min length of a field */
+    min?: number;
+    /** validate from a regular expression */
+    pattern?: RegExp;
+    /** indicates whether field is required */
+    required?: boolean;
+    /** transform a value before validation */
+    transform?: (value: StoreValue) => StoreValue;
+    /** built-in validation type, available options: https://github.com/yiminghe/async-validator#type */
+    type?: RuleType;
+    /** treat required fields that only contain whitespace as errors */
+    whitespace?: boolean;
+    /** Customize rule level `validateTrigger`. Must be subset of Field `validateTrigger` */
+    validateTrigger?: string | string[];
+    /** Check trigger timing */
+    trigger?: 'blur' | 'change' | Array<'change' | 'blur'>;
+}
+type AggregationRule = BaseRule & Partial<ValidatorRule>;
+interface ArrayRule extends Omit<AggregationRule, 'type'> {
+    type: 'array';
+    defaultField?: RuleObject;
+}
+export type RuleObject = AggregationRule | ArrayRule;
+export type Rule = RuleObject;
+export interface ValidateErrorEntity<Values = any> {
+    values: Values;
+    errorFields: {
+        name: InternalNamePath;
+        errors: string[];
+    }[];
+    outOfDate: boolean;
+}
+export interface FieldError {
+    name: InternalNamePath | string;
+    errors: string[];
+}
+export interface RuleError {
+    errors: string[];
+    rule: RuleObject;
+}
+export interface ValidateOptions {
+    triggerName?: string;
+    validateMessages?: ValidateMessages;
+}
+export type InternalValidateFields = (nameList?: NamePath[], options?: ValidateOptions) => Promise<Store>;
+export type ValidateFields = (nameList?: NamePath[]) => Promise<Store>;
+interface ValueUpdateInfo {
+    type: 'valueUpdate';
+    source: 'internal' | 'external';
+}
+interface ValidateFinishInfo {
+    type: 'validateFinish';
+}
+interface ResetInfo {
+    type: 'reset';
+}
+interface SetFieldInfo {
+    type: 'setField';
+    data: FieldData;
+}
+interface DependenciesUpdateInfo {
+    type: 'dependenciesUpdate';
+    /**
+     * Contains all the related `InternalNamePath[]`.
+     * a <- b <- c : change `a`
+     * relatedFields=[a, b, c]
+     */
+    relatedFields: InternalNamePath[];
+}
+export type NotifyInfo = ValueUpdateInfo | ValidateFinishInfo | ResetInfo | SetFieldInfo | DependenciesUpdateInfo;
+export type ValuedNotifyInfo = NotifyInfo & {
+    store: Store;
+};
+export interface Callbacks<Values = any> {
+    onValuesChange?: (changedValues: any, values: Values) => void;
+    onFieldsChange?: (changedFields: FieldData[], allFields: FieldData[]) => void;
+    onFinish?: (values: Values) => void;
+    onFinishFailed?: (errorInfo: ValidateErrorEntity<Values>) => void;
+    onValidate?: (name: string | number | string[] | number[], status: boolean, errors: string[] | null) => void;
+}
+export type EventArgs = any[];
+type ValidateMessage = string | (() => string);
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage;
+    enum?: ValidateMessage;
+    whitespace?: ValidateMessage;
+    date?: {
+        format?: ValidateMessage;
+        parse?: ValidateMessage;
+        invalid?: ValidateMessage;
+    };
+    types?: {
+        string?: ValidateMessage;
+        method?: ValidateMessage;
+        array?: ValidateMessage;
+        object?: ValidateMessage;
+        number?: ValidateMessage;
+        date?: ValidateMessage;
+        boolean?: ValidateMessage;
+        integer?: ValidateMessage;
+        float?: ValidateMessage;
+        regexp?: ValidateMessage;
+        email?: ValidateMessage;
+        url?: ValidateMessage;
+        hex?: ValidateMessage;
+    };
+    string?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    number?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    array?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    pattern?: {
+        mismatch?: ValidateMessage;
+    };
+}
+export {};

package/ant/form/style/explain.d.ts

@@ -0,0 +1,4 @@
+import type { FormToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genFormValidateMotionStyle: GenerateStyle<FormToken>;
+export default genFormValidateMotionStyle;

package/ant/form/style/index.d.ts

@@ -0,0 +1,7 @@
+import type { FullToken } from '../../theme/internal';
+export interface FormToken extends FullToken<'Form'> {
+    formItemCls: string;
+    rootPrefixCls: string;
+}
+declare const _default: (_prefixCls?: import("vue").Ref<string>) => import("../../theme/internal").UseComponentStyleResult;
+export default _default;

package/ant/form/useForm.d.ts

@@ -0,0 +1,45 @@
+import type { Ref } from 'vue';
+import type { Callbacks, RuleError, ValidateMessages } from './interface';
+import type { ValidateStatus } from './FormItem';
+interface DebounceSettings {
+    leading?: boolean;
+    wait?: number;
+    trailing?: boolean;
+}
+export interface Props {
+    [key: string]: any;
+}
+export interface validateOptions {
+    validateFirst?: boolean;
+    validateMessages?: ValidateMessages;
+    trigger?: 'change' | 'blur' | string | string[];
+}
+type namesType = string | string[];
+export interface ValidateInfo {
+    autoLink?: boolean;
+    required?: boolean;
+    validateStatus?: ValidateStatus;
+    help?: any;
+}
+export interface validateInfos {
+    [key: string]: ValidateInfo;
+}
+declare function useForm(modelRef: Props | Ref<Props>, rulesRef?: Props | Ref<Props>, options?: {
+    immediate?: boolean;
+    deep?: boolean;
+    validateOnRuleChange?: boolean;
+    debounce?: DebounceSettings;
+    onValidate?: Callbacks['onValidate'];
+}): {
+    modelRef: Props | Ref<Props>;
+    rulesRef: Props | Ref<Props>;
+    initialModel: Props;
+    validateInfos: validateInfos;
+    resetFields: (newValues?: Props) => void;
+    validate: <T = any>(names?: namesType, option?: validateOptions) => Promise<T>;
+    /** This is an internal usage. Do not use in your prod */
+    validateField: (name: string, value: any, rules: Record<string, unknown>[], option?: validateOptions) => Promise<RuleError[]>;
+    mergeValidateInfo: (items: ValidateInfo | ValidateInfo[]) => ValidateInfo;
+    clearValidate: (names?: namesType) => void;
+};
+export default useForm;

package/ant/form/utils/asyncUtil.d.ts

@@ -0,0 +1,2 @@
+import type { FieldError } from '../interface';
+export declare function allPromiseFinish(promiseList: Promise<FieldError>[]): Promise<FieldError[]>;

package/ant/form/utils/messages.d.ts

@@ -0,0 +1,47 @@
+export declare const defaultValidateMessages: {
+    default: string;
+    required: string;
+    enum: string;
+    whitespace: string;
+    date: {
+        format: string;
+        parse: string;
+        invalid: string;
+    };
+    types: {
+        string: string;
+        method: string;
+        array: string;
+        object: string;
+        number: string;
+        date: string;
+        boolean: string;
+        integer: string;
+        float: string;
+        regexp: string;
+        email: string;
+        url: string;
+        hex: string;
+    };
+    string: {
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+    };
+    number: {
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+    };
+    array: {
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+    };
+    pattern: {
+        mismatch: string;
+    };
+};

package/ant/form/utils/typeUtil.d.ts

@@ -0,0 +1 @@
+export declare function toArray<T>(value?: T | T[] | null): T[];

package/ant/form/utils/useDebounce.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export default function useDebounce<T>(value: Ref<T[]>): Ref<T[]>;

package/ant/form/utils/validateUtil.d.ts

@@ -0,0 +1,6 @@
+import type { InternalNamePath, RuleError, RuleObject, ValidateOptions } from '../interface';
+/**
+ * We use `async-validator` to validate the value.
+ * But only check one value in a time to avoid namePath validate issue.
+ */
+export declare function validateRules(namePath: InternalNamePath, value: any, rules: RuleObject[], options: ValidateOptions, validateFirst: boolean | 'parallel', messageVariables?: Record<string, string>): Promise<RuleError[]>;

package/ant/form/utils/valueUtil.d.ts

@@ -0,0 +1,15 @@
+import type { InternalNamePath, NamePath } from '../interface';
+/**
+ * Convert name to internal supported format.
+ * This function should keep since we still thinking if need support like `a.b.c` format.
+ * 'a' => ['a']
+ * 123 => [123]
+ * ['a', 123] => ['a', 123]
+ */
+export declare function getNamePath(path: NamePath | null): InternalNamePath;
+export declare function getValue<T>(store: T, namePath: InternalNamePath): any;
+export declare function setValue<T>(store: T, namePath: InternalNamePath, value: any, removeIfUndefined?: boolean): T;
+export declare function containsNamePath(namePathList: InternalNamePath[], namePath: InternalNamePath): boolean;
+export declare function setValues<T>(store: T, ...restValues: T[]): T;
+export declare function cloneByNamePathList<T>(store: T, namePathList: InternalNamePath[]): T;
+export declare function matchNamePath(namePath: InternalNamePath, changedNamePath: InternalNamePath | null): boolean;