@4riders/reform 3.0.24

package/src/yop/decorators/file.ts

@@ -0,0 +1,69 @@
+import { CommonConstraints, validateTypeConstraint } from "../constraints/CommonConstraints"
+import { MinMaxConstraints, validateMinMaxConstraints } from "../constraints/MinMaxConstraints"
+import { TestConstraint, validateTestConstraint } from "../constraints/TestConstraint"
+import { isFile, isNumber } from "../TypesUtil"
+import { InternalValidationContext } from "../ValidationContext"
+import { fieldValidationDecorator, Groups } from "../Metadata"
+
+/**
+ * Type for a file value, which can be a File object, null, or undefined.
+ * @ignore
+ */
+export type FileValue = File | null | undefined
+
+/**
+ * Interface for file field constraints, combining common, min/max, and test constraints.
+ * @template Value - The type of the file value.
+ * @template Parent - The type of the parent object.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export interface FileConstraints<Value extends FileValue, Parent> extends
+    CommonConstraints<Value, Parent>,
+    MinMaxConstraints<Value, number, Parent>,
+    TestConstraint<Value, Parent> {
+}
+
+/**
+ * Validates a file field against its constraints.
+ * @template Value - The type of the file value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The file constraints to validate.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+function validateFile<Value extends FileValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: FileConstraints<Value, Parent>) {
+    return (
+        validateTypeConstraint(context, isFile, "file") &&
+        validateMinMaxConstraints(context, constraints, isNumber, (value, min) => value.size >= min, (value, max) => value.size <= max) &&
+        validateTestConstraint(context, constraints)
+    )
+}
+
+/**
+ * Decorator for applying validation rules to a File field.
+ * 
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠file({ required: true, min: [1024, "Picture size must be at least 1KB"] })
+ *     profilePicture: File | null = null
+ * }
+ * const form = useForm(Person, ...)
+ * 
+ * // the file decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(null, file({ required: true })) // error: "Required field"
+ * ```
+ * @template Value - The type of the file value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The file constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export function file<Value extends FileValue, Parent>(constraints?: FileConstraints<Value, Parent>, groups?: Groups<FileConstraints<Value, Parent>>) {
+    return fieldValidationDecorator("file", constraints ?? {}, groups, validateFile, isNumber)
+}

package/src/yop/decorators/id.ts

@@ -0,0 +1,35 @@
+import { Constructor } from "../TypesUtil"
+import { Yop } from "../Yop"
+import { ArrayConstraints } from "./array"
+import { InstanceConstraints } from "./instance"
+
+/**
+ * Class decorator to register a class with a unique identifier in the Yop registry. It can be used when you need to reference
+ * classes by an identifier to prevent circular references.
+ * 
+ * Example usage:
+ * ```tsx
+ * ＠id("Person")
+ * class Person {
+ * 
+ *    ＠instance({ of: "Person" }) // circular reference to itself using the class id
+ *    friend: Person | null = null
+ * 
+ *    ＠array({ of: "Person" }) // circular reference to itself using the class id
+ *    friends: Person[] | null = null
+ * }
+ * ```
+ * 
+ * @template Type - The type of the class instance.
+ * @template Class - The constructor type of the class.
+ * @param id - The unique identifier for the class.
+ * @returns A class decorator function that registers the class in the Yop registry.
+ * @see {@link InstanceConstraints}
+ * @see {@link ArrayConstraints}
+ * @category Class Decorators
+ */
+export function id<Type extends object, Class extends Constructor<Type>>(id: string) {
+    return function decorateClass(target: Class, _: ClassDecoratorContext<Class>) {
+        Yop.registerClass(id, target)
+    }
+}

package/src/yop/decorators/ignored.ts

@@ -0,0 +1,40 @@
+import { InternalCommonConstraints } from "../constraints/CommonConstraints"
+import { Constraint } from "../constraints/Constraint"
+import { fieldDecorator, Groups } from "../Metadata"
+
+/**
+ * Field decorator to mark a field as ignored for validation.
+ * 
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠string({ required: true, match: /^[A-Za-z]+$/ })
+ *     name: string | null = null
+ * }
+ * class Anonymous extends Person {
+ *     ＠ignored() // ignore all validation constraints on `name`
+ *     override name: string | null = null
+ * }
+ * ```
+ * 
+ * @template Parent - The type of the parent object.
+ * @param ignored - The constraint or boolean indicating if the field should be ignored (default: true).
+ * @param groups - Optional groups with their own ignored constraints.
+ * @returns A field decorator function that marks a field as ignored for validation.
+ * @category Property Decorators
+ */
+export function ignored<Parent>(ignored: Constraint<any, boolean, Parent> = true, groups?: Groups<Constraint<any, boolean, Parent>>) {
+    return fieldDecorator<Parent, any>(field => {
+        field.ignored = ignored
+
+        if (groups != null) {
+            field.groups ??= {}
+            for (const [name, constraint] of Object.entries(groups)) {
+                if (field.groups?.[name] != null)
+                    field.groups[name].ignored = constraint
+                else
+                    field.groups[name] = { ignored: constraint } as InternalCommonConstraints
+            }
+        }
+    })
+}

package/src/yop/decorators/instance.ts

@@ -0,0 +1,110 @@
+import { CommonConstraints, InternalCommonConstraints, validateTypeConstraint } from "../constraints/CommonConstraints"
+import { TestConstraint, validateTestConstraint } from "../constraints/TestConstraint"
+import { fieldValidationDecorator, Groups, InternalClassConstraints, validateClass } from "../Metadata"
+import { defineLazyProperty } from "../ObjectsUtil"
+import { ClassConstructor, isObject } from "../TypesUtil"
+import { InternalValidationContext } from "../ValidationContext"
+import { validationSymbol, Yop } from "../Yop"
+import { id } from "./id"
+
+/**
+ * Type for values that can be validated as instances (objects, null, or undefined).
+ * @ignore
+ */
+export type InstanceValue = object | null | undefined
+
+
+/**
+ * Constraints for validating an instance of a class. Inherits common and test constraints.
+ * @template Value - The type of the instance value.
+ * @template Parent - The type of the parent object.
+ * @property of - A class constructor, a function returning a constructor, or a class id to validate the instance against.
+ * @see {@link id}
+ * @see {@link CommonConstraints}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export interface InstanceConstraints<Value extends InstanceValue, Parent> extends
+    CommonConstraints<Value, Parent>,
+    TestConstraint<Value, Parent> {
+    /**
+     * A class constructor, a function returning a constructor, or a class id (see {@link id}) to validate the instance against.
+     */
+    of: ClassConstructor<NoInfer<Value>> | (() => ClassConstructor<NoInfer<Value>>) | string
+}
+
+/**
+ * Traverses the constraints of a class instance for validation.
+ * @param context - The validation context.
+ * @param constraints - The instance constraints.
+ * @param key - The property key to traverse.
+ * @param traverseNullish - Whether to traverse nullish values.
+ * @returns A tuple of the internal constraints and the value.
+ * @ignore
+ */
+function traverseInstance<Value extends InstanceValue, Parent>(
+    context: InternalValidationContext<Value, Parent>,
+    constraints: InstanceConstraints<Value, Parent>,
+    key: string | number,
+    traverseNullish?: boolean
+): readonly [InternalCommonConstraints | undefined, any] {
+    if (constraints.of == null)
+        return [undefined, undefined] as const
+    const classConstraints = (constraints.of as any)[Symbol.metadata]?.[validationSymbol] as InternalClassConstraints | undefined
+    if (classConstraints == null)
+        return [undefined, undefined] as const
+    return classConstraints.traverse!(context as InternalValidationContext<never, never>, classConstraints, key, traverseNullish)
+}
+
+/**
+ * Validates that a value is an instance of the specified class and meets all constraints.
+ * @param context - The validation context.
+ * @param constraints - The instance constraints.
+ * @returns True if valid, false otherwise.
+ * @ignore
+ */
+function validateInstance<Value extends InstanceValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: InstanceConstraints<Value, Parent>) {
+    if (!validateTypeConstraint(context, isObject, "object") ||
+        !validateTestConstraint(context, constraints) ||
+        constraints.of == null)
+        return false
+
+    const classConstraints = (constraints.of as any)[Symbol.metadata]?.[validationSymbol] as InternalClassConstraints | undefined
+    return classConstraints == null || validateClass(context as InternalValidationContext<{ [x: string]: any }>, classConstraints)
+}
+
+/**
+ * The kind string used to identify instance constraints.
+ * @ignore
+ */
+export const instanceKind = "instance"
+
+/**
+ * Decorator for validating a field value as an instance of a specified class. The `of` property must be set to a custom
+ * class constructor, not a built-in object type like String or Date.
+ * 
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠instance({ of: Dog, required: true })
+ *     dog: Dog | null = null
+ * }
+ * const form = useForm(Person, ...)
+ * 
+ * // the instance decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(new Person(), instance({ of: Person })) // error: dog is a "Required field"
+ * ```
+ * @template Value - The type of the instance value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The instance constraints.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator that stores the instance constraints and validation function in the class metadata.
+ * @category Property Decorators
+ */
+export function instance<Value extends InstanceValue, Parent>(constraints?: InstanceConstraints<Value, Parent>, groups?: Groups<InstanceConstraints<Value, Parent>>) {
+    if (typeof constraints?.of === "string" || (typeof constraints?.of === "function" && constraints.of.prototype == null)) {
+        const of = constraints.of
+        defineLazyProperty(constraints, "of", (_this) => Yop.resolveClass(of))
+    }
+    return fieldValidationDecorator(instanceKind, constraints ?? ({} as InstanceConstraints<Value, Parent>), groups, validateInstance, undefined, traverseInstance)
+}

package/src/yop/decorators/number.ts

@@ -0,0 +1,73 @@
+import { CommonConstraints, validateTypeConstraint } from "../constraints/CommonConstraints"
+import { MinMaxConstraints, validateMinMaxConstraints } from "../constraints/MinMaxConstraints"
+import { OneOfConstraint, validateOneOfConstraint } from "../constraints/OneOfConstraint"
+import { TestConstraint, validateTestConstraint } from "../constraints/TestConstraint"
+import { isNumber, isNumberArray } from "../TypesUtil"
+import { InternalValidationContext } from "../ValidationContext"
+import { fieldValidationDecorator, Groups } from "../Metadata"
+
+/**
+ * Type for a number value, which can be a number, null, or undefined.
+ * @ignore
+ */
+export type NumberValue = number | null | undefined
+
+/**
+ * Interface for number field constraints, combining common, min/max, oneOf, and test constraints.
+ * @template Value - The type of the number value.
+ * @template Parent - The type of the parent object.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export interface NumberConstraints<Value extends NumberValue, Parent> extends
+    CommonConstraints<Value, Parent>,
+    MinMaxConstraints<Value, number, Parent>,
+    OneOfConstraint<Value, Parent>,
+    TestConstraint<Value, Parent> {
+}
+
+/**
+ * Validates a number field against its constraints.
+ * @template Value - The type of the number value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The number constraints to validate.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+function validateNumber<Value extends NumberValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: NumberConstraints<Value, Parent>) {
+    return (
+        validateTypeConstraint(context, isNumber, "number") &&
+        validateMinMaxConstraints(context, constraints, isNumber, (value, min) => value >= min, (value, max) => value <= max) &&
+        validateOneOfConstraint(context, constraints, isNumberArray) &&
+        validateTestConstraint(context, constraints)
+    )
+}
+
+/**
+ * Decorator for applying validation rules to a number field.
+ * 
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠number({ required: true, min: 0 })
+ *     age: number | null = null
+ * }
+ * const form = useForm(Person, ...)
+ * 
+ * // the number decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(-1, number({ required: true, min: 0 })) // error: "Must be greater or equal to 0"
+ * ```
+ * @template Value - The type of the number value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The number constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export function number<Value extends NumberValue, Parent>(constraints?: NumberConstraints<Value, Parent>, groups?: Groups<NumberConstraints<Value, Parent>>) {
+    return fieldValidationDecorator("number", constraints ?? {}, groups, validateNumber, isNumber)
+}

package/src/yop/decorators/string.ts

@@ -0,0 +1,90 @@
+import { CommonConstraints, validateTypeConstraint } from "../constraints/CommonConstraints"
+import { Constraint, Message, validateConstraint } from "../constraints/Constraint"
+import { MinMaxConstraints, validateMinMaxConstraints } from "../constraints/MinMaxConstraints"
+import { OneOfConstraint, validateOneOfConstraint } from "../constraints/OneOfConstraint"
+import { TestConstraint, validateTestConstraint } from "../constraints/TestConstraint"
+import { isNumber, isRegExp, isString, isStringArray } from "../TypesUtil"
+import { InternalValidationContext, ValuedContext } from "../ValidationContext"
+import { fieldValidationDecorator, Groups } from "../Metadata"
+
+/**
+ * Type for a string value, which can be a string, null, or undefined.
+ * @ignore
+ */
+export type StringValue = string | null | undefined
+
+/**
+ * Interface for string field constraints, combining common, min/max, oneOf, test, and match constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @property match - Constraint for matching a regular expression.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export interface StringConstraints<Value extends StringValue, Parent> extends
+    CommonConstraints<Value, Parent>,
+    MinMaxConstraints<Value, number, Parent>,
+    OneOfConstraint<Value, Parent>,
+    TestConstraint<Value, Parent> {
+    /**
+     * Constraint for matching a regular expression. The constraint value can be a RegExp, a function that returns a RegExp.
+     */
+    match?: Constraint<NonNullable<Value>, RegExp, Parent>
+}
+
+/**
+ * Validates a string field against its constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The string constraints to validate.
+ * @param defaultRegexp - Optional default regular expression for matching.
+ * @param defaultMatchMessage - Optional default error message for match failures.
+ * @param type - Optional type name for error reporting.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+export function validateString<Value extends StringValue, Parent>(
+    context: InternalValidationContext<Value, Parent>,
+    constraints: StringConstraints<Value, Parent>,
+    defaultRegexp?: RegExp,
+    defaultMatchMessage?: Message<Value, Parent>,
+    type?: string
+) {
+    return (
+        validateTypeConstraint(context, isString, type ?? "string") &&
+        validateMinMaxConstraints(context, constraints, isNumber, (value, min) => value.length >= min, (value, max) => value.length <= max) &&
+        validateConstraint(context as ValuedContext<Value, Parent>, constraints, "match", isRegExp, (value, re) => re.test(value), defaultRegexp, defaultMatchMessage) &&
+        validateOneOfConstraint(context, constraints, isStringArray) &&
+        validateTestConstraint(context, constraints)
+    )
+}
+
+/**
+ * Decorator for applying validation rules to a string field. A required string field can be an empty string, but neither `null` nor `undefined`.
+ * To enforce non-empty strings, use the `min` constraint with a value of 1.
+ * 
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠string({ required: true, min: 1 })
+ *     name: string | null = null
+ * }
+ * const form = useForm(Person, ...)
+ * 
+ * // the string decorator can also be used as a function to allow standalone validation:
+ * Yop.validate("", string({ required: true, min: 1 })) // error: "Minimum 1 character"
+ * ```
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The string constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export function string<Value extends StringValue, Parent>(constraints?: StringConstraints<Value, Parent>, groups?: Groups<StringConstraints<Value, Parent>>) {
+    return fieldValidationDecorator("string", constraints ?? {}, groups, validateString, isNumber)
+}

package/src/yop/decorators/test.ts

@@ -0,0 +1,41 @@
+import { TestConstraintFunction } from "../constraints/TestConstraint"
+import { initClassConstraints } from "../Metadata"
+import { Constructor } from "../TypesUtil"
+
+/**
+ * Utility type to extract the instance type from a constructor.
+ * @template Class - The constructor type.
+ * @category Class Decorators
+ */
+export type InstanceType<Class> = Class extends Constructor<infer Type> ? Type : never
+
+/**
+ * Class decorator to add a test constraint function to a class for validation. The test function will be called with the
+ * class instance after all field validations have passed, allowing for complex custom validation logic that depends on 
+ * the entire object state.
+ * 
+ * Example usage:
+ * ```tsx
+ * ＠test(credentials => credentials.password === credentials.confirmPassword ? true : "Passwords do not match")
+ * class Credentials {
+ *     ＠string({ required: true, min: 8 })
+ *     username: string | null = null
+ *     ＠string({ required: true, min: 8, test: checkPasswordStrength })
+ *     password: string | null = null
+ *     ＠string({ required: true, min: 8 })
+ *     confirmPassword: string | null = null
+ * }
+ * const form = useForm(Credentials, ...)
+ * ```
+ * @template Class - The constructor type of the class.
+ * @param test - The test constraint function to apply to the class instance.
+ * @returns A class decorator function that sets the test constraint.
+ * @see {@link TestConstraintFunction}
+ * @category Class Decorators
+ */
+export function test<Class extends Constructor>(test: TestConstraintFunction<InstanceType<Class>>) {
+    return function decorateClass(_: Class, context: ClassDecoratorContext<Class>) {
+        const classConstraints = initClassConstraints(context.metadata)
+        classConstraints.test = test
+    }
+}

package/src/yop/decorators/time.ts

@@ -0,0 +1,112 @@
+import { InternalValidationContext } from "../ValidationContext"
+import { fieldValidationDecorator, Groups } from "../Metadata"
+import { StringValue } from "./string"
+import { MinMaxConstraints, validateMinMaxConstraints } from "../constraints/MinMaxConstraints"
+import { CommonConstraints, validateTypeConstraint } from "../constraints/CommonConstraints"
+import { isFunction, isString, isStringArray } from "../TypesUtil"
+import { OneOfConstraint, validateOneOfConstraint } from "../constraints/OneOfConstraint"
+import { TestConstraint, validateTestConstraint } from "../constraints/TestConstraint"
+import { Message } from "../constraints/Constraint"
+
+/**
+ * Interface for time field constraints, combining common, min/max, oneOf, and test constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @property formatError - Optional custom error message for invalid time format.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export interface TimeConstraints<Value extends StringValue, Parent> extends
+    CommonConstraints<Value, Parent>,
+    MinMaxConstraints<Value, string, Parent>,
+    OneOfConstraint<Value, Parent>,
+    TestConstraint<Value, Parent> {
+    /**
+     * Optional custom error message for invalid time format. `formatError` can be a {@link Message} or a function that returns a {@link Message}.
+     * @see {@link timeRegex}
+     */
+    formatError?: Message<Value, Parent>
+}
+
+/**
+ * Regular expression for validating time strings in the format HH:mm[:ss[.sss]].
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Date_and_time_formats#time_strings
+ * @ignore
+ */
+export const timeRegex = /^([01][0-9]|2[0-3]):([0-5][0-9])(?::([0-5][0-9])(?:\.([0-9]{1,3}))?)?$/
+
+/**
+ * Converts a time string (HH:mm[:ss[.sss]]) to milliseconds since midnight.
+ * @param time - The time string to convert.
+ * @returns The number of milliseconds since midnight, or undefined if invalid.
+ * @ignore
+ */
+export function timeToMillis(time: string) {
+    const matches = timeRegex.exec(time)
+    return (
+        matches != null ?
+        (+matches[1] * 3600 * 1000) + (+matches[2] * 60 * 1000) + (+(matches[3] ?? 0) * 1000) + (+(matches[4] ?? 0)) :
+        undefined
+    )
+}
+
+/**
+ * Maximum number of milliseconds in a day (23:59:59.999).
+ * @ignore
+ */
+const MAX_MILLIS = (24 * 3600 * 1000) - 1
+
+/**
+ * Validates a time field against its constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The time constraints to validate.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+export function validateTime<Value extends StringValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: TimeConstraints<Value, Parent>) {
+    if (!validateTypeConstraint(context, isString, "time"))
+        return false
+    
+    const millis = timeToMillis(context.value!)
+    if (millis == null) {
+        const message = isFunction(constraints.formatError) ? constraints.formatError(context) : constraints.formatError
+        return context.setStatus("match", timeRegex, message) == null
+    }
+
+    return (
+        validateMinMaxConstraints(context, constraints, isString, (_, min) => millis >= (timeToMillis(min) ?? 0), (_, max) => millis <= (timeToMillis(max) ?? MAX_MILLIS)) &&
+        validateOneOfConstraint(context, constraints, isStringArray) &&
+        validateTestConstraint(context, constraints)
+    )
+}
+
+/**
+ * Decorator for applying validation rules to a time field. A valid time value must be a string in the format HH:mm[:ss[.sss]] (24-hour clock).
+ * 
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠time({ required: true, formatError: "Invalid wake up time format", max: "18:00" })
+ *     wakeUpTime: string | null = null
+ * }
+ * const form = useForm(Person, ...)
+ * 
+ * // the time decorator can also be used as a function to allow standalone validation:
+ * Yop.validate("00:00", time({ min: "01:00" })) // error: "Must be after or equal to 01:00"
+ * ```
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The time constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Date_and_time_formats#time_strings
+ * @category Property Decorators
+ */
+export function time<Value extends StringValue, Parent>(constraints?: TimeConstraints<Value, Parent>, groups?: Groups<TimeConstraints<Value, Parent>>) {
+    return fieldValidationDecorator("time", constraints ?? {}, groups, validateTime, isString)
+}