/**
 * @regle/core v1.23.0
 * (c) 2026 Victor Garcia
 * @license MIT
 */

import { ComputedRef, MaybeRef, MaybeRefOrGetter, Plugin, Raw, Ref, UnwrapNestedRefs, UnwrapRef } from "vue";
import { EmptyObject, Get, IsAny, IsEmptyObject, IsLiteral, IsNever, IsNullable, IsOptional, IsStringLiteral, IsUnion, IsUnknown, Merge, Or, Paths, RequireAtLeastOne, RequireOneOrNone, RequiredDeep, UnionToIntersection, UnionToTuple } from "type-fest";
import { StandardSchemaV1 } from "@standard-schema/spec";
interface GlobalConfigOverrides<TValue extends unknown = unknown> {
  /**
   * Override the default $edited handler.
   */
  isEdited?: isEditedHandlerFn<TValue>;
}
type isEditedHandlerFn<TValue extends unknown = unknown> = (currentValue: MaybeInput<TValue>, initialValue: MaybeInput<TValue>, defaultHandlerFn: (currentValue: unknown, initialValue: unknown) => boolean) => boolean;
interface RegleBehaviourOptions {
  /**
   * Does not run rules until the field is dirty.
   * @default false
   */
  lazy?: boolean | undefined;
  /**
   * Automatically set the dirty state to true when value is changed without the need of calling `$touch`.
   * @default true
   *
   */
  autoDirty?: boolean | undefined;
  /**
   * Only update error status when calling `$validate` or `$validateSync`.
   * Will not display errors as you type
   * @default false
   *
   * @default true if rewardEarly is true
   *
   */
  silent?: boolean | undefined;
  /**
   * The fields will turn valid when they are, but not invalid unless calling `r$.$validate()` or `$validateSync`
   * @default false
   */
  rewardEarly?: boolean | undefined;
  /**
   * Define whether the external errors should be cleared when updating a field
   *
   * Default to `false` if `$silent` is set to `true`
   *
   * @default true
   */
  clearExternalErrorsOnChange?: boolean | undefined;
  /**
   * Define whether the external errors should be cleared when calling `$validate` or `$validateSync`
   *
   * @default true
   */
  clearExternalErrorsOnValidate?: boolean | undefined;
  /**
   * Set the dirty state to true when the form is initialized.
   * @default false
   */
  immediateDirty?: boolean | undefined;
  /**
   * Disable all the computation
   * @default false
   */
  disabled?: boolean | undefined;
}
interface LocalRegleBehaviourOptions<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<TState>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}> {
  /**
   * A dictionary of external errors to be injected into the field statuses.
   *
   * Useful for integrating errors from a backend or other validation sources.
   * External errors can be assigned using a reactive object or a Ref, and will be merged into the `$externalErrors` and `$errors` properties for each field.
   * You can also call `r$.$setExternalErrors(...)` directly without providing this option.
   * Pass this option when the same external errors ref needs to be owned and synchronized outside of Regle.
   *
   * More details: https://reglejs.dev/advanced-usage/external-errors
   */
  externalErrors?: Ref<RegleExternalErrorTree<Unwrap<TState>> | Record<string, string[]>>;
  /**
   * Allows you to group fields for custom collective validation logic.
   *
   * The `validationGroups` option lets you define logical groupings of fields within your form that should be validated or checked together.
   * This can be used, for example, to easily determine if a subset of your form (e.g. an "address" group or a set of "contact information" fields) are all valid or share a collective error state.
   *
   * The function receives the `$fields` object and must return an object where each key is a group name and the value is an array of RegleStatus or RegleFieldStatus instances representing the grouped fields.
   * These groups can then be referenced using `$validationGroups.<groupName>` to access their combined validation state (e.g. `$invalid`, `$error`, `$errors`, etc).
   *
   * More details: https://reglejs.dev/core-concepts/modifiers#validationgroups
   */
  validationGroups?: (fields: RegleStatus<TState, TRules>['$fields']) => TValidationGroups;
  /**
   * A unique identifier for the Regle instance in the devtools.
   * @default undefined
   */
  id?: string | undefined;
}
type FieldOnlyRegleBehaviourOptions = {
  /**
   * Set external errors for the field.
   */
  externalErrors?: Ref<string[]>;
  /**
   * A unique identifier for the Regle instance in the devtools.
   * @default undefined
   */
  id?: string | undefined;
};
type RegleValidationGroupEntry = RegleFieldStatus<any, any> | undefined;
interface RegleValidationGroupOutput {
  /** Indicates whether any field in the validation group is invalid. */
  $invalid: boolean;
  /** Convenience flag to easily decide if an error message should be displayed. True when any field in the group is dirty, not pending, and invalid. */
  $error: boolean;
  /** Indicates if any async rule in the validation group is currently running. */
  $pending: boolean;
  /** Indicates whether any field in the validation group has been interacted with by the user. */
  $dirty: boolean;
  /** Indicates whether all fields in the validation group pass validation and are dirty. */
  $correct: boolean;
  /** Collection of all error messages from fields in the group where $dirty equals true. */
  $errors: string[];
  /** Collection of all error messages from fields in the group, regardless of $dirty state. */
  $silentErrors: string[];
}
type FieldRegleBehaviourOptions<TValue extends unknown = unknown> = AddDollarToOptions<RegleBehaviourOptions> & {
  /**
   * Let you declare the number of milliseconds the rule needs to wait before executing. Useful for async or heavy computations.
   */
  $debounce?: number;
  /**
   * Override the default `$edited` handler.
   */
  $isEdited?: isEditedHandlerFn<TValue>;
};
type CollectionRegleBehaviourOptions<TValue extends unknown = unknown> = FieldRegleBehaviourOptions<TValue> & {
  /**
   * Allow deep compare of array children to compute the `$edited` property
   *
   * Disabled by default for performance
   *
   * @default false
   * */
  $deepCompare?: boolean;
};
type ResolvedRegleBehaviourOptions = DeepMaybeRef<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>, Record<string, any>, Record<string, any[]>>;
type ShortcutCommonFn<T extends Record<string, any>> = {
  [x: string]: (element: Omit<OmitByType<T, Function>, '~standard'>) => unknown;
};
type ShortcutFieldStatus<TCustomRules extends Record<string, any>> = RegleFieldStatus<any, Partial<TCustomRules> & Partial<DefaultValidators>>;
type ShortcutNestedStatus<TCustomRules extends Record<string, any>> = RegleStatus<Record<string, any>, ReglePartialRuleTree<any, Partial<TCustomRules>>>;
type ShortcutCollectionStatus<TCustomRules extends Record<string, any>> = RegleCollectionStatus<any[], Partial<TCustomRules> & Partial<DefaultValidators>>;
type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
  /**
   * Allow you to customize the properties for every field
   */
  fields?: ShortcutCommonFn<ShortcutFieldStatus<TCustomRules>>;
  /**
   * Allow you to customize the properties for every parent of a nested object
   */
  nested?: ShortcutCommonFn<ShortcutNestedStatus<TCustomRules>>;
  /**
   * Allow you to customize the properties for every parent of a collection
   */
  collections?: ShortcutCommonFn<ShortcutCollectionStatus<TCustomRules>>;
};
type AddDollarToOptions<T extends Record<string, any>> = { [K in keyof T as `$${string & K}`]: T[K] };
/**
 * The main Regle type that represents a complete validation instance.
 *
 * @template TState - The shape of the state object being validated
 * @template TRules - The validation rules tree for the state
 * @template TValidationGroups - Groups of validation rules that can be run together
 * @template TShortcuts - Custom shortcut definitions for common validation patterns
 * @template TAdditionalReturnProperties - Additional properties to extend the return type
 *
 */
type Regle<TState extends Record<string, any> = EmptyObject, TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> = EmptyObject, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
  /**
   * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
   *
   * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
   */
  r$: Raw<RegleRoot<TState, TRules, TValidationGroups, TShortcuts>>;
} & TAdditionalReturnProperties;
/**
 * The type for a single field validation instance.
 *
 * @template TState - The type of the state value being validated
 * @template TRules - The validation rules for the field
 * @template TShortcuts - Custom shortcut definitions for common validation patterns
 * @template TAdditionalReturnProperties - Additional properties to extend the return type
 */
type RegleSingleField<TState extends Maybe<PrimitiveTypes> = any, TRules extends RegleRuleDecl<NonNullable<TState>, CustomRulesDeclarationTree> = EmptyObject, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
  /**
   * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
   *
   * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
   */
  r$: Raw<RegleFieldStatus<TState, TRules, TShortcuts>>;
} & TAdditionalReturnProperties;
type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? never : ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
type InferDeepReactiveState<TState> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? MaybeRef<TState> : NonNullable<TState> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState> extends Date | File ? MaybeRef<TState> : NonNullable<TState> extends Record<string, any> ? DeepReactiveState<TState> : MaybeRef<TState>;
type ResetOptions<TState extends unknown> = RequireOneOrNone<{
  /**
   * Reset validation status and reset form state to its initial state.
   *
   * Initial state is different than the original state as the initial state can be mutated when using `$reset`.
   *
   * This serve as the base comparison state for `$edited` property.
   *
   * ⚠️ This doesn't work if the state is a `reactive` object.
   */
  toInitialState?: boolean;
  /**
   * Reset validation status and reset form state to its original state.
   *
   * Original state is the unmutated state that was passed to the form when it was initialized.
   */
  toOriginalState?: boolean;
  /**
   * Reset validation status and reset form state to the given state
   * Also set the new state as the initial state.
   */
  toState?: TState | (() => TState);
  /**
   * Clears the $externalErrors state back to an empty object.
   *
   * @default true
   */
  clearExternalErrors?: boolean;
  /**
   * Keep the validation state of the form ($dirty, $invalid, $pending etc..)
   * Only useful if you only want to reset the form state.
   *
   * @default false
   */
  keepValidationState?: boolean;
}, 'toInitialState' | 'toState'>;
type ScopedInstancesRecord = Record<string, Record<string, SuperCompatibleRegleRoot>> & {
  '~~global': Record<string, SuperCompatibleRegleRoot>;
};
type ScopedInstancesRecordLike = Partial<ScopedInstancesRecord>;
type PartialFormState<TState extends Record<string, any>> = [unknown] extends [TState] ? {} : Prettify<{ [K in keyof TState as ExtendOnlyRealRecord<TState[K]> extends true ? never : TState[K] extends Array<any> ? never : K]?: MaybeOutput<TState[K]> } & { [K in keyof TState as ExtendOnlyRealRecord<TState[K]> extends true ? K : TState[K] extends Array<any> ? K : never]: NonNullable<TState[K]> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : PartialFormState<TState[K]> }>;
type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = {
  /** The result of the validation */valid: false; /** Output data, filter the result by checking the `valid` property */
  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules> extends true ? isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : HasNamedKeys<Data> extends true ? HasNamedKeys<TRules> extends true ? NonNullable<Data> extends Date | File ? MaybeOutput<Raw<Data>> : NonNullable<Data> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : NonNullable<Data> extends Record<string, any> ? PartialFormState<NonNullable<Data>> : MaybeOutput<Data> : isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : unknown;
  /**
   * Collection of all the error messages, collected for all children properties and nested forms.
   *
   * Only contains errors from properties where $dirty equals true.
   * */
  issues: DataTypeRegleIssues<Data, TRules>;
  /**
   * Collection of all the issues, collected for all children properties and nested forms.
   *
   * Only contains issues from properties where $dirty equals true.
   */
  errors: DataTypeRegleErrors<Data>;
} | {
  valid: true;
  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules> extends true ? isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : HasNamedKeys<Data> extends true ? HasNamedKeys<TRules> extends true ? NonNullable<Data> extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules extends ReglePartialRuleTree<any> ? TRules : {}>[] : NonNullable<Data> extends Date | File ? SafeFieldProperty<Raw<NonNullable<Data>>, TRules extends ReglePartialRuleTree<any> ? TRules : {}> : NonNullable<Data> extends Record<string, any> ? DeepSafeFormState<NonNullable<Data>, TRules extends ReglePartialRuleTree<any> ? TRules : {}> : SafeFieldProperty<Data, TRules extends ReglePartialRuleTree<any> ? TRules : {}> : isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : unknown;
  issues: EmptyObject;
  errors: EmptyObject;
};
type DataTypeRegleIssues<TData extends Record<string, any> | any[] | unknown, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any> = never> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? RegleFieldIssue<TRules>[] : RegleCollectionErrors<TData, true> : isRecordLiteral<TData> extends true ? RegleIssuesTree<TData> : RegleFieldIssue<TRules>[] : RegleFieldIssue | RegleCollectionErrors<TData, true> | RegleIssuesTree<TData>;
type DataTypeRegleErrors<TData extends Record<string, any> | any[] | unknown> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? string[] : RegleCollectionErrors<TData> : isRecordLiteral<TData> extends true ? RegleErrorTree<TData> : string[] : string[] | RegleErrorTree<TData> | RegleCollectionErrors<TData>;
type RegleCollectionResult<Data extends any[], TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
  valid: false;
  issues: RegleCollectionErrors<Data, true>;
  errors: RegleCollectionErrors<Data>;
} | {
  valid: true;
  issues: EmptyObject;
  errors: EmptyObject;
});
type RegleFieldResult<Data extends any, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
  valid: false;
  issues: RegleFieldIssue<TRules>[];
  errors: string[];
} | {
  valid: true;
  issues: [];
  errors: [];
});
type $InternalRegleResult = {
  valid: boolean;
  data: any;
  errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
  issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
};
type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | undefined> = IsUnknown<TState> extends true ? {} : IsAny<TState> extends true ? unknown : TRules extends undefined ? TState : HasNamedKeys<TState> extends true ? TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> ? Prettify<{ [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? K : never]?: SafeProperty<TState[K], TRules[K]> extends MaybeInput<infer M> ? MaybeOutput<M> : SafeProperty<TState[K], TRules[K]> } & { [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? never : K]-?: IsUnknown<SafeProperty<TState[K], TRules[K]>> extends true ? unknown : IsAny<TState[K]> extends true ? unknown : NonNullable<SafeProperty<TState[K], TRules[K]>> }> : TState : TState;
type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRefOrComputedRef<RegleRuleDecl<any, any>> ? UnwrapRef<TRule> extends infer TRuleResolved extends Record<string, any> ? { [K in keyof TRuleResolved]-?: TRuleResolved[K] extends RegleRuleDefinition<unknown, any, any[], any, any, any, any, true> ? true : false }[keyof TRuleResolved] extends false ? false : true : false : false;
type ObjectHaveAtLeastOneRequiredField<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<TState, any>> = TState extends Maybe<TState> ? ({ [K in keyof NonNullable<TState>]-?: IsPropertyOutputRequired<NonNullable<TState>[K], TRules[K] extends RegleFormPropertyType<any, any> ? TRules[K] : {}> } & {
  $self: IsPropertyOutputRequired<string, TRules['$self']>;
})[keyof TState | '$self'] extends false ? false : true : true;
type ArrayHaveAtLeastOneRequiredField<TState extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<any>> = TState extends Maybe<TState> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement<NonNullable<TState>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = unknown extends TState ? unknown : [TRule] extends [RegleCollectionRuleDecl<any, any>] ? TState extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[] : TState : [TRule] extends [ReglePartialRuleTree<any, any>] ? ExtendOnlyRealRecord<TState> extends true ? DeepSafeFormState<NonNullable<TState> extends Record<string, any> ? JoinDiscriminatedUnions<NonNullable<TState>> : {}, TRule> : [TRule] extends [MaybeRef<RegleRuleDecl<any, any>>] ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends true ? TState : MaybeOutput<TState> : TState : TState;
type IsPropertyOutputRequired<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState] ? unknown : NonNullable<TState> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, TRule extends ReglePartialRuleTree<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, any> ? TRule : {}> extends false ? false : true : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends false ? false : true : false : false;
type SafeFieldProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = FieldHaveRequiredRule<TRule> extends true ? NonNullable<TState> : MaybeOutput<TState>;
/** Types to be augmented by @regle/schemas */
interface NarrowVariantExtracts {}
interface NarrowVariantFieldExtracts<T extends unknown> {}
type NarrowVariant<TRoot extends {
  [x: string]: unknown;
  $fields: {
    [x: string]: unknown;
  };
  $value: unknown;
}, TKey extends keyof TRoot, TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
  $value: infer V;
} ? V : unknown)> = Extract<TRoot, { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue>[keyof NarrowVariantFieldExtracts<TValue>]) }> & {
  $fields: Extract<TRoot['$fields'], { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue>[keyof NarrowVariantFieldExtracts<TValue>]) }> & { [K in TKey]: TRoot[K] & {
    $value: TValue;
  } };
} & {
  $value: Omit<TRoot['$value'], TKey> & { [K in TKey]: TValue };
} & { [K in TKey]: TRoot[K] & {
  $value: TValue;
} };
type MaybeVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}, TIsUnionOverride extends boolean = false,
/**
 * Workaround for $each variants, TS generic can't detect if the Rules are an union when type is too nested, to the tuple is passed from parent
 */
TRulesTuple extends any[] = never> = IsUnion<NonNullable<TState>> extends true ? Or<TIsUnionOverride, IsUnion<TRules>> extends true ? (IsNever<TRulesTuple> extends true ? TRules : TRulesTuple[number]) extends infer RulesUnionTuple extends ReglePartialRuleTree<NonNullable<TState>> ? ProcessChildrenFields<NonNullable<TState>, RulesUnionTuple, TShortcuts> extends infer TChildren ? Omit<RegleStatus<NonNullable<TState>, RulesUnionTuple, TShortcuts>, '$fields'> & {
  $fields: TChildren[keyof TChildren];
} & (HasNamedKeys<NonNullable<TState>> extends true ? TChildren[keyof TChildren] : {}) : never : RegleStatus<JoinDiscriminatedUnions<NonNullable<TState>>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<NonNullable<TState>>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<JoinDiscriminatedUnions<NonNullable<TState>>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<NonNullable<TState>>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<TState, TRules, TShortcuts>;
/** Helper type to extract state tuple item at index */
type StateTupleItem<TStateTuple extends readonly any[], TIndexInt extends number> = TStateTuple[TIndexInt] extends Record<string, any> ? TStateTuple[TIndexInt] : never;
/** Helper type to extract NonNullable state tuple item */
type NonNullableStateTupleItem<TStateTuple extends readonly any[], TIndexInt extends number> = NonNullable<StateTupleItem<TStateTuple, TIndexInt>>;
/** Helper type to find the corresponding variant rule */
type VariantRuleForKey<TStateTuple extends readonly any[], TRulesTuple extends readonly any[], TIndexInt extends number, TKey> = FindCorrespondingVariant<StateTupleItem<TStateTuple, TIndexInt>, TRulesTuple> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject;
type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}> = UnionToTuple<TState> extends infer TStateTuple extends readonly any[] ? UnionToTuple<TRules> extends infer TRulesTuple extends readonly any[] ? { [TIndex in keyof TupleToPlainObj<TStateTuple>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof TStateTuple[TIndexInt] as IsEmptyObject<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>, NonNullableStateTupleItem<TStateTuple, TIndexInt>, TKey, TShortcuts> } & { [TKey in keyof TStateTuple[TIndexInt] as IsEmptyObject<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>, NonNullableStateTupleItem<TStateTuple, TIndexInt>, TKey, TShortcuts> } : {} } : {} : {};
type FindCorrespondingVariant<TState extends Record<string, any>, TRules extends readonly any[]> = TRules extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState> ? [F] : FindCorrespondingVariant<TState, R> : [];
type PossibleLiteralTypes<T extends Record<string, any>, TKey extends keyof T> = unknown extends T[TKey] ? {
  [x: string]: { [K in TKey]-?: Omit<RegleRuleDecl<any, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
    literal?: RegleRuleDefinition<'literal', any, [literal: any], false, boolean, any, string | number, true>;
  } };
} : { [TVal in NonNullable<T[TKey]>]: { [K in TKey]-?: Omit<RegleRuleDecl<TVal, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
  literal?: RegleRuleDefinition<'literal', MaybeInput<TVal>, [literal: TVal], false, boolean, MaybeInput<TVal>, string | number, true>;
} } };
type RequiredForm<T extends Record<string, any>, TKey extends keyof T> = Omit<ReglePartialRuleTree<T>, TKey> & PossibleLiteralTypes<T, TKey>[keyof PossibleLiteralTypes<T, TKey>];
type VariantTuple<T extends Record<string, any>, TKey extends keyof T> = [RequiredForm<T, TKey>, ...RequiredForm<T, TKey>[]];
declare const RegleStaticSymbol: unique symbol;
type RegleStatic<T> = T extends (new (...args: infer Args) => infer U) ? RegleStaticImpl<new (...args: Args) => RegleStaticImpl<U>> : RegleStaticImpl<T>;
type RegleStaticImpl<T> = Raw<T & {
  [RegleStaticSymbol]: true;
}>;
type IsRegleStatic<T> = T extends RegleStaticImpl<T> ? true : false;
type UnwrapStatic<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : NonNullable<T> extends RegleStaticImpl<infer U> ? Raw<U> : UnwrapStaticSimple<T>;
type UnwrapStaticSimple<T> = IsAny<T> extends true ? any : NonNullable<T> extends Array<infer U> ? Array<UnwrapStatic<U>> : isRecordLiteral<NonNullable<T>> extends true ? { [K in keyof T]: UnwrapStatic<T[K]> } : T;
/**
 * Combine all members of a union type, merging types for each key, and keeping loose types
 */
type JoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : HasNamedKeys<TUnion> extends true ? isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull ? NormalizeUnion<TNonNull> extends infer TNormalized extends Record<string, any> ? HasCommonKey<UnionToTuple<TNonNull>, keyof TNormalized> extends true ? ResolveKeys<TUnion> extends infer TResolved extends Record<string, any> ? DumbJoinDiscriminatedUnions<TUnion> extends infer TDumbJoin ? Omit<TDumbJoin, keyof TResolved> extends infer TLoose ? Prettify<TResolved & (TLoose extends EmptyObject ? {} : TLoose)> : never : never : never : DumbJoinDiscriminatedUnions<TUnion> : never : never : TUnion : TUnion;
type ResolveKeys<TUnion extends unknown> = NonNullable<TUnion> extends infer TNonNull ? NormalizeUnion<TNonNull> extends infer TNormalized extends Record<string, any> ? Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TNonNull>, keyof TNormalized>[number]>> & Pick<TNormalized, keyof TNormalized> : never : never;
/**
 * Combine all members of a union type on one level and not nested.
 */
type LazyJoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull extends Record<string, any> ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TNonNull>, keyof TNonNull>[number]>> & Pick<TNonNull, keyof TNonNull>> : never : TUnion;
type DumbJoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull extends Record<string, any> ? Prettify<Partial<UnionToIntersection<TNonNull>> & Pick<TNonNull, keyof TNonNull>> : never : TUnion;
type RemoveCommonKey<T extends readonly any[], K extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K>>, ...RemoveCommonKey<R, K>] : [];
type HasCommonKey<T extends readonly any[], K extends PropertyKey> = T extends [infer F, ...infer R] ? K extends keyof F ? true : HasCommonKey<R, K> : false;
/**
 * Transforms a union and apply undefined values to non-present keys to support intersection
 */
type NormalizeUnion<TUnion> = RetrieveUnionUnknownValues<NonNullable<UnionToTuple<TUnion>>, RetrieveUnionUnknownKeysOf<NonNullable<UnionToTuple<TUnion>>>[number]>[number];
/**
 * Combine all union values to be able to get even the normally "never" values, act as an intersection type
 */
type RetrieveUnionUnknownValues<T extends readonly any[], TKeys extends string> = T extends [infer F extends Record<string, any>, ...infer R] ? [{ [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? never : K]?: GetMaybeObjectValue<F, K> } & { [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? K : never]: GetMaybeObjectValue<F, K> }, ...RetrieveUnionUnknownValues<R, TKeys>] : [];
/**
 * Get all possible keys from a union, even the ones present only on one union
 */
type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
/**
 * Get item value from object, otherwise fallback to undefined. Avoid TS to not be able to infer keys not present on all unions
 */
type GetMaybeObjectValue<O extends Record<string, any>, K extends string> = K extends keyof O ? O[K] : undefined;
type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K] };
/**
 * Merge every boolean property into a single boolean.
 */
type MergePropsIntoRequiredBooleans<TObject extends Record<string, any>> = { [K in keyof TObject]-?: TObject[K] extends NonNullable<TObject[K]> ? true : false }[keyof TObject];
/**
 * Ensure that if at least one prop is required, the "prop" object will be required too
 */
type HaveAnyRequiredProps<TObject extends Record<string, any>> = [TObject] extends [never] ? false : TObject extends Record<string, any> ? MergePropsIntoRequiredBooleans<TObject> extends false ? false : true : false;
type EnumType<T extends Record<string, unknown>> = T[keyof T];
type EnumLike = {
  [k: string]: string | number;
  [nu: number]: string;
};
type MaybeRefOrComputedRef<T extends any> = MaybeRef<T> | ComputedRef<T>;
type UnwrapMaybeRef<T extends MaybeRef<any> | DeepReactiveState<any>> = T extends Ref<any> ? UnwrapRef<T> : UnwrapNestedRefs<T>;
type TupleToPlainObj<T> = { [I in keyof T & `${number}`]: T[I] };
type HasNamedKeys<T> = IsAny<T> extends true ? false : IsUnknown<T> extends true ? false : IsUnion<T> extends true ? ProcessHasNamedKeys<LazyJoinDiscriminatedUnions<T>> : ProcessHasNamedKeys<T>;
type ProcessHasNamedKeys<T> = { [K in keyof NonNullable<T>]: K extends string ? (string extends K ? never : K) : never }[keyof NonNullable<T>] extends never ? false : true;
/**
 * Convert a nested object to a deeply nested partial object.
 */
type DeepPartial<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends Date | File | RegleStaticImpl<unknown> ? T : T extends Record<string, any> ? { [K in keyof T]?: DeepPartial<T[K]> | undefined } : T | undefined;
type Prettify<T> = T extends infer R ? { [K in keyof R]: R[K] } & {} : never;
type Maybe<T = any> = T | null | undefined;
type MaybeInput<T = any> = T | null | undefined;
type MaybeOutput<T = any> = T | undefined;
type MaybeReadonly<T> = T | Readonly<T>;
type NonUndefined<T> = Exclude<T, undefined>;
type isUndefinedOrNull<T> = Or<IsOptional<T>, IsNullable<T>>;
type MaybeOrPartial<T> = T extends Record<string, any> ? Partial<T> : MaybeOutput<T>;
type MaybeNullable<T> = Or<IsNullable<T>, IsOptional<T>>;
type PromiseReturn<T> = T extends Promise<infer U> ? U : T;
type MaybeGetter<T, V = any, TAdd extends Record<string, any> = {}, TSelf extends Record<string, any> = {}> = (T & TSelf) | ((value: Ref<V>, index: number) => T & TAdd & TSelf);
type MaybeComputedOrGetter<T> = MaybeRefOrComputedRef<T> | ((...args: any[]) => T);
type Unwrap<T extends MaybeRef<unknown>> = T extends Ref ? UnwrapRef<T> : UnwrapNestedRefs<T>;
type UnwrapSimple<T extends MaybeRef<Record<string, any>>> = T extends MaybeComputedOrGetter<infer U> ? U : T extends Ref<infer U> ? U : T extends ((...args: any[]) => infer U) ? U : T;
type ExtractFromGetter<T extends MaybeGetter<any, any, any>> = T extends ((value: Ref<any>, index: number) => infer U extends Record<string, any>) ? U : T;
type ExtendOnlyRealRecord<T extends unknown> = NonNullable<T> extends File | Date | RegleStatic<{}> | RegleStaticImpl<{}> ? false : NonNullable<T> extends Record<string, any> ? true : false;
type OmitByType<T extends Record<string, any>, U> = { [K in keyof T as T[K] extends U ? never : K]: T[K] };
type DeepMaybeRef<T extends Record<string, any>> = { [K in keyof T]: MaybeRefOrGetter<T[K]> };
type ExcludeByType<T, U> = { [K in keyof T as T[K] extends U ? never : K]: T[K] extends U ? never : T[K] };
type PrimitiveTypes = string | number | boolean | bigint | Date | File;
type WidenPrimitiveLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File | RegleStatic<unknown> | RegleStaticImpl<unknown> ? false : NonNullable<T> extends Record<string, any> ? true : false;
type NoInferLegacy<A extends any> = [A][A extends any ? 0 : never];
/**
 * Extract the element type from an array.
 *
 * @example
 * ```ts
 * type Element = ArrayElement<[1, 2, 3]>; // number
 * ```
 */
type ArrayElement<T> = T extends Array<infer U> ? U : never;
/**
 * Declares a tuple that must have at least one element
 */
type NonEmptyTuple<T> = [T, ...T[]] | T[];
interface CommonComparisonOptions {
  /**
   * Change the behaviour of the rule to check only if the value is equal in addition to be strictly superior or inferior
   * @default true
   */
  allowEqual?: boolean;
}
interface CommonAlphaOptions {
  /**
   * Allow symbols in alphabetical-like rules (like "_")
   * @default true
   */
  allowSymbols?: boolean;
}
interface UrlOptions {
  /**
   * Optional regex for validating the URL protocol
   */
  protocol?: RegExp;
}
type EnumOneOfLike<TValue extends unknown> = {
  readonly [k: string]: TValue;
};
type DefaultValidators = {
  alpha: RegleRuleWithParamsDefinition<unknown, string, [options?: CommonAlphaOptions | undefined]>;
  alphaNum: RegleRuleWithParamsDefinition<unknown, string | number, [options?: CommonAlphaOptions | undefined]>;
  atLeastOne: RegleRuleWithParamsDefinition<unknown, Record<string, unknown> | object, [keys?: readonly string[] | undefined], false, boolean, false, Record<string, unknown> | object>;
  between: RegleRuleWithParamsDefinition<unknown, number, [min: number, max: number, options?: CommonComparisonOptions]>;
  boolean: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
  checked: RegleRuleDefinition<unknown, boolean, [], false, boolean, boolean>;
  contains: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
  containsSpecialCharacter: RegleRuleWithParamsDefinition<unknown, string, [minCharactersCount?: number | undefined], false, {
    $valid: boolean;
    minCharactersCount: number;
  }>;
  containsUppercase: RegleRuleWithParamsDefinition<unknown, string, [minUppercaseCount?: number | undefined], false, {
    $valid: boolean;
    minUppercaseCount: number;
  }>;
  date: RegleRuleDefinition<unknown, unknown, [], false, boolean, MaybeInput<Date>, unknown>;
  dateAfter: RegleRuleWithParamsDefinition<unknown, string | Date, [after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
    $valid: false;
    error: 'date-not-after';
  } | {
    $valid: false;
    error: 'value-or-parameter-not-a-date';
  }>;
  dateBefore: RegleRuleWithParamsDefinition<unknown, string | Date, [before: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
    $valid: false;
    error: 'date-not-before';
  } | {
    $valid: false;
    error: 'value-or-parameter-not-a-date';
  }>;
  dateBetween: RegleRuleWithParamsDefinition<unknown, string | Date, [before: MaybeInput<string | Date>, after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, boolean>;
  decimal: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
  domain: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
  email: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
  endsWith: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
  exactLength: RegleRuleWithParamsDefinition<unknown, string | any[] | Record<PropertyKey, any>, [count: number], false, boolean>;
  exactValue: RegleRuleWithParamsDefinition<unknown, number, [count: number], false, boolean>;
  file: RegleRuleDefinition<unknown, unknown, [], false, boolean, MaybeInput<File>, unknown>;
  fileType: RegleRuleWithParamsDefinition<unknown, File, [accept: readonly string[]], false, boolean>;
  hexadecimal: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
  integer: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
  ipv4Address: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
  literal: RegleRuleDefinition<unknown, string | number, [literal: string | number], false, boolean, MaybeInput<string | number>, string | number, true>;
  macAddress: RegleRuleWithParamsDefinition<unknown, string, [separator?: string | undefined], false, boolean>;
  maxLength: RegleRuleWithParamsDefinition<unknown, string | any[] | Record<PropertyKey, any>, [max: number, options?: CommonComparisonOptions], false, boolean>;
  maxFileSize: RegleRuleWithParamsDefinition<unknown, File, [maxSize: number], false, true | {
    $valid: boolean;
    fileSize: number;
  }, MaybeInput<File>, File>;
  maxValue: RegleRuleWithParamsDefinition<unknown, number | string, [max: number | string, options?: CommonComparisonOptions], false, boolean>;
  minFileSize: RegleRuleWithParamsDefinition<unknown, File, [minSize: number], false, true | {
    $valid: boolean;
    fileSize: number;
  }, MaybeInput<File>, File>;
  minLength: RegleRuleWithParamsDefinition<unknown, string | any[] | Record<PropertyKey, any>, [min: number, options?: CommonComparisonOptions], false, boolean, string | any[] | Record<PropertyKey, any>>;
  minValue: RegleRuleWithParamsDefinition<unknown, number | string, [min: number | string, options?: CommonComparisonOptions], false, boolean>;
  nativeEnum: RegleRuleDefinition<unknown, string | number, [enumLike: EnumLike], false, boolean, string | number>;
  number: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
  numeric: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
  oneOf: RegleRuleDefinition<unknown, string | number, [options: readonly [string | number, ...(string | number)[]] | EnumOneOfLike<unknown>], false, boolean, MaybeInput<string | number>, string | number>;
  regex: RegleRuleWithParamsDefinition<unknown, string | number, [regexp: RegExp | readonly RegExp[]], false, boolean>;
  required: RegleRuleDefinition<unknown, unknown, [], false, boolean, unknown, unknown, true>;
  sameAs: RegleRuleWithParamsDefinition<unknown, unknown, [target: any, otherName?: string], false, boolean>;
  string: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
  type: RegleRuleDefinition<unknown, unknown, [], false, boolean, unknown, unknown>;
  startsWith: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
  url: RegleRuleWithParamsDefinition<unknown, string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
};
interface inferRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>> {
  <TState extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules extends ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<DefaultValidatorsTree> & TCustomRules>, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<DefaultValidatorsTree> & TCustomRules>>(state: Maybe<TState> | DeepReactiveState<TState>, rulesFactory: Unwrap<TState> extends MaybeInput<PrimitiveTypes> ? TDecl : Unwrap<TState> extends Record<string, any> ? TRules : {}): NonNullable<Unwrap<TState>> extends PrimitiveTypes ? TDecl : TRules;
}
/**
 * Type helper to provide autocomplete and type-checking for your form rules.
 * It returns the rules without any processing - useful with computed rules.
 *
 * @param state - The state reference
 * @param rules - Your rule tree
 * @returns The rules object (passthrough)
 *
 * @example
 * ```ts
 * import { inferRules, useRegle } from '@regle/core';
 * import { required, minLength } from '@regle/rules';
 *
 * const state = ref({ name: '' });
 *
 * // inferRules preserves TypeScript autocompletion
 * const rules = computed(() => {
 *   return inferRules(state, {
 *     name: { required, minLength: minLength(2) }
 *   })
 * });
 *
 * const { r$ } = useRegle(state, rules);
 * ```
 *
 * @see {@link https://reglejs.dev/core-concepts/#dynamic-rules-object Documentation}
 */
declare const inferRules: inferRulesFn<Partial<ExtendedRulesDeclarationsOverrides>>;
interface GlobalConfigOptions<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides> = EmptyObject, TShortcuts extends RegleShortcutDefinition<any> = never> {
  /**
   * Declare custom rules to be used globally or override the default rules messages.
   *
   * Ex:
   * ```ts
   * import { defineRegleConfig } from '@regle/core';
   * import { required, withMessage } from '@regle/rules';
   *
   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
   *   rules: () => ({
   *     required: withMessage(required, 'This field cannot be empty'),
   *   }),
   * });
   * ```
   * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
   */
  rules?: () => TCustomRules;
  /**
   * Define modifiers to be used globally.
   *
   * Ex:
   * ```ts
   * import { defineRegleConfig } from '@regle/core';
   *
   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
   *   modifiers: {
   *     lazy: true,
   *     rewardEarly: true
   *   }
   * });
   * ```
   * @see {@link https://reglejs.dev/advanced-usage/global-config#declare-modifiers Documentation}
   */
  modifiers?: RegleBehaviourOptions;
  /**
   * Define reusable validation shortcuts to be used globally.
   *
   * Ex:
   * ```ts
   * import { defineRegleConfig } from '@regle/core';
   *
   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
   *   shortcuts: {
   *     fields: {
   *       $isRequired: (field) => field.$rules.required?.$active ?? false,
   *     },
   *   },
   * });
   * ```
   * @see {@link https://reglejs.dev/advanced-usage/extend-properties#extend-properties Documentation}
   */
  shortcuts?: TShortcuts;
  /** Override default behaviors of Regle processors. */
  overrides?: GlobalConfigOverrides<unknown>;
}
/**
 * Define a global Regle configuration to customize the validation behavior across your application.
 *
 * Features:
 * - Customize built-in rules messages
 * - Add your custom rules with full type inference
 * - Define global modifiers (lazy, rewardEarly, etc.)
 * - Define shortcuts for common validation patterns
 *
 * @param options - Configuration options
 * @returns Object containing typed `useRegle`, `inferRules`, and `useRules` functions
 *
 * @example
 * ```ts
 * import { defineRegleConfig } from '@regle/core';
 * import { required, withMessage } from '@regle/rules';
 *
 * export const { useRegle, inferRules, useRules } = defineRegleConfig({
 *   rules: () => ({
 *     // Override default required message
 *     required: withMessage(required, 'This field cannot be empty'),
 *     // Add custom rule
 *     myCustomRule: createRule({
 *       validator: (value) => value === 'valid',
 *       message: 'Invalid value'
 *     })
 *   }),
 *   modifiers: {
 *     lazy: true,
 *     rewardEarly: true
 *   }
 * });
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
 */
declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TCustomRules>, TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>>({
  rules,
  modifiers,
  shortcuts,
  overrides
}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
  useRegle: useRegleFn<Omit<TCustomRules, keyof DefaultValidators>, TShortcuts>;
  inferRules: inferRulesFn<Omit<TCustomRules, keyof DefaultValidators>>;
  useRules: useRulesFn<TCustomRules, TShortcuts>;
};
/**
 * Extend an already created custom `useRegle` configuration with additional rules, modifiers, or shortcuts.
 *
 * @param regle - The existing useRegle function to extend
 * @param options - Additional configuration to merge
 * @param options.rules - Additional custom rules
 * @param options.modifiers - Additional modifiers to merge
 * @param options.shortcuts - Additional shortcuts to merge
 * @returns Object containing the extended `useRegle` and `inferRules` functions
 *
 * @example
 * ```ts
 * import { extendRegleConfig } from '@regle/core';
 * import { baseUseRegle } from './base-config';
 *
 * export const { useRegle, inferRules } = extendRegleConfig(baseUseRegle, {
 *   rules: () => ({
 *     additionalRule: myNewRule
 *   }),
 *   modifiers: {
 *     rewardEarly: true
 *   }
 * });
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
 */
declare function extendRegleConfig<TRootCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>, TRootShortcuts extends RegleShortcutDefinition<{}>, TShortcuts extends RegleShortcutDefinition<Merge<TRootCustomRules, TCustomRules>>, TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>>(regle: useRegleFn<TRootCustomRules, TRootShortcuts>, {
  rules,
  modifiers,
  shortcuts,
  overrides
}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
  useRegle: useRegleFn<Merge<TRootCustomRules, TCustomRules>, TRootShortcuts & TShortcuts>;
  inferRules: inferRulesFn<Merge<TRootCustomRules, TCustomRules>>;
};
/**
 * Define a global Regle options to customize the validation behavior across your application.
 * It's meant to be used with the Regle Vue plugin.
 *
 * @param options - Configuration options
 * @returns The configuration options
 *
 * @example
 * ```ts
 * import { defineRegleOptions } from '@regle/core';
 *
 * const regleOptions = defineRegleOptions({
 *   modifiers: {
 *     lazy: true,
 *     rewardEarly: true
 *   }
 * });
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
 */
declare function defineRegleOptions<T extends GlobalConfigOptions<Partial<ExtendedRulesDeclarationsOverrides>, RegleShortcutDefinition<any>>>(options: T): T;
type useRegleFnOptions<TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<TState>>, CustomRulesDeclarationTree>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState extends Record<string, any> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState>, TRules, TValidationGroups> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions & FieldOnlyRegleBehaviourOptions>> & TAdditionalOptions;
interface useRegleFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
  <TState extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules extends ReglePartialRuleTree<JoinDiscriminatedUnions<Unwrap<TState>>, Partial<ExtendedRulesDeclarations & Omit<TCustomRules, keyof DefaultValidatorsTree>>>, TDecl extends RegleRuleDecl<WidenPrimitiveLiterals<NonNullable<Unwrap<TState>>>, Partial<ExtendedRulesDeclarations & TCustomRules>>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(...params: [state: Maybe<TState> | DeepReactiveState<TState>, rulesFactory: Unwrap<TState> extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : Unwrap<TState> extends Record<string, any> ? MaybeComputedOrGetter<TRules> : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<Unwrap<TState>, TRules, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<Unwrap<NoInferLegacy<TState>>, TRules, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<Unwrap<NoInferLegacy<TState>>, TRules, TAdditionalOptions, TValidationGroups>])]): NonNullable<Unwrap<TState>> extends PrimitiveTypes ? RegleSingleField<WidenPrimitiveLiterals<Unwrap<TState>>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<Unwrap<TState> extends Record<string, any> ? Unwrap<TState> : {}, UnwrapSimple<TRules> extends Record<string, any> ? UnwrapSimple<TRules> : {}, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
  __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
}
/**
 * `useRegle` serves as the foundation for validation logic.
 *
 * It transforms your data and validation rules into a powerful, reactive validation system.
 *
 * @param state - Your form data (plain object, ref, reactive object, or structure with nested refs)
 * @param rules - Validation rules that should align with the structure of your state
 * @param modifiers - Optional configuration to customize regle behavior
 * @returns An object containing `r$` - the reactive validation state
 *
 * @example
 * ```ts
 * import { useRegle } from '@regle/core';
 * import { required, email, minLength } from '@regle/rules';
 *
 * const { r$ } = useRegle(
 *   { name: '', email: '' },
 *   {
 *     name: { required, minLength: minLength(2) },
 *     email: { required, email }
 *   }
 * );
 *
 * // Access validation state
 * r$.$valid        // Whether all validations pass
 * r$.$value        // The current form values
 * r$.name.$errors  // Errors for the name field
 *
 * // Trigger validation
 * const result = await r$.$validate();
 * ```
 *
 * @see {@link https://reglejs.dev/core-concepts/ Documentation}
 */
declare const useRegle: useRegleFn<Partial<ExtendedRulesDeclarationsOverrides>, RegleShortcutDefinition<any>, {}, {}>;
/**
 * @internal
 * This is the internal function that creates the root storage for the Regle instance.
 * This allows shared logic between all `useRegle` like composables
 */
declare function useRootStorage({
  initialState,
  originalState,
  options,
  scopeRules,
  state,
  customRules,
  shortcuts,
  schemaErrors,
  schemaMode,
  onValidate,
  overrides
}: {
  scopeRules: Ref<$InternalReglePartialRuleTree>;
  state: Ref<Record<string, any> | PrimitiveTypes>;
  options: ResolvedRegleBehaviourOptions;
  initialState: Ref<Record<string, any> | PrimitiveTypes>;
  originalState: Record<string, any> | PrimitiveTypes;
  customRules?: () => CustomRulesDeclarationTree;
  shortcuts: RegleShortcutDefinition | undefined;
  schemaErrors?: Ref<any | undefined>;
  schemaMode?: boolean;
  onValidate?: () => Promise<$InternalRegleResult>;
  overrides: GlobalConfigOverrides | undefined;
}): {
  regle: Ref<$InternalRegleStatusType | undefined, $InternalRegleStatusType | undefined>;
  bindToCurrentScope: () => void;
};
/**
 * Converts a nested `$errors` object to a flat array of error strings.
 * Useful for displaying a complete list of form errors or counting total errors.
 *
 * With the `includePath` option, returns errors in Standard Schema Issue format
 * including the path to each error field.
 *
 * @param errors - The `$errors` object from a Regle instance (e.g., `r$.$errors`)
 * @param options - Configuration options
 * @param options.includePath - If true, returns Standard Schema Issues with paths
 * @returns Array of error strings, or Standard Schema Issues if `includePath` is true
 *
 * @example
 * ```ts
 * import { flatErrors, useRegle } from '@regle/core';
 * import { required, email, minLength } from '@regle/rules';
 *
 * const { r$ } = useRegle(
 *   { name: '', email: 'invalid' },
 *   { name: { required, minLength: minLength(3) }, email: { email } }
 * );
 *
 * await r$.$validate();
 *
 * // Get flat array of error messages
 * const errors = flatErrors(r$.$errors);
 * // ['This field is required', 'Value must be a valid email address']
 *
 * // Get errors with paths (Standard Schema format)
 * const issues = flatErrors(r$.$errors, { includePath: true });
 * // [{ message: 'This field is required', path: ['name'] }, ...]
 * ```
 *
 * @see {@link https://reglejs.dev/core-concepts/displaying-errors#display-flat-errors Documentation}
 */
declare function flatErrors(errors: $InternalRegleErrors, options: {
  includePath: true;
}): StandardSchemaV1.Issue[];
declare function flatErrors(errors: $InternalRegleErrors, options?: {
  includePath?: false;
}): string[];
/**
 * Retrieves error messages for a specific field using a dot-notation path.
 * Provides type-safe access to nested error arrays in a Regle instance.
 *
 * @typeParam TRegle - The Regle instance type (root or status)
 * @typeParam TPath - The dot-notation path type, validated at compile-time
 *
 * @param r$ - The Regle instance (e.g., from `useRegle()`)
 * @param path - Dot-notation path to the field (e.g., `'user.email'` or `'items.0.name'`)
 * @returns Array of error strings for the field, or `undefined` if path doesn't exist
 *
 * @example
 * ```ts
 * import { getErrors, useRegle } from '@regle/core';
 * import { required, email } from '@regle/rules';
 *
 * const { r$ } = useRegle(
 *   { user: { email: '' } },
 *   { user: { email: { required, email } } }
 * );
 *
 * await r$.$validate();
 *
 * // Type-safe access to nested errors
 * const emailErrors = getErrors(r$, 'user.email');
 * // ['This field is required']
 *
 * // Works with collections too
 * const itemErrors = getErrors(r$, 'items.0.name');
 * ```
 *
 * @see {@link https://reglejs.dev/core-concepts/displaying-errors#get-errors-by-path Documentation}
 */
declare function getErrors<TRegle extends SuperCompatibleRegleRoot | SuperCompatibleRegleStatus, TPath extends Paths<TRegle['$errors']> | (string & {})>(r$: MaybeRefOrGetter<TRegle>, path: TPath): IsStringLiteral<TPath> extends true ? Get<TRegle['$errors'], TPath & string> : string[] | undefined;
/**
 * Retrieves detailed validation issues for a specific field using a dot-notation path.
 * Issues contain more information than errors, including the rule name, property, and metadata.
 *
 * @typeParam TRegle - The Regle instance type (root or status)
 * @typeParam TPath - The dot-notation path type, validated at compile-time
 *
 * @param r$ - The Regle instance (e.g., from `useRegle()`)
 * @param path - Dot-notation path to the field (e.g., `'user.email'` or `'items.0.name'`)
 * @returns Array of `RegleFieldIssue` objects for the field, or `undefined` if path doesn't exist
 *
 * @example
 * ```ts
 * import { getIssues, useRegle } from '@regle/core';
 * import { required, email } from '@regle/rules';
 *
 * const { r$ } = useRegle(
 *   { user: { email: '' } },
 *   { user: { email: { required, email } } }
 * );
 *
 * await r$.$validate();
 *
 * // Type-safe access to nested issues with full metadata
 * const emailIssues = getIssues(r$, 'user.email');
 * // [{
 * //   $message: 'This field is required',
 * //   $property: 'email',
 * //   $rule: 'required'
 * // }]
 *
 * // Works with collections too
 * const itemIssues = getIssues(r$, 'items.0.name');
 * ```
 *
 * @see {@link https://reglejs.dev/core-concepts/displaying-errors#get-issues-by-path Documentation}
 */
declare function getIssues<TRegle extends SuperCompatibleRegleRoot | SuperCompatibleRegleStatus, TPath extends Paths<TRegle['$issues']>>(r$: MaybeRefOrGetter<TRegle>, path: TPath | (string & {})): IsStringLiteral<TPath> extends true ? Get<TRegle['$issues'], TPath & string> : RegleFieldIssue[] | undefined;
type useRulesFnOptions<TRules extends RegleUnknownRulesTree | RegleRuleDecl, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState = InferInput<TRules>> = Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState extends Record<string, any> ? Unwrap<TState> : {}>, TState extends Record<string, any> ? (TRules extends Record<string, any> ? TRules : {}) : {}, TValidationGroups>;
interface useRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>, TShortcuts extends RegleShortcutDefinition<any> = never> {
  <TRules extends RegleUnknownRulesTree | RegleRuleDecl, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<ExtendedRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState extends Record<string, any> = InferInput<TRules>>(rulesFactory: TState extends Record<string, any> ? MaybeRef<TRules> | ((...args: any[]) => TRules) : {}, options?: useRulesFnOptions<TRules, TValidationGroups, TState>): NonNullable<TState> extends PrimitiveTypes ? Raw<RegleFieldStatus<NonNullable<TState>, TDecl, TShortcuts>> & StandardSchemaV1<TState> : Raw<RegleRoot<TState extends Record<string, any> ? Unwrap<TState> : {}, TRules extends Record<string, any> ? TRules : {}, TValidationGroups, TShortcuts>> & StandardSchemaV1<TState>;
  __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
}
/**
 * `useRules` is a variant of `useRegle` that doesn't require you to provide initial state.
 * It creates an empty state based on your rules structure and implements the Standard Schema spec.
 *
 * This is useful when you want to define validation rules first and infer the state type from them.
 *
 * @param rules - Your validation rules object
 * @param modifiers - Optional configuration to customize regle behavior
 * @returns The reactive validation state (implements StandardSchemaV1)
 *
 * @example
 * ```ts
 * import { useRules, type InferInput } from '@regle/core';
 * import { required, string, email } from '@regle/rules';
 *
 * const r$ = useRules({
 *   name: { required, string },
 *   email: { required, email }
 * });
 *
 * // State is automatically created and typed
 * r$.$value.name // string | null
 * r$.$value.email // string | null
 *
 * // Can be used with Standard Schema compatible libraries
 * const result = await r$['~standard'].validate({ name: '', email: '' });
 * ```
 *
 * @see {@link https://reglejs.dev/common-usage/standard-schema#userules Documentation}
 */
declare const useRules: useRulesFn<Partial<ExtendedRulesDeclarationsOverrides>, RegleShortcutDefinition<any>>;
/**
 * Marks a value as static and treats the constructor as a regular raw Field.
 * @param value - The value to mark as static.
 * @returns The marked value.
 * @example
 * ```ts
 * const StaticDecimal = markStatic(Decimal);
 * const StaticBigWrapper = markStatic(BigWrapper);
 * ```
 */
declare function markStatic<T extends object>(value: T): T extends RegleStaticImpl<unknown> ? T : RegleStatic<T>;
/**
 * Infer type of the `r$` of any function returning a regle instance
 */
type InferRegleRoot<T extends (...args: any[]) => SuperCompatibleRegle> = T extends ((...args: any[]) => infer U) ? U extends SuperCompatibleRegle ? U['r$'] : never : never;
/**
 * Infer custom rules declared in a global configuration
 */
type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<DefaultValidators>> & UnwrapRuleTree<Partial<U>> : {};
/**
 * Infer custom shortcuts declared in a global configuration
 */
type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
/**
 * Extract a set rules and setting them as required
 */
type RegleEnforceRequiredRules<TRules extends keyof DefaultValidators> = Omit<Partial<DefaultValidatorsTree>, TRules> & { [K in TRules]-?: UnwrapRuleWithParams<DefaultValidators[K]> };
/**
 * Extract a set of custom rules from a global configuration and setting them as required

 */
type RegleEnforceCustomRequiredRules<T extends useRegleFn<any, any>, TRules extends keyof InferRegleRules<T>> = Omit<Partial<DefaultValidatorsTree>, TRules> & { [K in TRules]-?: T extends useRegleFn<any, any> ? K extends keyof InferRegleRules<T> ? NonNullable<UnwrapRuleWithParams<InferRegleRules<T>[K]>> : never : K extends keyof T ? NonNullable<T[K]> : never };
/**
 * Extract custom rules and custom shortcuts and apply them to a RegleFieldStatus type
 */
type RegleCustomFieldStatus<T extends useRegleFn<any, any>, TState extends unknown = any, TRules extends keyof InferRegleRules<T> = never> = RegleFieldStatus<TState, [TRules] extends [never] ? Partial<InferRegleRules<T>> : RegleEnforceCustomRequiredRules<T, TRules>, InferRegleShortcuts<T>>;
/**
 * Infer safe output type from a rules object and it's original state type
 *
 * ```ts
 * type FormRequest = InferOutput<typeof rules, typeof formState>;
 * ```
 */
type InferOutput<TRules extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> | ((state: any) => ReglePartialRuleTree<Record<string, any>, any>) | MaybeRef<StandardSchemaV1<any>>, TState extends MaybeRef<unknown> = InferInput<TRules>> = IsAny<TRules> extends true ? any : IsUnknown<TRules> extends true ? any : isRecordLiteral<TState> extends true ? TRules extends MaybeRef<StandardSchemaV1<infer State>> ? State : DeepSafeFormState<JoinDiscriminatedUnions<Unwrap<NonNullable<TState>>>, TRules extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> ? UnwrapRef<TRules> : {}> : TState extends any[] ? TState[] : TState;
/**
 * Infer input type from a rules object
 *
 * ```ts
 * type FormRequest = InferInput<typeof rules>;
 * ```
 */
type InferInput<TRules extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> | ((state: any) => ReglePartialRuleTree<Record<string, any>, any>) | MaybeRef<StandardSchemaV1<any>>, TMarkMaybe extends boolean = true> = IsAny<TRules> extends true ? any : IsUnknown<TRules> extends true ? any : TRules extends MaybeRef<StandardSchemaV1<infer State>> ? State : UnwrapSimple<TRules> extends infer TRulesUnwrapped extends Record<string, any> ? IsUnion<TRulesUnwrapped> extends true ? InferTupleUnionInput<UnionToTuple<TRulesUnwrapped>>[number] : TMarkMaybe extends true ? Prettify<{ [K in keyof TRulesUnwrapped as [TRulesUnwrapped[K]] extends [MaybeRef<RegleRuleDecl<any, any>>] ? K : never]?: ProcessInputChildren<TRulesUnwrapped[K], TMarkMaybe> } & { [K in keyof TRulesUnwrapped as [TRulesUnwrapped[K]] extends [MaybeRef<RegleRuleDecl<any, any>>] ? never : K]: ProcessInputChildren<TRulesUnwrapped[K], TMarkMaybe> }> : Prettify<{ [K in keyof TRulesUnwrapped]: ProcessInputChildren<TRulesUnwrapped[K], TMarkMaybe> }> : never;
type ProcessInputChildren<TRule extends unknown, TMarkMaybe extends boolean> = IsAny<TRule> extends true ? any : IsUnknown<TRule> extends true ? any : TRule extends {
  $each: RegleCollectionEachRules<any, any>;
} ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any, any> ? InferInput<ExtractFromGetter<TRule['$each']>, TMarkMaybe>[] : any[] : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? ExtractTypeFromRules<UnwrapRef<TRule>> extends infer TRuleInput ? [TRuleInput] extends [never] ? unknown : TRuleInput : unknown : TRule extends ReglePartialRuleTree<any, any> ? InferInput<TRule, TMarkMaybe> : string;
type ExtractTypeFromRules<TRules extends RegleRuleDecl<any, any>> = FilterRulesWithInput<TRules> extends infer TFilteredWithInput extends Record<string, any> ? TFilteredWithInput extends {
  type: infer Input;
} ? Input : FilterRulesWithSingleType<TRules> extends infer TFilteredWithSingleType extends Record<string, any> ? [TFilteredWithSingleType[keyof TFilteredWithSingleType]] extends [never] ? TFilteredWithInput[keyof TFilteredWithInput] : TFilteredWithSingleType[keyof TFilteredWithSingleType] : never : never;
type RuleInput<TRule> = TRule extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? Input : unknown;
type KnownRuleInput<TRule> = unknown extends RuleInput<TRule> ? never : RuleInput<TRule>;
type SingleKnownRuleInput<TRule> = IsUnion<NonNullable<KnownRuleInput<TRule>>> extends true ? never : KnownRuleInput<TRule>;
type FilterRulesWithInput<TRules extends RegleRuleDecl<any, any>> = { [K in keyof TRules as KnownRuleInput<TRules[K]> extends never ? never : K]: KnownRuleInput<TRules[K]> };
type FilterRulesWithSingleType<TRules extends RegleRuleDecl<any, any>> = { [K in keyof TRules as SingleKnownRuleInput<TRules[K]> extends never ? never : K]: SingleKnownRuleInput<TRules[K]> };
type InferTupleUnionInput<T extends any[]> = T extends [infer F extends ReglePartialRuleTree, ...infer R] ? [InferInput<F, true>, ...InferTupleUnionInput<R>] : [];
/**
 * Infer safe output from any `r$` instance
 *
 * ```ts
 * type FormRequest = InferSafeOutput<typeof r$>;
 * ```
 *
 * @deprecated Use {@link InferValidOutput} instead
 */
type InferSafeOutput<TRegle extends MaybeRef<SuperCompatibleRegleRoot | SuperCompatibleRegleFieldStatus>> = IsAny<TRegle> extends true ? any : IsUnknown<TRegle> extends true ? any : UnwrapRef<TRegle> extends Raw<RegleRoot<infer TState extends Record<string, any>, infer TRules, any, any>> ? TRules extends ReglePartialRuleTree<Record<string, any>, any> ? DeepSafeFormState<JoinDiscriminatedUnions<TState>, TRules> : never : UnwrapRef<TRegle> extends RegleFieldStatus<infer TState, infer TRules> ? SafeFieldProperty<TState, TRules> : UnwrapRef<TRegle> extends RegleLike<infer TState extends Record<string, any>> ? TState : never;
/**
 * Infer safe output from any `r$` instance
 *
 * ```ts
 * type FormRequest = InferValidOutput<typeof r$>;
 * ```
 */
type InferValidOutput<TRegle extends MaybeRef<SuperCompatibleRegleRoot | SuperCompatibleRegleFieldStatus>> = InferSafeOutput<TRegle>;
/**
 * Infer complete validation result from any `r$` instance
 */
type InferRegleValidationResult<TRegle extends MaybeRef<SuperCompatibleRegleRoot | SuperCompatibleRegleFieldStatus>> = InferRegleSettings<TRegle> extends {
  state: infer TState;
  rules: never;
} ? ({
  valid: true;
  data: TState;
} | {
  valid: false;
  data: DeepPartial<TState>;
}) & {
  errors: DataTypeRegleErrors<TState>;
  issues: DataTypeRegleIssues<TState>;
} : InferRegleSettings<TRegle> extends {
  state: infer TState;
  rules: infer TRules extends Record<string, any>;
} ? RegleResult<TState, TRules> : never;
/**
 * Infer State and Rules from any `r$` instance
 */
type InferRegleSettings<TRegle extends MaybeRef<SuperCompatibleRegleRoot | SuperCompatibleRegleFieldStatus>> = UnwrapRef<TRegle> extends Raw<RegleRoot<infer TState extends Record<string, any>, infer TRules extends Record<string, any>, any, any>> ? {
  state: TState;
  rules: TRules;
} : UnwrapRef<TRegle> extends RegleFieldStatus<infer TState, infer TRules extends Record<string, any>> ? {
  state: TState;
  rules: TRules;
} : UnwrapRef<TRegle> extends RegleLike<infer TState extends Record<string, any>> ? {
  state: TState;
  rules: never;
} : never;
type CreateFn<T extends any[]> = (...args: T) => any;
/**
 * Transform normal parameters tuple declaration to a rich tuple declaration
 *
 * [foo: string, bar?: number] => [foo: MaybeRef<string> | (() => string), bar?: MaybeRef<number | undefined> | (() => number) | undefined]
 */
type RegleUniversalParams<T extends any[] = [], F = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: MaybeRefOrGetter<Maybe<Args[K]>> }) => any : never>;
type UnwrapRegleUniversalParams<T extends MaybeRefOrGetter[] = [], F = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: Args[K] extends MaybeRefOrGetter<Maybe<infer U>> ? U : Args[K] }) => any : never>;
/**
 * Transform a tuple of parameters to a tuple of parameters and loose parameters
 *
 * [foo: string, bar?: number] => [foo: string, bar?: number, ...unknown[]]
 *
 * @param TParams - The tuple of parameters
 * @param TLoose - The tuple of loose parameters
 * @returns The tuple of parameters and loose parameters
 */
type ParamsToLooseParams<TParams extends any[], TLoose extends unknown[] = unknown[]> = TParams extends [] ? [...TLoose] : TParams extends [infer TFirst, ...infer TRest] ? [TFirst, ...TRest, ...TLoose] : [...TParams, ...TLoose];
type HasOptionalParams<T extends any[]> = T extends [param?: any, ...any[]] ? T[0] extends NonNullable<T[0]> ? false : true : false;
/**
 * Internal definition of the rule, this can be used to reset or patch the rule
 */
type RegleInternalRuleDefs<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> = Raw<{
  _validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
  _message: string | string[] | ((metadata: PossibleRegleRuleMetadataConsumer<TValue>) => string | string[]);
  _active?: boolean | ((metadata: PossibleRegleRuleMetadataConsumer<TValue>) => boolean);
  _tooltip?: string | string[] | ((metadata: PossibleRegleRuleMetadataConsumer<TValue>) => string | string[]);
  _type?: string;
  _message_patched: boolean;
  _tooltip_patched: boolean;
  _params?: RegleUniversalParams<TParams>;
  _async: TAsync;
  readonly _brand: symbol;
}>;
declare const InternalRuleType: {
  readonly Inline: "__inline";
  readonly Async: "__async";
};
type InternalRuleType = EnumType<typeof InternalRuleType>;
/**
 * Returned typed of rules created with `createRule`
 * */
interface RegleRuleDefinition<TType extends string | unknown = unknown, TValue extends unknown = unknown, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, _TInput = unknown, TFilteredValue extends any = (TValue extends Date & File & (infer M) ? M : TValue), TNonEmpty extends boolean = boolean> extends RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetaData>, RegleRuleDefinitionLight<TParams, TAsync, TMetaData> {
  validator: RegleRuleDefinitionProcessor<TFilteredValue, [...TParams, ...unknown[]], TAsync extends false ? TMetaData : Promise<TMetaData>>;
  message: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => string | string[];
  active?: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => boolean;
  tooltip?: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => string | string[];
  type?: TType;
  _value?: IsLiteral<TValue> extends true ? TValue : any;
  exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetaData : Promise<TMetaData>;
  required?: TNonEmpty;
}
type RegleRuleDefinitionLight<TParams extends [...unknown[]] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition> = {
  value: unknown;
  params: [...TParams];
  async: TAsync;
  metadata: TMetaData;
};
/**
 * Rules with params created with `createRules` are callable while being customizable
 */
type RegleRuleWithParamsDefinition<TType extends string | unknown = unknown, TValue extends unknown = unknown, TParams extends any[] = never, TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean, TInput = unknown, TFilteredValue extends any = (TValue extends Date & File & (infer M) ? M : TValue), TNonEmpty extends boolean = false> = RegleRuleCore<TType, TFilteredValue, TParams, TAsync, TMetadata, TNonEmpty> & RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetadata> & RegleRuleDefinitionLight<TParams, TAsync, TMetadata> & {
  (...params: RegleUniversalParams<TParams>): RegleRuleDefinition<TType, TFilteredValue, TParams, TAsync, TMetadata, TInput, TFilteredValue, TNonEmpty>;
} & (HasOptionalParams<TParams> extends true ? {
  exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetadata : Promise<TMetadata>;
} : IsAny<TParams[number]> extends true ? {
  exec?: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetadata : Promise<TMetadata>;
} : {});
type RegleRuleWithParamsDefinitionInput<TType extends string | unknown = unknown, TValue extends any = any, TParams extends any[] = never, TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean, TFilteredValue extends any = (TValue extends Date & File & (infer M) ? M : TValue)> = RegleRuleCoreInput<TType, TFilteredValue, TParams, TAsync, TMetadata> & RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetadata> & {
  exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetadata : Promise<TMetadata>;
};
type RegleRuleMetadataExtended = {
  $valid: boolean;
  [x: string]: any;
};
type UnwrapRuleTree<T extends {
  [x: string]: RegleRuleRawInput<any, any[], any, any> | undefined;
}> = { [K in keyof T]: UnwrapRuleWithParams<T[K]> };
type UnwrapRuleWithParams<T extends RegleRuleRawInput<any, any[], any, any> | undefined> = T extends RegleRuleWithParamsDefinition<infer TType, infer TValue, infer TParams, infer TAsync, infer TMetadata> ? HasOptionalParams<TParams> extends true ? RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetadata> | RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetadata> : RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetadata> : T;
/**
 * Define a rule Metadata definition
 */
type RegleRuleMetadataDefinition = RegleRuleMetadataExtended | boolean;
type DefaultMetadataPropertiesCommon = Pick<ExcludeByType<RegleCommonStatus, Function>, '$invalid' | '$dirty' | '$pending' | '$correct' | '$error'>;
type DefaultMetadataProperties = DefaultMetadataPropertiesCommon & {
  $rule: Pick<$InternalRegleRuleStatus, '$valid' | '$pending'>;
};
/**
 * Will be used to consume metadata on related helpers and rule status
 */
type RegleRuleMetadataConsumer<TValue extends any, TParams extends [...any[]] = never, TMetadata extends RegleRuleMetadataDefinition = boolean> = {
  $value: Maybe<TValue>;
} & DefaultMetadataProperties & (TParams extends never ? {} : {
  $params: [...TParams];
}) & (Exclude<TMetadata, boolean> extends RegleRuleMetadataExtended ? TMetadata extends boolean ? Partial<Omit<Exclude<TMetadata, boolean>, '$valid'>> : Omit<Exclude<TMetadata, boolean>, '$valid'> : {});
/**
 * Will be used to consume metadata on related helpers and rule status
 */
type PossibleRegleRuleMetadataConsumer<TValue> = {
  $value: Maybe<TValue>;
} & DefaultMetadataProperties & {
  $params?: [...any[]];
};
/**
 * Generic types for a created RegleRule
 */
type RegleRuleRaw<TType extends string | unknown = unknown, TValue extends any = any, TParams extends [...any[]] = [...any[]], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = boolean> = RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetaData> | RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetaData>;
type RegleRuleRawInput<TValue extends any = any, TParams extends [...any[]] = [...any[]], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = boolean> = Omit<RegleRuleDefinition<unknown, TValue, TParams, TAsync, TMetaData> | RegleRuleWithParamsDefinition<unknown, TValue, TParams, TAsync, TMetaData>, 'message' | 'tooltip' | 'active'> & {
  message: any;
  active?: any;
  tooltip?: any;
};
/**
 * Process the type of created rule with `createRule`.
 * For a rule with params it will return a function
 * Otherwise it will return the rule definition
 */
type InferRegleRule<TType extends string | unknown, TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean, TNonEmpty extends boolean = false> = [TParams] extends [[]] ? RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetaData, TValue, TValue, TNonEmpty> : RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetaData, TValue, TValue, TNonEmpty>;
type RegleRuleDefinitionProcessor<TValue extends any = any, TParams extends any[] = [], TReturn = any> = (value: Maybe<TValue>, ...params: TParams) => TReturn;
type RegleRuleDefinitionWithMetadataProcessor<TValue extends any, TMetadata extends RegleRuleMetadataConsumer<TValue, any[]>, TReturn = any> = ((metadata: TMetadata) => TReturn) | TReturn;
type RegleCollectionRuleDefinition<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue>, TCustomRules, CollectionRegleBehaviourOptions> & {
  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
}) | ({
  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
} & CollectionRegleBehaviourOptions);
type RegleInitPropertyGetter<TValue, TReturn, TParams extends [...any[]], TMetadata extends RegleRuleMetadataDefinition> = TReturn | ((metadata: RegleRuleMetadataConsumer<TValue, TParams, TMetadata>) => TReturn);
type RegleInitPropertyGetterInput<TReturn> = TReturn | ((metadata: any) => TReturn);
/**
 * @argument
 * createRule arguments options
 */
interface RegleRuleInit<TType extends string | unknown = unknown, TValue extends unknown = unknown, TParams extends [...any[]] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean, TMetadata extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TAsync extends boolean = (TReturn extends Promise<any> ? true : false), TNonEmpty extends boolean = false> {
  validator: (value: Maybe<TValue>, ...args: TParams) => TReturn;
  message: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
  active?: RegleInitPropertyGetter<TValue, boolean, TParams, TMetadata>;
  tooltip?: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
  type?: TType;
  async?: TAsync;
  required?: TNonEmpty;
}
/**
 * @argument
 * Rule core
 */
interface RegleRuleCore<TType extends string | unknown, TValue extends any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean, TNonEmpty extends boolean = false> {
  validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
  message: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
  active?: RegleInitPropertyGetter<TValue, boolean, TParams, TMetadata>;
  tooltip?: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
  type?: TType;
  async?: boolean;
  required?: TNonEmpty;
}
interface RegleRuleCoreInput<TType extends string | unknown, TValue extends any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean, TNonEmpty extends boolean = false> {
  validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
  message: RegleInitPropertyGetterInput<string | string[]>;
  active?: RegleInitPropertyGetterInput<boolean>;
  tooltip?: RegleInitPropertyGetterInput<string | string[]>;
  type?: TType;
  async?: boolean;
  required?: TNonEmpty;
}
type RegleRuleTypeReturn<TValue, TParams extends [...any[]]> = {
  value: TValue;
  params: [...TParams];
};
type CustomRulesDeclarationTree = {
  [x: string]: RegleRuleRawInput<any, any[], boolean, any> | undefined;
};
type DefaultValidatorsTree = { [K in keyof DefaultValidators]: DefaultValidators[K] extends ((...args: any[]) => infer U) ? U : DefaultValidators[K] };
type DefaultValidatorsTreeOverrides = { [K in keyof DefaultValidators]: DefaultValidators[K] | ((...args: any[]) => DefaultValidators[K]) };
/**
 * Extend this interface to declare your custom rules
 */
interface CustomRules {}
type ExtendedRulesDeclarations = CustomRulesDeclarationTree & DefaultValidatorsTree & CustomRules;
type ExtendedRulesDeclarationsOverrides = CustomRulesDeclarationTree & DefaultValidatorsTreeOverrides & CustomRules;
/** @deprecated Use {@link ExtendedRulesDeclarations} instead */
type AllRulesDeclarations = ExtendedRulesDeclarations;
/**
 * Extend this interface to declare your custom field properties
 */
interface CustomFieldProperties {}
/**
 * Extend this interface to declare your custom nested properties
 */
interface CustomNestedProperties {}
/**
 * Extend this interface to declare your custom collection properties
 */
interface CustomCollectionProperties {}
/**
 * @public
 */
type RegleRoot<TState extends object | Record<string, unknown> = {}, TRules extends ReglePartialRuleTree<TState> = Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never, TShortcuts extends RegleShortcutDefinition = {}> = MaybeVariantStatus<TState, TRules, TShortcuts> & ([TValidationGroups] extends [never] ? {} : {
  /**
   * Collection of validation groups used declared with the `validationGroups` modifier
   */
  $groups: { readonly [TKey in keyof TValidationGroups]: RegleValidationGroupOutput };
});
type ComputeNestedFieldStatus<TState extends Record<string, any>, TRules extends Record<string, any>, TKey extends keyof TState, TShortcuts extends RegleShortcutDefinition> = TKey extends string ? IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : never;
type ProcessNestedFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}, TIsFields extends boolean = false> = Or<HasNamedKeys<TState>, TIsFields> extends true ? { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? TKey : never : never : TKey]: ComputeNestedFieldStatus<NonNullable<TState>, TRules, TKey, TShortcuts> } & (IsEmptyObject<TRules> extends true ? { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? never : TKey : TKey : never]: ComputeNestedFieldStatus<NonNullable<TState>, TRules, TKey, TShortcuts> | (isUndefinedOrNull<TState[TKey]> extends true ? undefined : never) } : { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? never : TKey : TKey : never]-?: ComputeNestedFieldStatus<NonNullable<TState>, TRules, TKey, TShortcuts> }) : {};
/**
 * @public
 */
type RegleStatus<TState extends object | Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>, Partial<ExtendedRulesDeclarations>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}, _TFields = ProcessNestedFields<TState, TRules, TShortcuts, true>> = RegleCommonStatus<TState, TRules> & {
  /** Represents all the children of your object. You can access any nested child at any depth to get the relevant data you need for your form. */readonly $fields: _TFields;
  /**
   * Collection of all the issues, collected for all children properties and nested forms.
   *
   * Only contains issues from properties where $dirty equals true.
   */
  readonly $issues: RegleIssuesTree<TState, false, TRules>;
  /**
   * Collection of all the error messages, collected for all children properties and nested forms.
   *
   * Only contains errors from properties where $dirty equals true.
   * */
  readonly $errors: RegleErrorTree<TState, false>; /** Collection of all the error messages, collected for all children properties. */
  readonly $silentErrors: RegleErrorTree<TState>; /** Sets the external errors for the field. */
  $setExternalErrors(errors: RegleExternalErrorTree<TState>): void; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
  $validate: (forceValues?: JoinDiscriminatedUnions<TState> extends EmptyObject ? any : HasNamedKeys<JoinDiscriminatedUnions<TState>> extends true ? IsUnknown<JoinDiscriminatedUnions<TState>> extends true ? any : JoinDiscriminatedUnions<TState> : any) => Promise<RegleResult<JoinDiscriminatedUnions<TState>, TRules>>;
} & (HasNamedKeys<TState> extends true ? _TFields : {}) & CustomNestedProperties & ([TShortcuts['nested']] extends [never] ? {} : { [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]> }) & (TRules['$self'] extends RegleRuleDecl ? {
  /** Represents the status of the parent object. Status only concern the object itself and not its children */readonly $self: RegleFieldStatus<NonNullable<TRules['$self']>, NonNullable<TRules['$self']>, TShortcuts>;
} : {});
/**
 * @internal
 * @reference {@link RegleStatus}
 */
interface $InternalRegleStatus extends $InternalRegleCommonStatus {
  readonly $externalErrors?: $InternalRegleErrorTree;
  $fields: {
    [x: string]: $InternalRegleStatusType;
  };
  readonly $issues: Record<string, $InternalRegleIssues>;
  readonly $errors: Record<string, $InternalRegleErrors>;
  readonly $silentErrors: Record<string, $InternalRegleErrors>;
  readonly '~modifiers'?: RegleBehaviourOptions;
  $extractDirtyFields: (filterNullishValues?: boolean) => Record<string, any>;
  $validate: (forceValues?: any) => Promise<$InternalRegleResult>;
  $validateWithoutRaceconditions: (forceValues?: any) => Promise<$InternalRegleResult>;
  $id?: string;
  readonly $self?: $InternalRegleFieldStatus | undefined;
}
/**
 * @public
 */
type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialRuleTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string, TShortcuts extends RegleShortcutDefinition = {}, isUnionOverride extends boolean = false, TRulesTuple extends any[] = never> = HasNamedKeys<TState> extends true ? [TState[TKey]] extends [undefined | null] ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends string | number | boolean | bigint | symbol ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Array<unknown> ? TRule extends RegleCollectionRuleDefinition<any, any> ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any> ? RegleCollectionStatus<TState[TKey], ExtractFromGetter<TRule['$each']>, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCollectionStatus<TState[TKey], {}, TRule, TShortcuts> : TRule extends ReglePartialRuleTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<Raw<TState[TKey]>, TRule, TShortcuts> : unknown extends TState[TKey] ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? NonNullable<TState[TKey]> extends RegleStaticImpl<infer U> ? RegleFieldStatus<Raw<U>, TRule, TShortcuts> : TRule extends ReglePartialRuleTree<TState[TKey]> ? MaybeVariantStatus<TState[TKey], TRule, TShortcuts, isUnionOverride, TRulesTuple> : MaybeVariantStatus<TState[TKey], {}, TShortcuts, isUnionOverride, TRulesTuple> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<Raw<NonNullable<TState[TKey]>>, TRule, TShortcuts> : unknown extends TState[TKey] ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? NonNullable<TState[TKey]> extends RegleStaticImpl<infer U> ? RegleFieldStatus<Raw<U>, TRule, TShortcuts> : MaybeVariantStatus<TState[TKey], ReglePartialRuleTree<TState[TKey]>, TShortcuts, isUnionOverride, []> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCommonStatus<unknown>;
/**
 * @internal
 * @reference {@link InferRegleStatusType}
 */
type $InternalRegleStatusType = $InternalRegleCollectionStatus | $InternalRegleStatus | $InternalRegleFieldStatus;
/**
 * @public
 */
type RegleFieldStatus<TState extends any = any, TRules extends RegleFormPropertyType<any, Partial<ExtendedRulesDeclarations>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = never> = Omit<RegleCommonStatus<TState, TRules>, '$value' | '$silentValue' | '$initialValue' | '$originalValue'> & {
  /** A reference to the original validated model. It can be used to bind your form with v-model.*/$value: MaybeOutput<UnwrapNestedRefs<TState>>; /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
  $silentValue: MaybeOutput<UnwrapNestedRefs<TState>>;
  /**
   * This value reflect the current initial value of the field.
   * The initial value is different than the original value as the initial value can be mutated when using `$reset`.
   */
  readonly $initialValue: MaybeOutput<UnwrapNestedRefs<TState>>;
  /**
   * This value reflect the original value of the field at original call. This can't be mutated
   */
  readonly $originalValue: MaybeOutput<UnwrapNestedRefs<TState>>;
  /** Collection of all the error messages, collected for all children properties and nested forms.
   *
   * Only contains errors from properties where $dirty equals true. */
  readonly $errors: string[]; /** Collection of all the error messages, collected for all children properties and nested forms.  */
  readonly $silentErrors: string[];
  /**
   * Collect all metadata of validators, Only contains metadata from properties where $dirty equals true.
   */
  readonly $issues: RegleFieldIssue<TRules>[];
  /**
   * Collect all metadata of validators, including the error message.
   */
  readonly $silentIssues: RegleFieldIssue<TRules>[]; /** Stores external errors of the current field */
  readonly $externalErrors: string[]; /** Stores active tooltips messages of the current field */
  readonly $tooltips: string[]; /** Represents the inactive status. Is true when this state have empty rules */
  readonly $inactive: boolean; /** Adds runtime rules to the field. */
  $addRules: (rules: RegleRuleDecl) => void;
  /**
   * Adds runtime rules to the field.
   * @deprecated Use `$addRules` instead. This alias will be removed in a future version.
   */
  addRules: (rules: RegleRuleDecl) => void; /** Sets the external errors for the field. */
  $setExternalErrors(errors: string[]): void; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
  $extractDirtyFields: (filterNullishValues?: boolean) => MaybeOutput<TState>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
  $validate: (forceValues?: IsUnknown<TState> extends true ? any : TState) => Promise<RegleFieldResult<TState, TRules>>; /** This is reactive tree containing all the declared rules of your field. To know more about the rule properties check the rules properties section */
  readonly $rules: ComputeFieldRules<TState, TRules>;
} & CustomFieldProperties & ([TShortcuts['fields']] extends [never] ? {} : { [K in keyof TShortcuts['fields']]: ReturnType<NonNullable<TShortcuts['fields']>[K]> });
/**
 * @internal
 * @reference {@link RegleFieldStatus}
 */
interface $InternalRegleFieldStatus extends $InternalRegleCommonStatus {
  $value: any;
  $silentValue: any;
  readonly $rules: Record<string, $InternalRegleRuleStatus>;
  readonly $externalErrors?: string[];
  readonly $errors: string[];
  readonly $tooltips: string[];
  readonly $inactive: boolean;
  readonly $silentErrors: string[];
  readonly $issues: RegleFieldIssue[];
  readonly $isDebouncing: boolean;
  readonly $schemaMode?: boolean;
  readonly '~modifiers'?: FieldRegleBehaviourOptions;
  $addRules: (rules: RegleRuleDecl) => void;
  /** @deprecated Use `$addRules` instead. */
  addRules: (rules: RegleRuleDecl) => void;
  $extractDirtyFields: (filterNullishValues?: boolean) => any;
  $validate: (forceValues?: unknown) => Promise<$InternalRegleResult>;
  /**
   * Validates the field synchronously without waiting for async rules.
   * @internal
   */
  $validateSync: (forceValues?: unknown) => boolean;
  /** Validate without the await nextTick */
  $validateWithoutRaceconditions: (forceValues?: unknown) => Promise<$InternalRegleResult>;
}
/**
 * @public
 */
interface RegleCommonStatus<TValue = any, TRules extends Record<string, any> = Record<string, any>> extends StandardSchemaV1<TValue, HasNamedKeys<TRules> extends true ? InferOutput<TRules, TValue> : MaybeOrPartial<TValue>> {
  /** Indicates whether the field is invalid. It becomes true if any associated rules return false. */
  readonly $invalid: boolean;
  /**
   * This is not the opposite of `$invalid`. Correct is meant to display UI validation report.
   *
   * This will be `true` only if:
   * - The field has at least one active rule
   * - Is dirty and not empty
   * - Passes validation
   */
  readonly $correct: boolean;
  /** Indicates whether a field has been validated or interacted with by the user at least once. It's typically used to determine if a message should be displayed to the user. You can change this flag manually using the $touch and $reset methods. The $dirty flag is considered true if the current model has been touched or if all its children are dirty.*/
  readonly $dirty: boolean;
  /** Similar to $dirty, with one exception. The $anyDirty flag is considered true if given model was touched or any of its children are $anyDirty which means at least one descendant is $dirty. */
  readonly $anyDirty: boolean;
  /** Indicates whether a field has been touched and if the value is different than the initial one.
   *  On nested elements and collections, it's true only if all its children are also `$edited`.
   *  Use `$anyEdited` to check for any edited children
   */
  readonly $edited: boolean;
  /** Similar to $edited, with one exception. The $anyEdited flag is considered true if given model was edited or any of its children are $anyEdited which means at least one descendant is $edited. */
  readonly $anyEdited: boolean;
  /** Indicates if any async rule for the field is currently running. Always false for synchronous rules. */
  readonly $pending: boolean;
  /** Convenience flag to easily decide if a message should be displayed. Equivalent to $dirty && !$pending && $invalid. */
  readonly $error: boolean;
  /** Indicates whether the field is ready for submission. Equivalent to !$invalid && !$pending. */
  readonly $ready: boolean;
  /** Return the current key name of the field. */
  readonly $name: string;
  /** Returns the current path of the rule (used internally for tracking) */
  readonly $path: string;
  /** Id used to track collections items */
  $id?: string;
  /** A reference to the original validated model. It can be used to bind your form with v-model.*/
  $value: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
  /**
   * `$value` variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction.
   * */
  $silentValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
  /**
   * This value reflect the current initial value of the field.
   * The initial value is different than the original value as the initial value can be mutated when using `$reset`.
   */
  readonly $initialValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
  /**
   * This value reflect the original value of the field at original call. This can't be mutated
   */
  readonly $originalValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
  /**
   * Validates the field synchronously without waiting for async rules.
   *
   * This method provides immediate validation feedback by running only synchronous rules.
   * Async rules are skipped and assumed to be valid. Unlike `$validate`, this method:
   * - Does NOT wait for async validation results
   * - Returns a boolean directly instead of a Promise
   *
   * Use this when you need immediate validation feedback without side effects,
   * such as for real-time UI feedback or form gating logic.
   *
   * @param forceValues - Optional values to set before validating. Note that due to Vue's
   *                      reactivity system, you may need to wait for `nextTick()` after
   *                      setting values for rules to recalculate.
   * @returns `true` if all synchronous rules pass, `false` otherwise.
   *          Always returns `false` in schema mode.
   *
   * @example
   * ```ts
   * // Basic usage
   * const isValid = r$.$validateSync();
   *
   * // Field-level validation
   * const isEmailValid = r$.email.$validateSync();
   *
   * // Use with form submission gating
   * function handleSubmit() {
   *   if (r$.$validateSync()) {
   *     // Proceed with submission
   *   }
   * }
   * ```
   *
   */
  $validateSync: (forceValues?: unknown) => boolean;
  /** Marks the field and all nested properties as $dirty. */
  $touch(): void;
  /**
   * Reset the validation status to a pristine state while keeping the current form state.
   * Resets the `$dirty` state on all nested properties of a form.
   * Rerun rules if `$lazy` is false
   */
  $reset(): void;
  $reset(options?: ResetOptions<TValue>): void;
  /** Clears the $externalErrors state back to an empty object. */
  $clearExternalErrors(): void;
}
interface $InternalRegleCommonStatus extends Omit<RegleCommonStatus, '$touch' | '$reset'> {
  $touch(runCommit?: boolean, withConditions?: boolean): void;
  $unwatch(): void;
  $watch(): void;
  $reset(options?: ResetOptions<any>, fromParent?: boolean): void;
  $abort(): void;
  $setExternalErrors(errors: RegleExternalErrorTree<unknown>): void;
}
/**
 * @public
 */
type RegleRuleStatus<TValue = any, TParams extends any[] = any[], TMetadata extends RegleRuleMetadataDefinition = boolean> = {
  /** The name of the rule type. */readonly $type: string; /** Returns the computed error message or messages for the current rule. */
  readonly $message: string | string[]; /** Stores the current rule tooltip or tooltips */
  readonly $tooltip: string | string[]; /** Indicates whether or not the rule is enabled (for rules like requiredIf) */
  readonly $active: boolean; /** Indicates the state of validation for this validator. */
  readonly $valid: boolean; /** If the rule is async, indicates if it's currently pending. Always false if it's synchronous. */
  readonly $pending: boolean; /** Returns the current path of the rule (used internally for tracking) */
  readonly $path: string; /** Contains the metadata returned by the validator function. */
  readonly $metadata: TMetadata extends boolean ? TMetadata : Omit<TMetadata, '$valid'>;
  /**
   * Run the rule validator asynchronously and compute its properties like `$message` and `$active`.
   * @returns A promise that resolves to `true` if the rule passes, `false` otherwise.
   */
  $parse(): Promise<boolean>;
  /**
   * Run only the rule validator synchronously, skipping async rules.
   *
   * If the rule is async, this method returns `true` (assumes valid) since it cannot
   * wait for the async result. Use `$parse()` for async rules.
   *
   * @returns `true` if the sync rule passes or if the rule is async, `false` otherwise.
   */
  $parseSync(): boolean; /** Reset the $valid, $metadata and $pending states */
  $reset(): void; /** Returns the original rule validator function. */
  $validator: ((value: IsUnknown<TValue> extends true ? any : MaybeInput<TValue>, ...args: any[]) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>) & ((value: IsUnknown<TValue> extends true ? any : TValue, ...args: [TParams] extends [never[]] ? [] : [unknown[]] extends [TParams] ? any[] : TParams) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>);
} & ([TParams] extends [never[]] ? {} : [unknown[]] extends [TParams] ? {
  /** Contains the rule parameters when the rule accepts arguments. */readonly $params?: any[];
} : {
  /** Contains the rule parameters when the rule accepts arguments. */readonly $params: [...TParams];
});
/**
 * @internal
 * @reference {@link RegleRuleStatus}
 */
interface $InternalRegleRuleStatus {
  $type?: string;
  $message: string | string[];
  $tooltip: string | string[];
  $active: boolean;
  $valid: boolean;
  $pending: boolean;
  $path: string;
  $externalErrors?: string[];
  $params?: any[];
  $metadata: any;
  $haveAsync: boolean;
  $validating: boolean;
  $fieldDirty: boolean;
  $fieldInvalid: boolean;
  $fieldPending: boolean;
  $fieldCorrect: boolean;
  $fieldError: boolean;
  $maybePending: boolean;
  $validator(value: any, ...args: any[]): RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
  /** @internal */
  $parse(): Promise<boolean>;
  /**
   * Run only the rule validator synchronously. Returns `true` for async rules.
   * @internal
   */
  $parseSync(): boolean;
  $reset(): void;
  $unwatch(): void;
  $watch(): void;
}
/**
 * @public
 */
type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePartialRuleTree<Record<string, any>> = Record<string, any>, TFieldRule extends RegleCollectionRuleDecl<any, any> = never, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState, TRules>, '$value'> & {
  /** A reference to the original validated model. It can be used to bind your form with v-model.*/$value: MaybeOutput<TState>; /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
  $silentValue: MaybeOutput<TState>; /** Collection of status of every item in your collection. Each item will be a field you can access, or map on it to display your elements. */
  readonly $each: InferRegleStatusType<NonNullable<TRules>, NonNullable<TState>, number, TShortcuts, IsUnion<TRules>, UnionToTuple<TRules>>[]; /** Represents the status of the collection itself. You can have validation rules on the array like minLength, this field represents the isolated status of the collection. */
  readonly $self: RegleFieldStatus<TState, TFieldRule, TShortcuts>;
  /**
   * Collection of all the issues, collected for all children properties and nested forms.
   *
   * Only contains issues from properties where $dirty equals true.
   */
  readonly $issues: RegleCollectionErrors<TState, true>;
  /** Collection of all the error messages, collected for all children properties and nested forms.
   *
   * Only contains errors from properties where $dirty equals true. */
  readonly $errors: RegleCollectionErrors<TState>; /** Collection of all the error messages, collected for all children properties and nested forms.  */
  readonly $silentErrors: RegleCollectionErrors<TState>; /** Sets the external errors for the field. */
  $setExternalErrors(errors: RegleExternalCollectionErrors<TState>): void; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
  $validate: (value?: JoinDiscriminatedUnions<TState>) => Promise<RegleCollectionResult<TState, JoinDiscriminatedUnions<TRules>>>;
} & CustomCollectionProperties & ([TShortcuts['collections']] extends [never] ? {} : { [K in keyof TShortcuts['collections']]: ReturnType<NonNullable<TShortcuts['collections']>[K]> });
/**
 * @internal
 * @reference {@link RegleCollectionStatus}
 */
interface $InternalRegleCollectionStatus extends Omit<$InternalRegleStatus, '$fields' | '$issues' | '$errors' | '$silentErrors' | '~modifiers' | '$externalErrors'> {
  readonly $self: $InternalRegleFieldStatus;
  readonly $each: Array<$InternalRegleStatusType>;
  readonly $issues: $InternalRegleCollectionIssues;
  readonly $errors: $InternalRegleCollectionErrors;
  readonly $silentErrors: $InternalRegleCollectionErrors;
  readonly $externalErrors?: string[];
  readonly '~modifiers'?: CollectionRegleBehaviourOptions;
  $extractDirtyFields: (filterNullishValues?: boolean) => any[];
  $validate: (forceValues?: any) => Promise<$InternalRegleResult>;
  /** Validate without the await nextTick */
  $validateWithoutRaceconditions: (forceValues?: any) => Promise<$InternalRegleResult>;
}
/**
 * @public
 */
type ReglePartialRuleTree<TForm extends Record<string, any> = Record<string, any>, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = { [TKey in keyof TForm]?: RegleFormPropertyType<TForm[TKey], TCustomRules> } & SelfObjectValidationDecl<TForm, TCustomRules>;
type SelfObjectValidationDecl<TForm extends Record<string, any> = Record<string, any>, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = {
  $self?: MaybeRefOrComputedRef<RegleRuleDecl<TForm, TCustomRules>>;
};
/**
 * @public
 */
type RegleRuleTree<TForm extends Record<string, any>, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = HasNamedKeys<TForm> extends true ? { [TKey in keyof TForm]: RegleFormPropertyType<TForm[TKey], TCustomRules> } & SelfObjectValidationDecl<TForm, TCustomRules> : RegleUnknownRulesTree;
/**
 * @public
 */
type RegleUnknownRulesTree = {
  [x: string]: RegleRuleDecl | RegleCollectionRuleDecl | RegleUnknownRulesTree;
};
/**
 * @public
 */
type RegleComputedRules<TForm extends MaybeRefOrComputedRef<Record<string, any>> | DeepReactiveState<Record<string, any>>, TCustomRules extends Partial<ExtendedRulesDeclarations> | Regle<any, any> | useRegleFn<any> = Partial<ExtendedRulesDeclarations>, TState = Unwrap<UnwrapMaybeRef<TForm>>, TCustom = (TCustomRules extends Regle<any, infer R> ? R extends ReglePartialRuleTree<any, infer C> ? C : Partial<ExtendedRulesDeclarations> : TCustomRules extends useRegleFn<infer Rules, any> ? Rules : {})> = { [TKey in keyof JoinDiscriminatedUnions<TState>]?: RegleFormPropertyType<JoinDiscriminatedUnions<TState>[TKey], Omit<Partial<ExtendedRulesDeclarations>, keyof TCustom> & Partial<TCustom>> };
/**
 * @internal
 * @reference {@link ReglePartialRuleTree}
 */
type $InternalReglePartialRuleTree = {
  [x: string]: $InternalFormPropertyTypes;
} & {
  $self?: $InternalRegleRuleDecl;
};
/**
 * @public
 */
type RegleFormPropertyType<TValue = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = [NonNullable<TValue>] extends [never] ? MaybeRefOrComputedRef<RegleRuleDecl<TValue, TCustomRules>> : NonNullable<TValue> extends PrimitiveTypes ? MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue>, TCustomRules>> : NonNullable<TValue> extends Array<any> ? RegleCollectionRuleDecl<TValue, TCustomRules> : NonNullable<TValue> extends Ref<infer V> ? RegleFormPropertyType<V, TCustomRules> : NonNullable<TValue> extends Record<string, any> ? NonNullable<TValue> extends RegleStatic<infer U> ? MaybeRefOrComputedRef<RegleRuleDecl<Raw<U>, TCustomRules>> : ReglePartialRuleTree<NonNullable<TValue>, TCustomRules> : MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue>, TCustomRules>>;
/**
 * @internal
 * @reference {@link RegleFormPropertyType}
 */
type $InternalFormPropertyTypes = MaybeRefOrComputedRef<$InternalRegleRuleDecl> | $InternalRegleCollectionRuleDecl | $InternalReglePartialRuleTree | FieldRegleBehaviourOptions;
/**
 * @public
 * Rule tree for a form property
 */
type RegleRuleDecl<TValue extends any = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<DefaultValidatorsTree>, TOptions extends Record<string, unknown> = FieldRegleBehaviourOptions<TValue>> = TOptions & { [TKey in keyof RemoveIndexSignature<TCustomRules>]?: NonNullable<TCustomRules[TKey]> extends RegleRuleDefinitionLight<infer TParams, boolean, infer TMetadata> ? RegleRuleDefinitionLight<ParamsToLooseParams<TParams>, boolean, TMetadata> | InlineRuleDeclaration<TValue, ParamsToLooseParams<TParams>, any> : TCustomRules[TKey] } & {
  [x: string]: FormRuleDeclaration<TValue, any[]> | boolean | number | undefined;
};
/**
 * @internal
 * @reference {@link RegleRuleDecl}
 */
type $InternalRegleRuleDecl = FieldRegleBehaviourOptions & CollectionRegleBehaviourOptions & Record<string, FormRuleDeclaration<any, any>>;
/**
 * @public
 */
type RegleCollectionRuleDeclKeyProperty = {
  $key?: PropertyKey;
};
type CollectionEachRuleDecl<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = IsAny<TValue> extends true ? {
  $each?: RegleCollectionEachRules<TValue, TCustomRules>;
} : MaybeNullable<TValue> extends true ? {
  /**
   * Rules for each item in the collection
   *
   * ⚠️ `$each` is required here because your array is potentially undefined.
   * Regle can't guess the type of the array if it's undefined.
   * Having an empty `$each: {}` is the only way to tell Regle that the array is a collection.
   */
  $each: RegleCollectionEachRules<TValue, TCustomRules>;
} : {
  /**
   * Rules for each item in the collection
   */
  $each?: RegleCollectionEachRules<TValue, TCustomRules>;
};
/**
 * @public
 */
type RegleCollectionRuleDecl<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = (CollectionEachRuleDecl<TValue, TCustomRules> & RegleRuleDecl<NonNullable<TValue>, TCustomRules, CollectionRegleBehaviourOptions>) | (CollectionEachRuleDecl<TValue, TCustomRules> & CollectionRegleBehaviourOptions);
/** @public */
type RegleCollectionEachRules<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>, RegleCollectionRuleDeclKeyProperty, RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>>;
/**
 * @internal
 * @reference {@link RegleCollectionRuleDecl}
 */
type $InternalRegleCollectionRuleDecl = $InternalRegleRuleDecl & {
  $each?: MaybeGetter<$InternalFormPropertyTypes & RegleCollectionRuleDeclKeyProperty, any, {}, {
    $self?: $InternalRegleFieldStatus;
  }>;
};
/**
 * @public
 */
type InlineRuleDeclaration<TValue extends any = any, TParams extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean> = (value: Maybe<TValue>, ...args: UnwrapRegleUniversalParams<TParams>) => TReturn;
/**
 * @public
 * Regroup inline and registered rules
 * */
type FormRuleDeclaration<TValue extends any = unknown, TParams extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = boolean> = RegleRuleWithParamsDefinitionInput<unknown, TValue, [param?: any], TAsync, TMetadata> | RegleRuleDefinition<unknown, TValue, TParams, TAsync, TMetadata, any, any, boolean> | RegleRuleWithParamsDefinitionInput<unknown, TValue, [param?: any, ...any[]], TAsync, TMetadata> | InlineRuleDeclaration<TValue, TParams, TReturn>;
type RegleErrorTree<TState = MaybeRef<Record<string, any> | any[]>, TIssue extends boolean = false, TSchema extends boolean = false> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? any : { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], false, TIssue, TSchema> } & {
  readonly $self?: string[];
};
type RegleIssuesTree<TState = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? any : { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], false, true, TSchema, K extends keyof TRules ? TRules[K] extends RegleFormPropertyType<Record<string, any>> ? TRules[K] : EmptyObject : EmptyObject> } & {
  readonly $self?: RegleFieldIssue[];
};
type RegleExternalErrorTree<TState = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? any : ({ readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]?: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], true, TSchema> } & {
  readonly $self?: RegleFieldIssue[];
}) | Record<Paths<TState> | (string & {}), string[]>;
type RegleExternalSchemaErrorTree<TState = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? any : { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]?: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], true, true, TSchema> };
type ErrorMessageOrIssue<TIssue extends boolean, TRules extends RegleFormPropertyType<Record<string, any>> = EmptyObject> = TIssue extends true ? RegleFieldIssue<TRules>[] : string[];
type RegleValidationErrors<TState extends Record<string, any> | any[] | unknown = never, TExternal extends boolean = false, TIssue extends boolean = false, TSchema extends boolean = false, TRules extends RegleFormPropertyType<Record<string, any>> = EmptyObject> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? any : HasNamedKeys<TState> extends true ? NonNullable<TState> extends Array<infer U> ? TSchema extends false ? TExternal extends false ? RegleCollectionErrors<U, TIssue, TSchema> : RegleExternalCollectionErrors<U, TIssue, TSchema> : RegleCollectionErrors<U, TIssue, TSchema> : NonNullable<TState> extends Date | File ? ErrorMessageOrIssue<TIssue, TRules> : NonNullable<TState> extends Record<string, any> ? IsRegleStatic<NonNullable<TState>> extends true ? ErrorMessageOrIssue<TIssue, TRules> : TExternal extends false ? RegleErrorTree<TState, TIssue, TSchema> : RegleExternalErrorTree<TState, TSchema> : ErrorMessageOrIssue<TIssue, TRules> : any;
type RegleFieldIssue<TRules extends RegleFormPropertyType<unknown, Partial<ExtendedRulesDeclarations>> = EmptyObject> = {
  readonly $property: string;
  readonly $type?: string;
  readonly $message: string;
} & (IsEmptyObject<TRules> extends true ? {
  readonly $rule: string;
} : { [K in keyof ComputeFieldRules<any, TRules>]: ComputeFieldRules<any, TRules>[K] extends {
  $metadata: infer TMetadata;
} ? K extends string ? {
  readonly $rule: K;
} & (TMetadata extends boolean ? {
  readonly $rule: string;
} : TMetadata) : {
  readonly $rule: string;
} : {
  readonly $rule: string;
} }[keyof ComputeFieldRules<any, TRules>]);
type ComputeFieldRules<TState extends any, TRules extends MaybeRef<RegleFormPropertyType<unknown, Partial<ExtendedRulesDeclarations>>>> = IsEmptyObject<UnwrapRef<TRules>> extends true ? {
  readonly [x: string]: RegleRuleStatus<TState, any[], any>;
} : { readonly [TRuleKey in keyof UnwrapRef<TRules> as TRuleKey extends '$each' | keyof FieldRegleBehaviourOptions ? never : TRuleKey]: RegleRuleStatus<TState, UnwrapRef<TRules>[TRuleKey] extends RegleRuleDefinitionLight<infer TParams, any> ? TParams : [], UnwrapRef<TRules>[TRuleKey] extends RegleRuleDefinitionLight<any, any, infer TMetadata> ? TMetadata : UnwrapRef<TRules>[TRuleKey] extends InlineRuleDeclaration<any, any[], infer TReturn> ? TReturn extends Promise<infer P> ? P : TReturn : RegleRuleMetadataDefinition> };
type RegleCollectionErrors<TState extends any, TIssue extends boolean = false, TSchema extends boolean = false> = {
  readonly $self: TIssue extends true ? RegleFieldIssue[] : string[];
  readonly $each: RegleValidationErrors<TState, false, TIssue, TSchema>[];
};
type RegleExternalCollectionErrors<TState extends unknown, TIssue extends boolean = false, TSchema extends boolean = false> = {
  readonly $self?: TIssue extends true ? RegleFieldIssue[] : string[];
  readonly $each?: RegleValidationErrors<TState, true, TIssue, TSchema>[];
};
/** @internal */
type $InternalRegleCollectionErrors = {
  readonly $self?: string[];
  readonly $each?: $InternalRegleErrors[];
};
type $InternalRegleErrorTree = {
  [x: string]: $InternalRegleErrors;
};
type $InternalRegleErrors = $InternalRegleCollectionErrors | string[] | $InternalRegleErrorTree;
type $InternalRegleIssuesTree = {
  [x: string]: $InternalRegleIssues;
};
type $InternalRegleIssues = $InternalRegleCollectionIssues | RegleFieldIssue[] | $InternalRegleIssuesTree;
type $InternalRegleCollectionIssues = {
  readonly $self?: RegleFieldIssue[];
  readonly $each?: $InternalRegleIssues[];
};
type RegleLike<TState extends Record<string, any>> = {
  $value: TState;
  $validate: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
};
interface SuperCompatibleRegle {
  r$: SuperCompatibleRegleRoot;
}
/** Supports both core Regle and schemas Regle for Zod/Valibot */
type SuperCompatibleRegleRoot = SuperCompatibleRegleStatus & {
  $groups?: {
    [x: string]: RegleValidationGroupOutput;
  };
  $validate: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
  '~modifiers'?: RegleBehaviourOptions;
};
type SuperCompatibleRegleResult = $InternalRegleResult;
type SuperCompatibleRegleStatus = {
  readonly $fields?: {
    [x: string]: any;
  };
  readonly $issues: Record<string, RegleValidationErrors<any, false, true>>;
  readonly $errors: Record<string, RegleValidationErrors<any, false>>;
  readonly $silentErrors: Record<string, RegleValidationErrors<any, false>>;
  $extractDirtyFields: (filterNullishValues?: boolean) => Record<string, any>;
  $validate?: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
  $reset: (options?: ResetOptions<unknown>) => void;
  [x: string]: any;
};
type SuperCompatibleRegleRuleStatus = Omit<$InternalRegleRuleStatus, '$haveAsync' | '$validating' | '$fieldDirty' | '$fieldInvalid' | '$fieldPending' | '$fieldCorrect' | '$fieldError' | '$unwatch' | '$watch' | '$maybePending'>;
type SuperCompatibleRegleCommonStatus = Omit<RegleCommonStatus, '$pending' | '$validateSync'> & {
  $pending?: boolean;
};
interface SuperCompatibleRegleFieldStatus extends SuperCompatibleRegleCommonStatus {
  $value: any;
  $silentValue: any;
  readonly $rules: Record<string, SuperCompatibleRegleRuleStatus>;
  readonly $externalErrors?: string[];
  readonly $issues: RegleFieldIssue[];
  readonly $silentIssues: RegleFieldIssue[];
  readonly $errors: string[];
  readonly $inactive: boolean;
  readonly $silentErrors: string[];
  $validate?: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
  $validateSync?: (...args: any[]) => boolean;
}
interface SuperCompatibleRegleCollectionStatus extends Omit<SuperCompatibleRegleStatus, '$fields' | '$issues' | '$errors' | '$silentErrors' | 'extractDirtyFields'> {
  readonly $self: SuperCompatibleRegleFieldStatus;
  readonly $each: Array<SuperCompatibleRegleStatus | SuperCompatibleRegleFieldStatus>;
  readonly $issues: SuperCompatibleRegleCollectionIssues;
  readonly $errors: SuperCompatibleRegleCollectionErrors;
  readonly $silentErrors: SuperCompatibleRegleCollectionErrors;
  readonly $externalErrors?: string[];
  $extractDirtyFields: (filterNullishValues?: boolean) => any[];
  $validate?: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
  $validateSync?: (...args: any[]) => boolean;
}
type SuperCompatibleRegleCollectionErrors = $InternalRegleCollectionErrors;
type SuperCompatibleRegleCollectionIssues = $InternalRegleCollectionIssues;
/**
 * Create a typed custom rule that can be used like built-in rules.
 * The created rule can be declared in global options or used directly.
 *
 * Features:
 * - Automatically detects if the rule is async
 * - Supports parameters for configurable rules
 * - Full TypeScript type inference
 * - Custom metadata support
 *
 * @param definition - The rule definition object containing:
 *   - `validator`: The validation function
 *   - `message`: Error message (string or function)
 *   - `type`: Optional rule type identifier
 *   - `active`: Optional function to conditionally activate the rule
 *   - `tooltip`: Optional tooltip message
 *
 * @returns A rule definition that is callable if it accepts parameters
 *
 * @example
 * ```ts
 * import { createRule } from '@regle/core';
 * import { isFilled } from '@regle/rules';
 *
 * // Simple rule without params
 * export const isFoo = createRule({
 *   validator(value: Maybe<string>) {
 *     if (isFilled(value)) {
 *       return value === 'foo';
 *     }
 *     return true;
 *   },
 *   message: "The value should be 'foo'"
 * });
 *
 * // Rule with parameters
 * export const minCustom = createRule({
 *   validator(value: Maybe<number>, min: number) {
 *     if (isFilled(value)) {
 *       return value >= min;
 *     }
 *     return true;
 *   },
 *   message: ({ $params: [min] }) => `Value must be at least ${min}`
 * });
 *
 * // Usage
 * useRegle({ name: '' }, { name: { isFoo } });
 * useRegle({ count: 0 }, { count: { minCustom: minCustom(5) } });
 * ```
 *
 * @see {@link https://reglejs.dev/core-concepts/rules/reusable-rules Documentation}
 */
declare function createRule<const TType extends string | unknown, TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false), TNonEmpty extends boolean = false>(definition: RegleRuleInit<TType, TValue, TParams, TReturn, TMetadata, TAsync, TNonEmpty>): InferRegleRule<TType, TValue, TParams, TAsync, TMetadata, TNonEmpty extends true ? true : false>;
/**
 * Returns a clean list of parameters
 * Removing Ref and executing function to return the unwrapped value
 */
declare function unwrapRuleParameters<TParams extends any[]>(params: MaybeRefOrGetter[]): TParams;
type MergedRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TValue = { [K in keyof TRegles]: TRegles[K]['$value'] }> = Omit<RegleCommonStatus, '$value' | '$silentValue' | '$errors' | '$silentErrors' | '$name' | '$unwatch' | '$watch' | '$extractDirtyFields'> & {
  /** Map of merged Regle instances and their properties  */readonly $instances: { [K in keyof TRegles]: TRegles[K] }; /** A reference to the original validated model. It can be used to bind your form with v-model.*/
  $value: TValue; /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
  $silentValue: TValue;
  /** Collection of all the error messages, collected for all children properties and nested forms.
   *
   * Only contains errors from properties where $dirty equals true. */
  readonly $errors: { [K in keyof TRegles]: TRegles[K]['$errors'] }; /** Collection of all the error messages, collected for all children properties. */
  readonly $silentErrors: { [K in keyof TRegles]: TRegles[K]['$silentErrors'] };
  readonly $issues: { [K in keyof TRegles]: TRegles[K]['$issues'] };
  readonly $silentIssues: { [K in keyof TRegles]: TRegles[K]['$silentIssues'] }; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TValue>[]; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
  $validate: (forceValues?: TRegles['$value']) => Promise<MergedReglesResult<TRegles>>;
  $validateSync: (forceValues?: TRegles['$value']) => boolean;
} & (HasNamedKeys<TRegles> extends true ? { [K in keyof TRegles]: TRegles[K] } : {});
type MergedScopedRegles<TValue extends Record<string, unknown>[] = Record<string, unknown>[]> = Omit<MergedRegles<Record<string, SuperCompatibleRegleRoot>, TValue>, '$instances' | '$errors' | '$silentErrors' | '$value' | '$silentValue' | '$validate' | '$extractDirtyFields'> & {
  /** Array of scoped Regles instances  */readonly $instances: SuperCompatibleRegleRoot[]; /** Collection of all registered Regles instances values */
  readonly $value: TValue; /** Collection of all registered Regles instances errors */
  readonly $errors: RegleValidationErrors<Record<string, unknown>>[]; /** Collection of all registered Regles instances silent errors */
  readonly $silentErrors: RegleValidationErrors<Record<string, unknown>>[]; /** Collection of all registered Regles instances issues */
  readonly $issues: RegleValidationErrors<Record<string, unknown>, false, true>[]; /** Collection of all registered Regles instances silent issues */
  readonly $silentIssues: RegleValidationErrors<Record<string, unknown>, false, true>[]; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TValue>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
  $validate: (forceValues?: TValue) => Promise<{
    valid: boolean;
    data: TValue;
    errors: RegleValidationErrors<Record<string, unknown>>[];
    issues: RegleValidationErrors<Record<string, unknown>>[];
  }>;
};
type MergedReglesResult<TRegles extends Record<string, SuperCompatibleRegleRoot>> = {
  valid: false;
  data: { [K in keyof TRegles]: Extract<PromiseReturn<ReturnType<TRegles[K]['$validate']>>, {
    valid: false;
  }>['data'] };
  errors: { [K in keyof TRegles]: TRegles[K]['$errors'] };
  issues: { [K in keyof TRegles]: TRegles[K]['$issues'] };
} | {
  valid: true;
  data: { [K in keyof TRegles]: Extract<PromiseReturn<ReturnType<TRegles[K]['$validate']>>, {
    valid: true;
  }>['data'] };
  errors: EmptyObject;
  issues: EmptyObject;
};
/**
 * Merge multiple Regle instances into a single validation state.
 * Useful for combining multiple forms or validation scopes.
 *
 * @param regles - An object containing named Regle instances to merge
 * @param _scoped - Internal flag for scoped validation (default: false)
 * @returns A merged validation state with all instances' properties combined
 *
 * @example
 * ```ts
 * import { useRegle, mergeRegles } from '@regle/core';
 * import { required } from '@regle/rules';
 *
 * // Create separate validation instances
 * const { r$: personalInfo } = useRegle(
 *   { name: '', email: '' },
 *   { name: { required }, email: { required } }
 * );
 *
 * const { r$: address } = useRegle(
 *   { street: '', city: '' },
 *   { street: { required }, city: { required } }
 * );
 *
 * // Merge them together
 * const merged$ = mergeRegles({
 *   personalInfo,
 *   address
 * });
 *
 * // Access combined state
 * merged$.$valid           // true when ALL forms are valid
 * merged$.$errors          // { personalInfo: {...}, address: {...} }
 * await merged$.$validate() // Validates all forms
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/merge-regles Documentation}
 */
declare function mergeRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TScoped extends boolean = false>(regles: TRegles, _scoped?: TScoped): TScoped extends false ? MergedRegles<TRegles> : MergedScopedRegles;
type useCollectScopeFn<TNamedScoped extends boolean = false> = TNamedScoped extends true ? <const TValue extends Record<string, Record<string, any>>>(namespace?: MaybeRefOrGetter<string | string[]>) => {
  r$: MergedRegles<{ [K in keyof TValue]: RegleRoot<TValue[K]> & SuperCompatibleRegleRoot }>;
} : <TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string | string[]>) => {
  r$: MergedScopedRegles<TValue>;
};
type UseScopedRegleOptions<TAsRecord extends boolean> = {
  namespace?: MaybeRefOrGetter<string | undefined>;
} & (TAsRecord extends true ? RequireAtLeastOne<{
  id: string;
  /**
   * @deprecated Use `id` instead
   */
  scopeKey: string;
}, 'id' | 'scopeKey'> : {});
type useScopedRegleFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>, TShortcuts extends RegleShortcutDefinition<TCustomRules>, TAsRecord extends boolean> = useRegleFn<TCustomRules, TShortcuts, {
  dispose: () => void;
  register: () => void;
}, UseScopedRegleOptions<TAsRecord>>;
type CreateScopedUseRegleOptions<TCustomRegle extends useRegleFn<any, any>, TAsRecord extends boolean> = {
  /**
   * Inject a global configuration to the exported composables to keep your translations and typings
   */
  customUseRegle?: TCustomRegle;
  /**
   * Store the collected instances externally
   */
  customStore?: Ref<ScopedInstancesRecordLike>;
  /**
   * Collect instances in a Record instead of an array
   *
   * ⚠️ Each nested `useScopedRegle` must provide a parameter `id` to be collected.
   */
  asRecord?: TAsRecord;
};
/**
 * Create a scoped validation system for collecting and validating multiple form instances.
 * Useful for dynamic forms, multi-step wizards, or component-based form architectures.
 *
 * @param options - Configuration options
 * @param options.customUseRegle - Custom useRegle instance with your global config
 * @param options.customStore - External ref to store collected instances
 * @param options.asRecord - If true, collect instances in a Record (requires `id` param in useScopedRegle)
 * @returns Object containing `useScopedRegle` and `useCollectScope` functions
 *
 * @example
 * ```ts
 * // scoped-config.ts
 * import { createScopedUseRegle } from '@regle/core';
 *
 * export const { useScopedRegle, useCollectScope } = createScopedUseRegle();
 *
 * // ChildComponent.vue
 * const { r$ } = useScopedRegle(state, rules, {
 *   namespace: 'myForm'
 * });
 *
 * // ParentComponent.vue
 * const { r$: collectedR$ } = useCollectScope('myForm');
 * await collectedR$.$validate(); // Validates all child forms
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/scoped-validation Documentation}
 */
declare function createScopedUseRegle<TCustomRegle extends useRegleFn<any, any> = useRegleFn<Partial<ExtendedRulesDeclarationsOverrides>>, TAsRecord extends boolean = false, TReturnedRegle extends useRegleFn<any, any, any, any> = (TCustomRegle extends useRegleFn<infer A, infer B> ? useScopedRegleFn<A, B, TAsRecord> : useScopedRegleFn<Partial<ExtendedRulesDeclarationsOverrides>, any, TAsRecord>)>(options?: CreateScopedUseRegleOptions<TCustomRegle, TAsRecord>): {
  useScopedRegle: TReturnedRegle;
  useCollectScope: useCollectScopeFn<TAsRecord>;
};
/**
 * Composable to collect and merge all Regle instances created with the default `useScopedRegle` within the same scope.
 * Returns a merged `r$` object allowing validation across multiple components simultaneously.
 *
 * Children properties like `$value` and `$errors` are converted to arrays instead of objects.
 * You have access to all validation properties like `$error`, `$invalid`, `$validate()`, etc.
 *
 * @param namespace - Optional namespace or array of namespaces to filter which scoped instances to collect
 * @returns Object containing `r$` - the merged Regle instance with array-based properties
 *
 * @example
 * ```ts
 * // ParentComponent.vue
 * import { useCollectScope } from '@regle/core';
 *
 * const { r$ } = useCollectScope();
 * // Or with namespace filtering
 * const { r$ } = useCollectScope('contacts');
 *
 * // Validate all collected forms
 * const { result, data } = await r$.$validate();
 * // Access collected errors
 * console.log(r$.$errors);
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/scoped-validation Documentation}
 */
declare const useCollectScope: <TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string | string[]>) => {
  r$: MergedScopedRegles<TValue>;
};
/**
 * Clone of `useRegle` that automatically registers its instance for collection by `useCollectScope`.
 * Every time it's called, a new instance is added for the parent scope to collect.
 *
 * Can be called multiple times anywhere in your app - not restricted to components or DOM.
 * When the component is unmounted or scope is disposed, the instance is automatically unregistered.
 *
 * @param state - Reactive state object to validate
 * @param rules - Validation rules to apply
 * @param options - Configuration options including optional `namespace` for scoping
 * @returns Object containing `r$` (Regle instance), `dispose()` and `register()` methods
 *
 * @example
 * ```ts
 * // ChildComponent.vue
 * import { useScopedRegle } from '@regle/core';
 *
 * const { r$ } = useScopedRegle(
 *   { email: '' },
 *   { email: { required, email } },
 *   { namespace: 'contacts' }
 * );
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/scoped-validation Documentation}
 */
declare const useScopedRegle: useScopedRegleFn<Partial<ExtendedRulesDeclarationsOverrides>, never, boolean>;
/**
 * Create variant-based validation rules that depend on a discriminant field value.
 * Useful for union types where different fields are required based on a type discriminant.
 *
 * Note: Autocomplete may not fully work due to TypeScript limitations.
 *
 * @param root - The reactive state object
 * @param discriminantKey - The key used to discriminate between variants
 * @param variants - Array of variant rule definitions using `literal` for type matching
 * @returns A computed ref containing the currently active variant rules
 *
 * @example
 * ```ts
 * import { useRegle, createVariant } from '@regle/core';
 * import { required, email, literal } from '@regle/rules';
 *
 * const state = ref({
 *   type: 'EMAIL' as 'EMAIL' | 'GITHUB',
 *   email: '',
 *   username: ''
 * });
 *
 * // ⚠️ Use getter syntax for your rules
 * const { r$ } = useRegle(state, () => {
 *   const variant = createVariant(state, 'type', [
 *     { type: { literal: literal('EMAIL') }, email: { required, email } },
 *     { type: { literal: literal('GITHUB') }, username: { required } },
 *     { type: { required } }, // Default case
 *   ]);
 *
 *   return {
 *     ...variant.value,
 *   };
 * });
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/variants Documentation}
 */
declare function createVariant<TForm extends Record<string, any>, TDiscriminant extends keyof JoinDiscriminatedUnions<TForm>, TVariants extends VariantTuple<JoinDiscriminatedUnions<TForm>, TDiscriminant>>(root: MaybeRefOrGetter<TForm> | DeepReactiveState<TForm>, discriminantKey: TDiscriminant, variants: [...TVariants]): Ref<TVariants[number]>;
/**
 * Type guard to narrow a variant field to a specific discriminated value.
 * Enables type-safe access to variant-specific fields.
 *
 * @param root - The Regle status object
 * @param discriminantKey - The key used to discriminate between variants
 * @param discriminantValue - The specific value to narrow to
 * @returns `true` if the discriminant matches, with TypeScript narrowing the type
 *
 * @example
 * ```ts
 * import { narrowVariant } from '@regle/core';
 *
 * if (narrowVariant(r$, 'type', 'EMAIL')) {
 *   // TypeScript knows r$.email exists here
 *   r$.email.$value = 'user@example.com';
 * }
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/variants Documentation}
 */
declare function narrowVariant<TRoot extends {
  [x: string]: unknown;
  $fields: {
    [x: string]: unknown;
  };
  $value: unknown;
}, const TKey extends keyof Omit<NonNullable<TRoot>, `$${string}` | `~${string}`>, const TValue extends (LazyJoinDiscriminatedUnions<Exclude<NonNullable<TRoot>[TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
  $value: infer V;
} ? V : unknown)>(root: TRoot | undefined, discriminantKey: TKey, discriminantValue: TValue): root is NarrowVariant<NonNullable<TRoot>, TKey, TValue>;
/**
 * Create a reactive reference to a narrowed variant.
 * Useful in templates or when you need a stable ref to the narrowed type.
 *
 * @param root - The Regle status object (can be a ref)
 * @param discriminantKey - The key used to discriminate between variants
 * @param discriminantValue - The specific value to narrow to
 * @param options - Optional `{ unsafeAssertion: true }` to assert the variant always exists
 * @returns A ref containing the narrowed variant (or undefined if not matching)
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { variantToRef } from '@regle/core';
 *
 * const emailR$ = variantToRef(r$, 'type', 'EMAIL');
 *
 * // In template:
 * // <input v-if="emailR$" v-model="emailR$.$value.email" />
 * </script>
 * ```
 *
 * @see {@link https://reglejs.dev/advanced-usage/variants Documentation}
 */
declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey extends keyof TRoot['$fields'], const TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
  $value: infer V;
} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey, discriminantValue: TValue, options: {
  /**
   * Assert that the variant is always defined, use with caution
   */
  unsafeAssertion: true;
}): Ref<NarrowVariant<TRoot, TKey, TValue>>;
declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey extends keyof TRoot['$fields'], const TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
  $value: infer V;
} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey, discriminantValue: TValue): Ref<NarrowVariant<TRoot, TKey, TValue> | undefined>;
/**
 * Helper method to wrap a raw rules object with type inference.
 * Provides autocomplete and type-checking without processing.
 *
 * @param rules - The rules object to wrap
 * @returns The same rules object (passthrough)
 *
 * @example
 * ```ts
 * import { defineRules } from '@regle/core';
 * import { required, string } from '@regle/rules';
 *
 * // defineRules helps catch structure errors
 * const rules = defineRules({
 *   firstName: { required, string },
 *   lastName: { required, string }
 * });
 * ```
 *
 * @see {@link https://reglejs.dev/common-usage/standard-schema Documentation}
 */
declare function defineRules<TRules extends RegleUnknownRulesTree>(rules: TRules): TRules;
/**
 * Refine a rules object to add rules that depend on the state values.
 * Inspired by Zod's `refine`, this allows writing dynamic rules while maintaining type safety.
 *
 * @param rules - The base rules object
 * @param refinement - A function that receives the typed state and returns additional rules
 * @returns A function that, given the state ref, returns the merged rules
 *
 * @example
 * ```ts
 * import { refineRules, type InferInput } from '@regle/core';
 * import { required, string, sameAs } from '@regle/rules';
 *
 * const rules = refineRules({
 *   password: { required, string },
 * }, (state) => ({
 *   // state is typed based on the base rules
 *   confirmPassword: {
 *     required,
 *     sameAs: sameAs(() => state.value.password)
 *   }
 * }));
 *
 * type State = InferInput<typeof rules>;
 * // { password: string; confirmPassword: string }
 * ```
 *
 * @see {@link https://reglejs.dev/common-usage/standard-schema#refinerules Documentation}
 */
declare function refineRules<TRules extends RegleUnknownRulesTree, TRefinement extends ReglePartialRuleTree<InferInput<TRules>> & RegleUnknownRulesTree>(rules: TRules, refinement: (state: Ref<InferInput<TRules>>) => TRefinement): (state: Ref<InferInput<TRules>>) => Merge<TRules, TRefinement>;
/**
 * Checks if a value is a Regle instance (`r$`).
 * Useful for integrations (e.g. Pinia) that need to identify Regle objects.
 */
declare function isRegleInstance(value: unknown): boolean;
/**
 * Vue plugin to enable Regle devtools integration with Vue Devtools.
 * Provides debugging capabilities for inspecting validation trees, states, and actions.
 *
 * Supports inspection of: `useRegle`, `useRules`, `useRegleSchema`, `useScopedRegle`, `useScopedRegleSchema`.
 *
 * Note: If using `@regle/nuxt`, devtools are automatically enabled.
 *
 * @example
 * ```ts
 * // main.ts
 * import { createApp } from 'vue';
 * import { RegleVuePlugin } from '@regle/core';
 * import App from './App.vue';
 *
 * const app = createApp(App);
 * app.use(RegleVuePlugin);
 * app.mount('#app');
 * ```
 *
 * @see {@link https://reglejs.dev/introduction/devtools Documentation}
 */
declare const RegleVuePlugin: Plugin;
export { type $InternalRegleStatus, type AllRulesDeclarations, type ArrayElement, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type CustomCollectionProperties, type CustomFieldProperties, type CustomNestedProperties, type CustomRules, type DeepMaybeRef, type DeepPartial, type DeepReactiveState, type DefaultValidatorsTree, type DumbJoinDiscriminatedUnions, type ExtendedRulesDeclarations, type ExtendedRulesDeclarationsOverrides, type FormRuleDeclaration, type GlobalConfigOverrides, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferOutput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleSettings, type InferRegleShortcuts, type InferRegleStatusType, type InferRegleValidationResult, type InferSafeOutput, type InferValidOutput, type InlineRuleDeclaration, InternalRuleType, type IsRegleStatic, type JoinDiscriminatedUnions, type LazyJoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NarrowVariantExtracts, type NarrowVariantFieldExtracts, type NoInferLegacy, type NonEmptyTuple, type ParamsToLooseParams, type Prettify, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, type RegleLike, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionLight, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleRuleWithParamsDefinitionInput, type RegleShortcutDefinition, type RegleSingleField, type RegleStatic, type RegleStaticImpl, type RegleStatus, type RegleUniversalParams, type RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, RegleVuePlugin, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type TupleToPlainObj, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UnwrapStatic, type UrlOptions, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRegleOptions, defineRules, extendRegleConfig, flatErrors, getErrors, getIssues, inferRules, type inferRulesFn, type isEditedHandlerFn, isRegleInstance, markStatic, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useRules, type useRulesFn, useScopedRegle, type useScopedRegleFn, variantToRef };