@hy_ong/zod-kit 0.2.0 → 0.2.1

package/dist/common/text.d.cts

@@ -0,0 +1,156 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+/**
+ * @fileoverview Text validator for Zod Kit
+ *
+ * Provides comprehensive text validation with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for text validation error messages
+ *
+ * @interface TextMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [notEmpty] - Message when field must not be empty (whitespace-only)
+ * @property {string} [minLength] - Message when text is shorter than minimum length
+ * @property {string} [maxLength] - Message when text exceeds maximum length
+ * @property {string} [startsWith] - Message when text doesn't start with required string
+ * @property {string} [endsWith] - Message when text doesn't end with required string
+ * @property {string} [includes] - Message when text doesn't contain required string
+ * @property {string} [excludes] - Message when text contains forbidden string
+ * @property {string} [invalid] - Message when text doesn't match regex pattern
+ */
+type TextMessages = {
+    required?: string;
+    notEmpty?: string;
+    minLength?: string;
+    maxLength?: string;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string;
+    invalid?: string;
+};
+/**
+ * Configuration options for text validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface TextOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {number} [minLength] - Minimum length of text
+ * @property {number} [maxLength] - Maximum length of text
+ * @property {string} [startsWith] - String that text must start with
+ * @property {string} [endsWith] - String that text must end with
+ * @property {string} [includes] - String that must be included in text
+ * @property {string | string[]} [excludes] - String(s) that must not be included
+ * @property {RegExp} [regex] - Regular expression pattern for validation
+ * @property {"trim" | "trimStart" | "trimEnd" | "none"} [trimMode="trim"] - Whitespace handling
+ * @property {"upper" | "lower" | "title" | "none"} [casing="none"] - Case transformation
+ * @property {Function} [transform] - Custom transformation function for text
+ * @property {boolean} [notEmpty] - Whether to reject whitespace-only strings
+ * @property {string | null} [defaultValue] - Default value when input is empty
+ * @property {Record<Locale, TextMessages>} [i18n] - Custom error messages for different locales
+ */
+type TextOptions<IsRequired extends boolean = true> = {
+    minLength?: number;
+    maxLength?: number;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string | string[];
+    regex?: RegExp;
+    trimMode?: "trim" | "trimStart" | "trimEnd" | "none";
+    casing?: "upper" | "lower" | "title" | "none";
+    transform?: (value: string) => string;
+    notEmpty?: boolean;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<TextMessages>>>;
+};
+/**
+ * Type alias for text validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef TextSchema
+ * @description Returns ZodString if required, ZodNullable<ZodString> if optional
+ */
+type TextSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+/**
+ * Creates a Zod schema for text validation with comprehensive string processing
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {TextOptions<IsRequired>} [options] - Configuration options for text validation
+ * @returns {TextSchema<IsRequired>} Zod schema for text validation
+ *
+ * @description
+ * Creates a comprehensive text validator with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * Features:
+ * - Length validation (min/max)
+ * - Content validation (startsWith, endsWith, includes, excludes)
+ * - Regular expression pattern matching
+ * - Flexible trimming options (trim, trimStart, trimEnd, none)
+ * - Case transformation (upper, lower, title, none)
+ * - Empty string vs whitespace-only validation
+ * - Custom transformation functions
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic text validation (optional by default)
+ * const basicSchema = text()
+ * basicSchema.parse("Hello World") // ✓ Valid
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required text
+ * const requiredSchema = text(true)
+ * requiredSchema.parse("Hello") // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Length constraints
+ * const lengthSchema = text(true, { minLength: 3, maxLength: 50 })
+ * lengthSchema.parse("Hello") // ✓ Valid
+ * lengthSchema.parse("Hi") // ✗ Invalid (too short)
+ *
+ * // Content validation
+ * const contentSchema = text(true, {
+ *   startsWith: "Hello",
+ *   endsWith: "!",
+ *   includes: "World"
+ * })
+ * contentSchema.parse("Hello World!") // ✓ Valid
+ *
+ * // Case transformation
+ * const upperSchema = text(false, { casing: "upper" })
+ * upperSchema.parse("hello") // ✓ Valid (converted to "HELLO")
+ *
+ * // Trim modes
+ * const trimStartSchema = text(false, { trimMode: "trimStart" })
+ * trimStartSchema.parse("  hello  ") // ✓ Valid (result: "hello  ")
+ *
+ * // Regex validation
+ * const regexSchema = text(true, { regex: /^[a-zA-Z]+$/ })
+ * regexSchema.parse("hello") // ✓ Valid
+ * regexSchema.parse("hello123") // ✗ Invalid
+ *
+ * // Not empty (rejects whitespace-only)
+ * const notEmptySchema = text(true, { notEmpty: true })
+ * notEmptySchema.parse("hello") // ✓ Valid
+ * notEmptySchema.parse("   ") // ✗ Invalid
+ *
+ * // Optional with default
+ * const optionalSchema = text(false, { defaultValue: "default text" })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link TextOptions} for all available configuration options
+ */
+declare function text<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TextOptions<IsRequired>, 'required'>): TextSchema<IsRequired>;
+
+export { type TextMessages, type TextOptions, type TextSchema, text };

package/dist/common/text.d.ts

@@ -0,0 +1,156 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.js';
+
+/**
+ * @fileoverview Text validator for Zod Kit
+ *
+ * Provides comprehensive text validation with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for text validation error messages
+ *
+ * @interface TextMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [notEmpty] - Message when field must not be empty (whitespace-only)
+ * @property {string} [minLength] - Message when text is shorter than minimum length
+ * @property {string} [maxLength] - Message when text exceeds maximum length
+ * @property {string} [startsWith] - Message when text doesn't start with required string
+ * @property {string} [endsWith] - Message when text doesn't end with required string
+ * @property {string} [includes] - Message when text doesn't contain required string
+ * @property {string} [excludes] - Message when text contains forbidden string
+ * @property {string} [invalid] - Message when text doesn't match regex pattern
+ */
+type TextMessages = {
+    required?: string;
+    notEmpty?: string;
+    minLength?: string;
+    maxLength?: string;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string;
+    invalid?: string;
+};
+/**
+ * Configuration options for text validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface TextOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {number} [minLength] - Minimum length of text
+ * @property {number} [maxLength] - Maximum length of text
+ * @property {string} [startsWith] - String that text must start with
+ * @property {string} [endsWith] - String that text must end with
+ * @property {string} [includes] - String that must be included in text
+ * @property {string | string[]} [excludes] - String(s) that must not be included
+ * @property {RegExp} [regex] - Regular expression pattern for validation
+ * @property {"trim" | "trimStart" | "trimEnd" | "none"} [trimMode="trim"] - Whitespace handling
+ * @property {"upper" | "lower" | "title" | "none"} [casing="none"] - Case transformation
+ * @property {Function} [transform] - Custom transformation function for text
+ * @property {boolean} [notEmpty] - Whether to reject whitespace-only strings
+ * @property {string | null} [defaultValue] - Default value when input is empty
+ * @property {Record<Locale, TextMessages>} [i18n] - Custom error messages for different locales
+ */
+type TextOptions<IsRequired extends boolean = true> = {
+    minLength?: number;
+    maxLength?: number;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string | string[];
+    regex?: RegExp;
+    trimMode?: "trim" | "trimStart" | "trimEnd" | "none";
+    casing?: "upper" | "lower" | "title" | "none";
+    transform?: (value: string) => string;
+    notEmpty?: boolean;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<TextMessages>>>;
+};
+/**
+ * Type alias for text validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef TextSchema
+ * @description Returns ZodString if required, ZodNullable<ZodString> if optional
+ */
+type TextSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+/**
+ * Creates a Zod schema for text validation with comprehensive string processing
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {TextOptions<IsRequired>} [options] - Configuration options for text validation
+ * @returns {TextSchema<IsRequired>} Zod schema for text validation
+ *
+ * @description
+ * Creates a comprehensive text validator with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * Features:
+ * - Length validation (min/max)
+ * - Content validation (startsWith, endsWith, includes, excludes)
+ * - Regular expression pattern matching
+ * - Flexible trimming options (trim, trimStart, trimEnd, none)
+ * - Case transformation (upper, lower, title, none)
+ * - Empty string vs whitespace-only validation
+ * - Custom transformation functions
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic text validation (optional by default)
+ * const basicSchema = text()
+ * basicSchema.parse("Hello World") // ✓ Valid
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required text
+ * const requiredSchema = text(true)
+ * requiredSchema.parse("Hello") // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Length constraints
+ * const lengthSchema = text(true, { minLength: 3, maxLength: 50 })
+ * lengthSchema.parse("Hello") // ✓ Valid
+ * lengthSchema.parse("Hi") // ✗ Invalid (too short)
+ *
+ * // Content validation
+ * const contentSchema = text(true, {
+ *   startsWith: "Hello",
+ *   endsWith: "!",
+ *   includes: "World"
+ * })
+ * contentSchema.parse("Hello World!") // ✓ Valid
+ *
+ * // Case transformation
+ * const upperSchema = text(false, { casing: "upper" })
+ * upperSchema.parse("hello") // ✓ Valid (converted to "HELLO")
+ *
+ * // Trim modes
+ * const trimStartSchema = text(false, { trimMode: "trimStart" })
+ * trimStartSchema.parse("  hello  ") // ✓ Valid (result: "hello  ")
+ *
+ * // Regex validation
+ * const regexSchema = text(true, { regex: /^[a-zA-Z]+$/ })
+ * regexSchema.parse("hello") // ✓ Valid
+ * regexSchema.parse("hello123") // ✗ Invalid
+ *
+ * // Not empty (rejects whitespace-only)
+ * const notEmptySchema = text(true, { notEmpty: true })
+ * notEmptySchema.parse("hello") // ✓ Valid
+ * notEmptySchema.parse("   ") // ✗ Invalid
+ *
+ * // Optional with default
+ * const optionalSchema = text(false, { defaultValue: "default text" })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link TextOptions} for all available configuration options
+ */
+declare function text<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TextOptions<IsRequired>, 'required'>): TextSchema<IsRequired>;
+
+export { type TextMessages, type TextOptions, type TextSchema, text };

package/dist/common/text.js

@@ -0,0 +1,7 @@
+import {
+  text
+} from "../chunk-IJEEM3DI.js";
+import "../chunk-ZBOQCXD4.js";
+export {
+  text
+};

package/dist/common/time.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkVDOAPLA6cjs = require('../chunk-VDOAPLA6.cjs');
+require('../chunk-YWV2BBXN.cjs');
+
+
+
+
+
+
+exports.TIME_PATTERNS = _chunkVDOAPLA6cjs.TIME_PATTERNS; exports.normalizeTime = _chunkVDOAPLA6cjs.normalizeTime; exports.parseTimeToMinutes = _chunkVDOAPLA6cjs.parseTimeToMinutes; exports.time = _chunkVDOAPLA6cjs.time; exports.validateTimeFormat = _chunkVDOAPLA6cjs.validateTimeFormat;

package/dist/common/time.d.cts

@@ -0,0 +1,268 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+/**
+ * @fileoverview Time validator for Zod Kit
+ *
+ * Provides comprehensive time validation with support for multiple time formats,
+ * hour/minute constraints, and advanced time-based validation options.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for time validation error messages
+ *
+ * @interface TimeMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [invalid] - Message when time format is invalid
+ * @property {string} [format] - Message when time doesn't match expected format
+ * @property {string} [min] - Message when time is before minimum allowed
+ * @property {string} [max] - Message when time is after maximum allowed
+ * @property {string} [hour] - Message when hour is outside allowed range
+ * @property {string} [minute] - Message when minute doesn't match step requirement
+ * @property {string} [second] - Message when second doesn't match step requirement
+ * @property {string} [includes] - Message when time doesn't contain required string
+ * @property {string} [excludes] - Message when time contains forbidden string
+ * @property {string} [customRegex] - Message when custom regex validation fails
+ * @property {string} [notInWhitelist] - Message when value is not in whitelist
+ */
+type TimeMessages = {
+    required?: string;
+    invalid?: string;
+    format?: string;
+    min?: string;
+    max?: string;
+    hour?: string;
+    minute?: string;
+    second?: string;
+    includes?: string;
+    excludes?: string;
+    customRegex?: string;
+    notInWhitelist?: string;
+};
+/**
+ * Supported time formats for validation
+ *
+ * @typedef {string} TimeFormat
+ *
+ * Available formats:
+ * - HH:mm: 24-hour format with leading zeros (14:30, 09:30)
+ * - HH:mm:ss: 24-hour format with seconds (14:30:45, 09:30:15)
+ * - hh:mm A: 12-hour format with AM/PM (02:30 PM, 09:30 AM)
+ * - hh:mm:ss A: 12-hour format with seconds and AM/PM (02:30:45 PM)
+ * - H:mm: 24-hour format without leading zeros (14:30, 9:30)
+ * - h:mm A: 12-hour format without leading zeros (2:30 PM, 9:30 AM)
+ */
+type TimeFormat = "HH:mm" | "HH:mm:ss" | "hh:mm A" | "hh:mm:ss A" | "H:mm" | "h:mm A";
+/**
+ * Configuration options for time validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface TimeOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {TimeFormat} [format="HH:mm"] - Expected time format
+ * @property {string} [min] - Minimum allowed time (e.g., "09:00")
+ * @property {string} [max] - Maximum allowed time (e.g., "17:00")
+ * @property {number} [minHour] - Minimum allowed hour (0-23)
+ * @property {number} [maxHour] - Maximum allowed hour (0-23)
+ * @property {number[]} [allowedHours] - Specific hours that are allowed
+ * @property {number} [minuteStep] - Required minute intervals (e.g., 15 for :00, :15, :30, :45)
+ * @property {number} [secondStep] - Required second intervals
+ * @property {string} [includes] - String that must be included in the time
+ * @property {string | string[]} [excludes] - String(s) that must not be included
+ * @property {RegExp} [regex] - Custom regex for validation (overrides format validation)
+ * @property {"trim" | "trimStart" | "trimEnd" | "none"} [trimMode="trim"] - Whitespace handling
+ * @property {"upper" | "lower" | "none"} [casing="none"] - Case transformation
+ * @property {string[]} [whitelist] - Specific time strings that are always allowed
+ * @property {boolean} [whitelistOnly=false] - If true, only values in whitelist are allowed
+ * @property {Function} [transform] - Custom transformation function applied before validation
+ * @property {string | null} [defaultValue] - Default value when input is empty
+ * @property {Record<Locale, TimeMessages>} [i18n] - Custom error messages for different locales
+ */
+type TimeOptions<IsRequired extends boolean = true> = {
+    format?: TimeFormat;
+    min?: string;
+    max?: string;
+    minHour?: number;
+    maxHour?: number;
+    allowedHours?: number[];
+    minuteStep?: number;
+    secondStep?: number;
+    includes?: string;
+    excludes?: string | string[];
+    regex?: RegExp;
+    trimMode?: "trim" | "trimStart" | "trimEnd" | "none";
+    casing?: "upper" | "lower" | "none";
+    whitelist?: string[];
+    whitelistOnly?: boolean;
+    transform?: (value: string) => string;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<TimeMessages>>>;
+};
+/**
+ * Type alias for time validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef TimeSchema
+ * @description Returns ZodString if required, ZodNullable<ZodString> if optional
+ */
+type TimeSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+/**
+ * Regular expression patterns for time format validation
+ *
+ * @constant {Record<TimeFormat, RegExp>} TIME_PATTERNS
+ * @description Maps each supported time format to its corresponding regex pattern
+ */
+declare const TIME_PATTERNS: Record<TimeFormat, RegExp>;
+/**
+ * Parses a time string to minutes since midnight for comparison
+ *
+ * @param {string} timeStr - The time string to parse
+ * @param {TimeFormat} format - The expected time format
+ * @returns {number | null} Minutes since midnight (0-1439) or null if parsing fails
+ *
+ * @description
+ * Converts time strings to minutes since midnight for easy comparison and validation.
+ * Handles both 12-hour and 24-hour formats with proper AM/PM conversion.
+ *
+ * @example
+ * ```typescript
+ * parseTimeToMinutes("14:30", "HH:mm") // 870 (14*60 + 30)
+ * parseTimeToMinutes("2:30 PM", "h:mm A") // 870 (14*60 + 30)
+ * parseTimeToMinutes("12:00 AM", "hh:mm A") // 0 (midnight)
+ * parseTimeToMinutes("12:00 PM", "hh:mm A") // 720 (noon)
+ * ```
+ */
+declare const parseTimeToMinutes: (timeStr: string, format: TimeFormat) => number | null;
+/**
+ * Validates if a time string matches the specified format pattern
+ *
+ * @param {string} value - The time string to validate
+ * @param {TimeFormat} format - The expected time format
+ * @returns {boolean} True if the time matches the format pattern
+ *
+ * @description
+ * Performs regex pattern matching to validate time format.
+ * Does not validate actual time values (e.g., 25:00 would pass pattern but fail logic).
+ *
+ * @example
+ * ```typescript
+ * validateTimeFormat("14:30", "HH:mm") // true
+ * validateTimeFormat("2:30 PM", "h:mm A") // true
+ * validateTimeFormat("25:00", "HH:mm") // true (pattern matches)
+ * validateTimeFormat("14:30", "h:mm A") // false (wrong format)
+ * ```
+ */
+declare const validateTimeFormat: (value: string, format: TimeFormat) => boolean;
+/**
+ * Normalizes time to 24-hour format for internal processing
+ *
+ * @param {string} timeStr - The time string to normalize
+ * @param {TimeFormat} format - The current time format
+ * @returns {string | null} Normalized time string or null if parsing fails
+ *
+ * @description
+ * Converts time strings to a standardized 24-hour format for consistent processing.
+ * Handles AM/PM conversion and leading zero normalization.
+ *
+ * @example
+ * ```typescript
+ * normalizeTime("2:30 PM", "h:mm A") // "14:30"
+ * normalizeTime("12:00 AM", "hh:mm A") // "00:00"
+ * normalizeTime("9:30", "H:mm") // "09:30"
+ * normalizeTime("14:30:45", "HH:mm:ss") // "14:30:45"
+ * ```
+ */
+declare const normalizeTime: (timeStr: string, format: TimeFormat) => string | null;
+/**
+ * Creates a Zod schema for time validation with comprehensive options
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {IsRequired} [required=false] - Whether the field is required
+ * @param {Omit<ValidatorOptions<IsRequired>, 'required'>} [options] - Configuration options for validation
+ * @returns {TimeSchema<IsRequired>} Zod schema for time validation
+ *
+ * @description
+ * Creates a comprehensive time validator that supports multiple time formats,
+ * hour/minute constraints, step validation, and extensive customization options.
+ *
+ * Features:
+ * - Multiple time formats (24-hour, 12-hour, with/without seconds)
+ * - Time range validation (min/max)
+ * - Hour and minute constraints
+ * - Step validation (e.g., 15-minute intervals)
+ * - Whitelist/blacklist support
+ * - Custom regex patterns
+ * - String transformation and case handling
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic time validation (24-hour format)
+ * const basicSchema = time()
+ * basicSchema.parse("14:30") // ✓ Valid
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required validation
+ * const requiredSchema = parse("14:30") // ✓ Valid
+(true)
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * basicSchema.parse("2:30 PM") // ✗ Invalid (wrong format)
+ *
+ * // 12-hour format with AM/PM
+ * const ampmSchema = time(false, { format: "hh:mm A" })
+ * ampmSchema.parse("02:30 PM") // ✓ Valid
+ * ampmSchema.parse("14:30") // ✗ Invalid (wrong format)
+ *
+ * // Business hours validation
+ * const businessHours = time({
+ *   format: "HH:mm",
+ *   minHour: 9,
+ *   maxHour: 17,
+ *   minuteStep: 15 // Only :00, :15, :30, :45
+ * })
+ * businessHours.parse("09:15") // ✓ Valid
+ * businessHours.parse("18:00") // ✗ Invalid (after maxHour)
+ * businessHours.parse("09:05") // ✗ Invalid (not 15-minute step)
+ *
+ * // Time range validation
+ * const timeRangeSchema = time(false, {
+ *   min: "09:00",
+ *   max: "17:00"
+ * })
+ * timeRangeSchema.parse("12:30") // ✓ Valid
+ * timeRangeSchema.parse("08:00") // ✗ Invalid (before min)
+ *
+ * // Allowed hours only
+ * const specificHours = time({
+ *   allowedHours: [9, 12, 15, 18]
+ * })
+ * specificHours.parse("12:30") // ✓ Valid
+ * specificHours.parse("11:30") // ✗ Invalid (hour not allowed)
+ *
+ * // Whitelist specific times
+ * const whitelistSchema = time(false, {
+ *   whitelist: ["09:00", "12:00", "17:00"],
+ *   whitelistOnly: true
+ * })
+ * whitelistSchema.parse("12:00") // ✓ Valid (in whitelist)
+ * whitelistSchema.parse("13:00") // ✗ Invalid (not in whitelist)
+ *
+ * // Optional with default
+ * const optionalSchema = time(false, {
+ *   defaultValue: "09:00"
+ * })
+ * optionalSchema.parse("") // ✓ Valid (returns "09:00")
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link TimeOptions} for all available configuration options
+ * @see {@link TimeFormat} for supported time formats
+ */
+declare function time<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TimeOptions<IsRequired>, 'required'>): TimeSchema<IsRequired>;
+
+export { TIME_PATTERNS, type TimeFormat, type TimeMessages, type TimeOptions, type TimeSchema, normalizeTime, parseTimeToMinutes, time, validateTimeFormat };