import { RequiredBy, PropTypes, JSX, DirectionProperty, CommonProperties, NormalizeProps } from '@zag-js/types';
import * as _zag_js_core from '@zag-js/core';
import { StateMachine, Machine } from '@zag-js/core';

interface FieldOptions<K extends string> {
    type?: string;
    validate?: ValidatorFn<K>;
}
type ValiidatorResult = string | null | Promise<string | null>;
type ValidatorFn<K extends string = string> = (value: any, values: Record<K, any>) => ValiidatorResult;
type ValidateRules<K extends string> = Partial<Record<K, ValidatorFn<K>>>;
interface FieldPublicContext extends DirectionProperty, CommonProperties {
    /**
     * The value of the field
     */
    value?: any;
    /**
     * Validation rule for the field
     */
    validate?: ValidatorFn;
}
type FieldUserDefinedContext = RequiredBy<FieldPublicContext, "id">;
type FieldComputedContext = Readonly<{}>;
interface FieldPrivateContext {
}
interface FieldMachineContext extends FieldPublicContext, FieldPrivateContext, FieldComputedContext {
}
interface FieldMachineState {
    value: "idle" | "validating" | "valid" | "invalid";
}
type FieldChangeEvent = {
    type: "CHANGE";
    value: any;
};
type FieldFocusEvent = {
    type: "FOCUS";
};
type FieldBlurEvent = {
    type: "BLUR";
};
type FieldValidateEvent = {
    type: "VALIDATE";
    validator?: ValidatorFn;
    values?: Record<string, any>;
};
type FieldResetErrorEvent = {
    type: "RESET_ERROR";
};
type FieldMachineEvent = FieldFocusEvent | FieldBlurEvent | FieldChangeEvent | FieldValidateEvent | FieldResetErrorEvent;
type FieldState = StateMachine.State<FieldMachineContext, FieldMachineState, FieldMachineEvent>;
type FieldSend = StateMachine.Send<FieldMachineEvent>;
type FieldService = Machine<FieldMachineContext, FieldMachineState, FieldMachineEvent>;
type ElementIds<K> = Partial<{
    form: string;
    field(name: K): string;
}>;
interface FormPublicContext<K extends string> extends DirectionProperty, CommonProperties {
    /**
     * The ids of the elements in the form. Useful for composition.
     */
    ids?: ElementIds<K>;
    /**
     * The default values of the fields in the form
     */
    defaultValues: Record<K, any> | (() => Record<K, any> | Promise<Record<K, any>>);
    /**
     * Validation rules for the form
     */
    validate?: ValidateRules<K>;
    /**
     * When validation gets triggered
     * @default "all"
     */
    validation: "change" | "submit" | "blur" | "all";
    /**
     * Whether to focus on the first field with error after submitting
     * @default true
     */
    focusOnError?: boolean;
}
type FormUserDefinedContext<K extends string> = RequiredBy<FormPublicContext<K>, "id">;
type FormComputedContext = Readonly<{}>;
interface FormPrivateContext<K extends string> {
}
interface FormMachineContext<K extends string> extends FormPublicContext<K>, FormPrivateContext<K>, FormComputedContext {
}
interface FormMachineState {
    value: "loading" | "initialized" | "submitting" | "submitted";
}
type FormInitializeEvent = {
    type: "INITIALIZE";
};
type FormInitializedEvent = {
    type: "INITIALIZED";
};
type FormFieldChangeEvent<K extends string> = {
    type: "FIELD.CHANGE";
    name: K;
    value: any;
};
type FormFieldFocusEvent<K extends string> = {
    type: "FIELD.FOCUS";
    name: K;
};
type FormFieldBlurEvent<K extends string> = {
    type: "FIELD.BLUR";
    name: K;
};
type FormSubmitEvent<K extends string> = {
    type: "SUBMIT";
    cb: (values: Record<K, any>) => void;
};
type FormSubmittedEvent = {
    type: "SUBMITTED";
};
type FormSubmitAbortEvent = {
    type: "SUBMIT.ABORT";
};
type FormMachineEvent<K extends string> = FormInitializeEvent | FormInitializedEvent | FormFieldChangeEvent<K> | FormFieldFocusEvent<K> | FormFieldBlurEvent<K> | FormSubmitEvent<K> | FormSubmittedEvent | FormSubmitAbortEvent;
type FormState<K extends string> = StateMachine.State<FormMachineContext<K>, FormMachineState, FormMachineEvent<K>>;
type FormSend<K extends string> = StateMachine.Send<FormMachineEvent<K>>;
type FormService<K extends string> = Machine<FormMachineContext<K>, FormMachineState, FormMachineEvent<K>>;
interface FormMachineApi<K extends string, T extends PropTypes = PropTypes> {
    /**
     * Whether the form is dirty
     */
    dirty: boolean;
    /**
     * Whether the form is validating
     */
    validating: boolean;
    /**
     * Errors in the form
     */
    errors: Record<K, string>;
    /**
     * Function to get Current values of the form
     */
    getValues: () => Record<K, any>;
    /**
     * Function to submit the form.
     */
    onSubmit<E extends JSX.FormEvent<HTMLFormElement>>(cb: (values: Record<K, any>) => void): (event?: E) => void;
    getFieldProps(name: K, options?: FieldOptions<K>): T["element"];
}

declare function formConnect<K extends string, T extends PropTypes>(state: FormState<K>, send: FormSend<K>, normalize: NormalizeProps<T>): FormMachineApi<K, T>;

declare function createFormmachine<K extends string>(userContext: FormUserDefinedContext<K>): _zag_js_core.Machine<FormMachineContext<K>, FormMachineState, FormMachineEvent<K>>;

declare function createFieldMachine(userContext: FieldUserDefinedContext): _zag_js_core.Machine<FieldMachineContext, FieldMachineState, FieldMachineEvent>;

declare const form: {
    connect: typeof formConnect;
    machine: typeof createFormmachine;
};
declare const field: {
    machine: typeof createFieldMachine;
};

export { type ElementIds, type FieldMachineContext, type FieldMachineEvent, type FieldMachineState, type FieldSend, type FieldService, type FieldState, type FieldUserDefinedContext, type FormMachineApi, type FormMachineContext, type FormMachineEvent, type FormMachineState, type FormSend, type FormService, type FormState, type FormUserDefinedContext, field, form };