functype 0.8.85 → 0.9.1

package/dist/index.d.ts

@@ -1,24 +1,16 @@
 import { Brand } from './branded/index.js';
 export { BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unbrand, createBrander, hasBrand, unbrand } from './branded/index.js';
-import { O as Option, E as Either, F as Foldable, L as List, a as FunctypeBase, b as Extractable, P as Pipe, T as Traversable, S as Serializable, M as Matchable } from './Either-BlY4VB1r.js';
-export { A as Applicative, s as AsyncMonad, C as Collection, q as CollectionOps, r as ContainerOps, u as Functor, j as Functype, k as FunctypeCollection, d as Left, l as MatchableUtils, v as Monad, N as None, n as OptionConstructor, R as Right, o as SerializationMethods, p as Set, m as Some, c as TestEither, g as TypeCheckLeft, f as TypeCheckRight, e as isLeft, i as isRight, t as tryCatch, h as tryCatchAsync } from './Either-BlY4VB1r.js';
-import { T as Type, a as Typeable } from './Typeable-BBXrKPTY.js';
-export { E as ExtractTag, b as TypeableParams, i as isTypeable } from './Typeable-BBXrKPTY.js';
+import { O as Option, E as Either, L as List, F as FunctypeBase, a as Extractable, T as Traversable, M as Matchable } from './Either-BHep7I0d.js';
+export { A as Applicative, q as AsyncMonad, C as Collection, o as CollectionOps, p as ContainerOps, r as Functor, j as Functype, k as FunctypeCollection, c as Left, l as MatchableUtils, s as Monad, N as None, m as OptionConstructor, R as Right, n as Set, S as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, h as isExtractable, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-BHep7I0d.js';
+import { T as Type, a as Typeable, F as Foldable, P as Pipe, S as Serializable } from './Serializable-BbKuhDDL.js';
+export { b as SerializationMethods } from './Serializable-BbKuhDDL.js';
 import { FPromise } from './fpromise/index.js';
 export { ErrorContext, FPromiseCompanion } from './fpromise/index.js';
 import { Try } from './try/index.js';
 export { TypeNames } from './try/index.js';
 export { Map, SafeTraversable } from './map/index.js';
-import { V as Valuable } from './Tuple-ZYh96cGE.js';
-export { T as Tuple, a as ValuableParams } from './Tuple-ZYh96cGE.js';
+export { Tuple } from './tuple/index.js';
 
-/**
- * A brand with runtime validation
- * @example
- * const Age = ValidatedBrand("Age", (n: number) => n >= 0 && n <= 150)
- * const myAge = Age.of(25) // Option<Brand<"Age", number>>
- * const invalid = Age.of(-5) // None
- */
 type ValidatedBrand<K extends string, T> = {
     readonly brand: K;
     readonly validate: (value: T) => boolean;
@@ -145,6 +137,7 @@ declare function PatternString(brand: string, pattern: RegExp): ValidatedBrand<s
  */
 declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
 
+/** @internal */
 type LazyCondChain<T> = {
     when: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
     elseWhen: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
@@ -276,11 +269,35 @@ declare const Cond: (<T extends Type>() => Cond<T>) & {
     lazy: <T extends Type>() => LazyCondChain<T>;
 };
 
+/**
+ * Type-level utilities for exhaustiveness checking
+ * @internal
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/** @internal */
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+/** @internal */
+type RequireExhaustive<T, Cases> = IsUnion<T> extends true ? (keyof Cases extends T ? (T extends keyof Cases ? Cases : never) : never) : Cases;
+/**
+ * Pattern types for nested matching
+ * @internal
+ */
+type Pattern<T> = T | {
+    [K in keyof T]?: Pattern<T[K]>;
+} | ((value: T) => boolean) | {
+    _: (value: T) => boolean;
+};
+/**
+ * Extract result from pattern
+ * @internal
+ */
+type PatternResult<T, R> = R | ((matched: T) => R);
 /**
  * Pattern matching construct similar to Scala's match expressions.
- * Enforces exhaustive matching and returns values.
+ * Supports exhaustive matching, nested patterns, and guards.
  *
  * @example
+ * // Basic pattern matching
  * const result = Match(value)
  *   .case(x => x > 100, "large")
  *   .case(x => x > 50, "medium")
@@ -293,31 +310,57 @@ declare const Cond: (<T extends Type>() => Cond<T>) & {
  *   .caseValue("success", "Completed!")
  *   .caseValue("error", "Failed")
  *   .default("Unknown")
+ *
+ * @example
+ * // Nested pattern matching
+ * const user = { name: "John", age: 30, role: "admin" }
+ * const msg = Match(user)
+ *   .case({ role: "admin", age: n => n >= 18 }, "Adult admin")
+ *   .case({ role: "user" }, u => `User: ${u.name}`)
+ *   .default("Guest")
  */
 type Match<T extends Type, R extends Type> = {
     /**
-     * Add a case with a predicate
+     * Match against a pattern (value, nested object, or predicate)
      */
-    case: (predicate: (value: T) => boolean, result: R | ((value: T) => R)) => Match<T, R>;
+    case: (pattern: Pattern<T>, result: PatternResult<T, R>) => Match<T, R>;
     /**
-     * Add a case that matches a specific value
+     * Add a case that matches a specific value (backward compatibility)
      */
     caseValue: (match: T, result: R | (() => R)) => Match<T, R>;
     /**
-     * Add a case that matches multiple values
+     * Add a case that matches multiple values (backward compatibility)
      */
     caseValues: (matches: T[], result: R | (() => R)) => Match<T, R>;
     /**
-     * Default case - required to get result
+     * Match with a guard function (alias for readability)
+     */
+    when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => Match<T, R>;
+    /**
+     * Match multiple patterns (OR operation)
+     */
+    caseAny: (patterns: Pattern<T>[], result: PatternResult<T, R>) => Match<T, R>;
+    /**
+     * Default case - makes match non-exhaustive
+     */
+    default: (result: PatternResult<T, R>) => R;
+    /**
+     * Force exhaustive matching (compile-time check for union types)
+     */
+    exhaustive: () => R;
+    /**
+     * Get result if matched, throws if no match
      */
-    default: (result: R | ((value: T) => R)) => R;
+    getOrThrow: (errorMessage?: string) => R;
     /**
-     * Get result if a case matched, throws if no match
+     * Get result wrapped in Option
      */
-    getOrThrow: () => R;
+    toOption: () => Option<R>;
 };
 /**
- * Pattern matching utility for type-safe conditional logic
+ * Pattern matching utility for type-safe conditional logic with exhaustiveness checking,
+ * nested patterns, and guard support
+ *
  * @example
  * // Basic pattern matching
  * const result = Match(value)
@@ -335,12 +378,24 @@ type Match<T extends Type, R extends Type> = {
  * })(color)
  *
  * @example
- * // Partial matching with default
- * const name = Match.partial<number, string>({
- *   1: "one",
- *   2: "two",
- *   3: "three"
- * }).withDefault(n => `number ${n}`)(value)
+ * // Nested pattern matching
+ * type User = { name: string; age: number; role: "admin" | "user" }
+ * const user: User = { name: "John", age: 30, role: "admin" }
+ *
+ * const message = Match<User, string>(user)
+ *   .case({ role: "admin", age: (n) => n >= 18 }, "Adult admin")
+ *   .case({ role: "user" }, u => `User: ${u.name}`)
+ *   .default("Unknown")
+ *
+ * @example
+ * // Using exhaustive() method
+ * type Status = "idle" | "loading" | "success" | "error"
+ * const result = Match<Status, string>("success")
+ *   .case("idle", "Waiting...")
+ *   .case("loading", "Loading...")
+ *   .case("success", "Done!")
+ *   .case("error", "Failed!")
+ *   .exhaustive()
  */
 declare const Match: (<T extends Type, R extends Type>(value: T) => Match<T, R>) & {
     /**
@@ -366,7 +421,7 @@ declare const Match: (<T extends Type, R extends Type>(value: T) => Match<T, R>)
      * const compute = ops("multiply").fn
      * const result = compute(4, 5) // 20
      */
-    exhaustive: <T extends string | number | symbol, R extends Type>(cases: Record<T, R>) => (value: T) => R;
+    exhaustive: <T extends string | number | symbol, R extends Type>(cases: RequireExhaustive<T, Record<T, R>>) => (value: T) => R;
     /**
      * Create a partial match that requires a default
      * @example
@@ -417,6 +472,46 @@ declare const Match: (<T extends Type, R extends Type>(value: T) => Match<T, R>)
     withGuards: <T extends Type, R extends Type>(guards: Array<[(value: T) => boolean, R | ((value: T) => R)]>) => {
         withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
     };
+    /**
+     * Pattern matching for objects with specific structure
+     * @example
+     * type Event =
+     *   | { type: "click"; x: number; y: number }
+     *   | { type: "keypress"; key: string }
+     *   | { type: "hover"; element: string }
+     *
+     * const handler = Match.struct<Event, void>()
+     *   .case({ type: "click" }, (e) => console.log(`Click at ${e.x}, ${e.y}`))
+     *   .case({ type: "keypress", key: "Enter" }, () => console.log("Enter pressed"))
+     *   .case({ type: "hover" }, (e) => console.log(`Hovering over ${e.element}`))
+     *   .build()
+     */
+    struct: <T extends Type, R extends Type>() => {
+        case: (pattern: Pattern<T>, handler: (value: T) => R) => /*elided*/ any;
+        build: () => (value: T) => R;
+    };
+    /**
+     * Create a pattern matcher with guards and nested patterns
+     * @example
+     * type User = {
+     *   name: string
+     *   age: number
+     *   permissions: string[]
+     * }
+     *
+     * const canAccess = Match.builder<User, boolean>()
+     *   .when(u => u.permissions.includes("admin"), true)
+     *   .case({ age: n => n >= 18, permissions: p => p.length > 0 }, true)
+     *   .default(false)
+     *   .build()
+     */
+    builder: <T extends Type, R extends Type>() => {
+        case: (pattern: Pattern<T>, result: PatternResult<T, R>) => /*elided*/ any;
+        when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => /*elided*/ any;
+        default: (result: PatternResult<T, R>) => {
+            build: () => (value: T) => R;
+        };
+    };
 };
 
 /**
@@ -433,6 +528,9 @@ declare function Base<T>(type: string, body: T): T & {
  * The identifier name for Throwable type
  */
 declare const NAME: "Throwable";
+/**
+ * @internal
+ */
 type ThrowableType = Error & Typeable<typeof NAME> & {
     readonly data?: unknown;
     readonly cause?: Error;
@@ -721,6 +819,356 @@ type ParseError = Error & {
     name: "ParseError";
 };
 
+/**
+ * Type-safe error codes using template literal types
+ */
+type ErrorCode = "VALIDATION_FAILED" | "NETWORK_ERROR" | "AUTH_REQUIRED" | "NOT_FOUND" | "PERMISSION_DENIED" | "RATE_LIMITED" | "INTERNAL_ERROR" | "BAD_REQUEST" | "CONFLICT" | "TIMEOUT";
+/**
+ * Template literal type for error messages based on error code
+ */
+type ErrorMessage<T extends ErrorCode> = T extends "VALIDATION_FAILED" ? `Validation failed: ${string}` : T extends "NETWORK_ERROR" ? `Network error: ${string}` : T extends "AUTH_REQUIRED" ? `Authentication required: ${string}` : T extends "NOT_FOUND" ? `Not found: ${string}` : T extends "PERMISSION_DENIED" ? `Permission denied: ${string}` : T extends "RATE_LIMITED" ? `Rate limit exceeded: ${string}` : T extends "INTERNAL_ERROR" ? `Internal server error: ${string}` : T extends "BAD_REQUEST" ? `Bad request: ${string}` : T extends "CONFLICT" ? `Conflict: ${string}` : T extends "TIMEOUT" ? `Request timeout: ${string}` : never;
+/**
+ * HTTP status codes mapped to error codes
+ */
+type ErrorStatus<T extends ErrorCode> = T extends "VALIDATION_FAILED" | "BAD_REQUEST" ? 400 : T extends "AUTH_REQUIRED" ? 401 : T extends "PERMISSION_DENIED" ? 403 : T extends "NOT_FOUND" ? 404 : T extends "CONFLICT" ? 409 : T extends "RATE_LIMITED" ? 429 : T extends "TIMEOUT" ? 408 : T extends "INTERNAL_ERROR" ? 500 : T extends "NETWORK_ERROR" ? 503 : 500;
+/**
+ * Context type for each error code
+ */
+type TypedErrorContext<T extends ErrorCode> = T extends "VALIDATION_FAILED" ? {
+    field: string;
+    value: unknown;
+    rule: string;
+} : T extends "NETWORK_ERROR" ? {
+    url: string;
+    method: string;
+    statusCode?: number;
+} : T extends "AUTH_REQUIRED" ? {
+    resource: string;
+    requiredRole?: string;
+} : T extends "NOT_FOUND" ? {
+    resource: string;
+    id: string | number;
+} : T extends "PERMISSION_DENIED" ? {
+    action: string;
+    resource: string;
+    userId?: string;
+} : T extends "RATE_LIMITED" ? {
+    limit: number;
+    window: string;
+    retryAfter?: number;
+} : T extends "INTERNAL_ERROR" ? {
+    errorId: string;
+    timestamp: string;
+} : T extends "BAD_REQUEST" ? {
+    reason: string;
+    expected?: string;
+} : T extends "CONFLICT" ? {
+    resource: string;
+    conflictingValue: string;
+} : T extends "TIMEOUT" ? {
+    duration: number;
+    operation: string;
+} : Record<string, unknown>;
+/**
+ * Type-safe error class with template literal types
+ */
+interface TypedError<T extends ErrorCode> extends Throwable {
+    readonly code: T;
+    readonly message: ErrorMessage<T>;
+    readonly status: ErrorStatus<T>;
+    readonly context: TypedErrorContext<T>;
+    readonly timestamp: string;
+    readonly traceId?: string;
+}
+declare const TypedError: (<T extends ErrorCode>(code: T, message: ErrorMessage<T>, context: TypedErrorContext<T>, options?: {
+    cause?: unknown;
+    traceId?: string;
+}) => TypedError<T>) & {
+    /**
+     * Create a validation error
+     * @example
+     * const error = TypedError.validation("email", "test@", "must be valid email")
+     * // Type: TypedError<"VALIDATION_FAILED">
+     * // Message must match: "Validation failed: ..."
+     */
+    validation: (field: string, value: unknown, rule: string) => TypedError<"VALIDATION_FAILED">;
+    /**
+     * Create a network error
+     * @example
+     * const error = TypedError.network("https://api.example.com", "POST", 500)
+     * // Type: TypedError<"NETWORK_ERROR">
+     */
+    network: (url: string, method: string, statusCode?: number) => TypedError<"NETWORK_ERROR">;
+    /**
+     * Create an authentication error
+     * @example
+     * const error = TypedError.auth("/api/admin", "admin")
+     * // Type: TypedError<"AUTH_REQUIRED">
+     */
+    auth: (resource: string, requiredRole?: string) => TypedError<"AUTH_REQUIRED">;
+    /**
+     * Create a not found error
+     * @example
+     * const error = TypedError.notFound("user", "123")
+     * // Type: TypedError<"NOT_FOUND">
+     */
+    notFound: (resource: string, id: string | number) => TypedError<"NOT_FOUND">;
+    /**
+     * Create a permission denied error
+     * @example
+     * const error = TypedError.permission("delete", "post", "user123")
+     * // Type: TypedError<"PERMISSION_DENIED">
+     */
+    permission: (action: string, resource: string, userId?: string) => TypedError<"PERMISSION_DENIED">;
+    /**
+     * Create a rate limit error
+     * @example
+     * const error = TypedError.rateLimit(100, "1h", 3600)
+     * // Type: TypedError<"RATE_LIMITED">
+     */
+    rateLimit: (limit: number, window: string, retryAfter?: number) => TypedError<"RATE_LIMITED">;
+    /**
+     * Create an internal error
+     * @example
+     * const error = TypedError.internal("ERR-500-ABC123")
+     * // Type: TypedError<"INTERNAL_ERROR">
+     */
+    internal: (errorId: string) => TypedError<"INTERNAL_ERROR">;
+    /**
+     * Create a bad request error
+     * @example
+     * const error = TypedError.badRequest("Invalid JSON", "valid JSON object")
+     * // Type: TypedError<"BAD_REQUEST">
+     */
+    badRequest: (reason: string, expected?: string) => TypedError<"BAD_REQUEST">;
+    /**
+     * Create a conflict error
+     * @example
+     * const error = TypedError.conflict("email", "user@example.com")
+     * // Type: TypedError<"CONFLICT">
+     */
+    conflict: (resource: string, conflictingValue: string) => TypedError<"CONFLICT">;
+    /**
+     * Create a timeout error
+     * @example
+     * const error = TypedError.timeout(30000, "database query")
+     * // Type: TypedError<"TIMEOUT">
+     */
+    timeout: (duration: number, operation: string) => TypedError<"TIMEOUT">;
+    /**
+     * Check if a value is a TypedError
+     */
+    isTypedError: (value: unknown) => value is TypedError<ErrorCode>;
+    /**
+     * Check if a TypedError has a specific code
+     */
+    hasCode: <T extends ErrorCode>(error: TypedError<ErrorCode>, code: T) => error is TypedError<T>;
+};
+
+/**
+ * LazyList provides lazy evaluation for list operations.
+ * Operations are deferred until the list is materialized.
+ *
+ * @example
+ * // Basic lazy evaluation
+ * const result = LazyList([1, 2, 3, 4, 5])
+ *   .map(x => x * 2)
+ *   .filter(x => x > 5)
+ *   .toArray() // [6, 8, 10]
+ *
+ * @example
+ * // Infinite sequences with take
+ * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
+ *   .map(([a]) => a)
+ *   .take(10)
+ *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+ */
+interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
+    [Symbol.iterator](): Iterator<A>;
+    map<B extends Type>(f: (a: A) => B): LazyList<B>;
+    flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>;
+    filter(predicate: (a: A) => boolean): LazyList<A>;
+    take(n: number): LazyList<A>;
+    drop(n: number): LazyList<A>;
+    takeWhile(predicate: (a: A) => boolean): LazyList<A>;
+    dropWhile(predicate: (a: A) => boolean): LazyList<A>;
+    concat(other: LazyList<A>): LazyList<A>;
+    zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
+    toList(): List<A>;
+    toArray(): A[];
+    forEach(f: (a: A) => void): void;
+    reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B;
+    find(predicate: (a: A) => boolean): Option<A>;
+    some(predicate: (a: A) => boolean): boolean;
+    every(predicate: (a: A) => boolean): boolean;
+    count(): number;
+    first(): Option<A>;
+    last(): Option<A>;
+    toString(): string;
+}
+/**
+ * Lazy list implementation for efficient deferred computation
+ * @example
+ * // Process large datasets efficiently
+ * const result = LazyList.range(1, 1000000)
+ *   .filter(x => x % 2 === 0)
+ *   .map(x => x * x)
+ *   .take(5)
+ *   .toArray() // [4, 16, 36, 64, 100]
+ *
+ * @example
+ * // Infinite sequences
+ * const primes = LazyList.iterate(2, n => n + 1)
+ *   .filter(isPrime)
+ *   .take(10)
+ *   .toArray() // First 10 prime numbers
+ *
+ * @example
+ * // Combining operations
+ * const evens = LazyList.range(0, 100, 2)
+ * const odds = LazyList.range(1, 100, 2)
+ * const combined = evens.zip(odds)
+ *   .map(([e, o]) => e + o)
+ *   .take(5)
+ *   .toArray() // [1, 5, 9, 13, 17]
+ */
+declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>) & {
+    /**
+     * Create an empty LazyList
+     * @example
+     * const empty = LazyList.empty<number>()
+     * empty.toArray() // []
+     */
+    empty: <A extends Type>() => LazyList<A>;
+    /**
+     * Create a LazyList from a single value
+     * @example
+     * const single = LazyList.of(42)
+     *   .map(x => x * 2)
+     *   .toArray() // [84]
+     */
+    of: <A extends Type>(value: A) => LazyList<A>;
+    /**
+     * Create a LazyList from multiple values
+     */
+    from: <A extends Type>(...values: A[]) => LazyList<A>;
+    /**
+     * Create an infinite LazyList by repeatedly applying a function
+     * @example
+     * // Powers of 2
+     * const powers = LazyList.iterate(1, x => x * 2)
+     *   .take(10)
+     *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+     *
+     * @example
+     * // Fibonacci sequence
+     * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
+     *   .map(([a]) => a)
+     *   .take(8)
+     *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]
+     */
+    iterate: <A extends Type>(initial: A, f: (a: A) => A) => LazyList<A>;
+    /**
+     * Create an infinite LazyList by repeatedly calling a function
+     */
+    generate: <A extends Type>(f: () => A) => LazyList<A>;
+    /**
+     * Create a LazyList of numbers from start to end (exclusive)
+     * @example
+     * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]
+     * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]
+     * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+     *
+     * @example
+     * // Sum of squares from 1 to 100
+     * const sum = LazyList.range(1, 101)
+     *   .map(x => x * x)
+     *   .reduce((a, b) => a + b, 0) // 338350
+     */
+    range: (start: number, end: number, step?: number) => LazyList<number>;
+    /**
+     * Create a LazyList that repeats a value n times (or infinitely if n is not provided)
+     */
+    repeat: <A extends Type>(value: A, n?: number) => LazyList<A>;
+    /**
+     * Create a LazyList that cycles through an iterable infinitely
+     */
+    cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
+};
+
+/**
+ * Validation rule types using template literal types
+ */
+type ValidationRule = `min:${number}` | `max:${number}` | `minLength:${number}` | `maxLength:${number}` | `pattern:${string}` | `email` | `url` | `uuid` | `required` | `numeric` | `alpha` | `alphanumeric` | `date` | `future` | `past` | `in:${string}` | `notIn:${string}`;
+/**
+ * Validator function type
+ */
+type Validator<T> = (value: unknown) => Either<TypedError<"VALIDATION_FAILED">, T>;
+/**
+ * Field validation result
+ */
+type FieldValidation<T> = {
+    field: string;
+    value: unknown;
+    result: Either<TypedError<"VALIDATION_FAILED">, T>;
+};
+/**
+ * Form validation result
+ */
+type FormValidation<T extends Record<string, Type>> = Either<List<TypedError<"VALIDATION_FAILED">>, T>;
+declare const Validation: (<T extends Type>(rule: ValidationRule) => Validator<T>) & {
+    /**
+     * Common pre-built validators
+     */
+    validators: {
+        email: Validator<string>;
+        url: Validator<string>;
+        uuid: Validator<string>;
+        required: Validator<string>;
+        numeric: Validator<number>;
+        positiveNumber: Validator<number>;
+        nonEmptyString: Validator<string>;
+    };
+    /**
+     * Create a validator from a rule string
+     * @example
+     * const validator = Validation.rule<number>("min:18")
+     * const result = validator(25) // Right(25)
+     * const error = validator(15) // Left(TypedError)
+     */
+    rule: <T extends Type>(rule: ValidationRule) => Validator<T>;
+    /**
+     * Combine multiple validators
+     * @example
+     * const validator = Validation.combine(
+     *   Validation.rule<string>("required"),
+     *   Validation.rule<string>("email"),
+     *   Validation.rule<string>("maxLength:100")
+     * )
+     */
+    combine: <T extends Type>(...validators: Validator<T>[]) => Validator<T>;
+    /**
+     * Create a custom validator
+     * @example
+     * const isEven = Validation.custom<number>(
+     *   (value) => typeof value === "number" && value % 2 === 0,
+     *   "must be an even number"
+     * )
+     */
+    custom: <T extends Type>(predicate: (value: unknown) => boolean, errorMessage: string) => Validator<T>;
+    /**
+     * Validate a form with multiple fields
+     * @example
+     * const schema = {
+     *   name: Validation.rule<string>("required"),
+     *   email: Validation.rule<string>("email"),
+     *   age: Validation.rule<number>("min:18")
+     * }
+     * const result = Validation.form(schema, { name: "John", email: "john@example.com", age: 25 })
+     */
+    form: <T extends Record<string, Type>>(schema: { [K in keyof T]: Validator<T[K]>; }, data: Record<string, unknown>) => FormValidation<T>;
+};
+
 /**
  * Utility functions for working with Foldable data structures
  */
@@ -776,13 +1224,20 @@ type EitherKind<E> = <A>(a: A) => Either<E, A>;
 type TryKind = <A>(a: A) => Try<A>;
 /**
  * Generic container types for type-safe operations
+ * @internal
  */
 type Mappable<T> = {
     map<U>(f: (value: T) => U): unknown;
 };
+/**
+ * @internal
+ */
 type Flattenable = {
     flatten(): unknown;
 };
+/**
+ * @internal
+ */
 type FlatMappable<T> = {
     flatMap<U>(f: (value: T) => unknown): unknown;
 };
@@ -1081,148 +1536,100 @@ declare const Lazy: (<T extends Type>(thunk: () => T) => Lazy<T>) & {
 };
 
 /**
- * LazyList provides lazy evaluation for list operations.
- * Operations are deferred until the list is materialized.
- *
- * @example
- * // Basic lazy evaluation
- * const result = LazyList([1, 2, 3, 4, 5])
- *   .map(x => x * 2)
- *   .filter(x => x > 5)
- *   .toArray() // [6, 8, 10]
- *
- * @example
- * // Infinite sequences with take
- * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
- *   .map(([a]) => a)
- *   .take(10)
- *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+ * Type alias for the native JavaScript Map
+ * @interface
+ * @module Map
+ * @category Collections
  */
-type LazyList<A extends Type> = {
-    [Symbol.iterator](): Iterator<A>;
-    map<B extends Type>(f: (a: A) => B): LazyList<B>;
-    flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>;
-    filter(predicate: (a: A) => boolean): LazyList<A>;
-    take(n: number): LazyList<A>;
-    drop(n: number): LazyList<A>;
-    takeWhile(predicate: (a: A) => boolean): LazyList<A>;
-    dropWhile(predicate: (a: A) => boolean): LazyList<A>;
-    concat(other: LazyList<A>): LazyList<A>;
-    zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
-    toList(): List<A>;
-    toArray(): A[];
-    forEach(f: (a: A) => void): void;
-    reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B;
-    find(predicate: (a: A) => boolean): Option<A>;
-    some(predicate: (a: A) => boolean): boolean;
-    every(predicate: (a: A) => boolean): boolean;
-    count(): number;
-    first(): Option<A>;
-    last(): Option<A>;
-};
+type ESMapType<K, V> = Map<K, V>;
 /**
- * Lazy list implementation for efficient deferred computation
- * @example
- * // Process large datasets efficiently
- * const result = LazyList.range(1, 1000000)
- *   .filter(x => x % 2 === 0)
- *   .map(x => x * x)
- *   .take(5)
- *   .toArray() // [4, 16, 36, 64, 100]
- *
- * @example
- * // Infinite sequences
- * const primes = LazyList.iterate(2, n => n + 1)
- *   .filter(isPrime)
- *   .take(10)
- *   .toArray() // First 10 prime numbers
+ * Reference to the native JavaScript Map
+ * @module Map
+ * @category Collections
+ */
+declare const ESMap: MapConstructor;
+
+/**
+ * A mutable reference container that holds a value of type A.
+ * This provides controlled mutability in a functional context.
  *
  * @example
- * // Combining operations
- * const evens = LazyList.range(0, 100, 2)
- * const odds = LazyList.range(1, 100, 2)
- * const combined = evens.zip(odds)
- *   .map(([e, o]) => e + o)
- *   .take(5)
- *   .toArray() // [1, 5, 9, 13, 17]
+ * const counter = Ref(0)
+ * counter.get() // 0
+ * counter.set(5)
+ * counter.get() // 5
+ * counter.update(n => n + 1)
+ * counter.get() // 6
  */
-declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>) & {
+interface Ref<A> {
     /**
-     * Create an empty LazyList
-     * @example
-     * const empty = LazyList.empty<number>()
-     * empty.toArray() // []
+     * Get the current value
      */
-    empty: <A extends Type>() => LazyList<A>;
+    get(): A;
     /**
-     * Create a LazyList from a single value
-     * @example
-     * const single = LazyList.of(42)
-     *   .map(x => x * 2)
-     *   .toArray() // [84]
+     * Set a new value
      */
-    of: <A extends Type>(value: A) => LazyList<A>;
+    set(value: A): void;
     /**
-     * Create a LazyList from multiple values
+     * Update the value using a function
      */
-    from: <A extends Type>(...values: A[]) => LazyList<A>;
+    update(f: (current: A) => A): void;
     /**
-     * Create an infinite LazyList by repeatedly applying a function
-     * @example
-     * // Powers of 2
-     * const powers = LazyList.iterate(1, x => x * 2)
-     *   .take(10)
-     *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
-     *
-     * @example
-     * // Fibonacci sequence
-     * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
-     *   .map(([a]) => a)
-     *   .take(8)
-     *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]
+     * Update and return the old value
      */
-    iterate: <A extends Type>(initial: A, f: (a: A) => A) => LazyList<A>;
+    getAndSet(value: A): A;
     /**
-     * Create an infinite LazyList by repeatedly calling a function
+     * Update and return the new value
      */
-    generate: <A extends Type>(f: () => A) => LazyList<A>;
+    updateAndGet(f: (current: A) => A): A;
     /**
-     * Create a LazyList of numbers from start to end (exclusive)
-     * @example
-     * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]
-     * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]
-     * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
-     *
-     * @example
-     * // Sum of squares from 1 to 100
-     * const sum = LazyList.range(1, 101)
-     *   .map(x => x * x)
-     *   .reduce((a, b) => a + b, 0) // 338350
+     * Update and return the old value
      */
-    range: (start: number, end: number, step?: number) => LazyList<number>;
+    getAndUpdate(f: (current: A) => A): A;
     /**
-     * Create a LazyList that repeats a value n times (or infinitely if n is not provided)
+     * Compare and swap - only updates if current value equals expected
      */
-    repeat: <A extends Type>(value: A, n?: number) => LazyList<A>;
+    compareAndSet(expected: A, newValue: A): boolean;
     /**
-     * Create a LazyList that cycles through an iterable infinitely
+     * Modify the value and return a result
      */
-    cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
-};
+    modify<B>(f: (current: A) => [A, B]): B;
+}
+/**
+ * Creates a new mutable reference containing the given value
+ */
+declare function Ref<A extends Type>(initial: A): Ref<A>;
+declare namespace Ref {
+    var of: typeof Ref;
+}
 
 /**
- * Type alias for the native JavaScript Map
- * @interface
- * @module Map
- * @category Collections
+ * Parameters for creating a Valuable instance
  */
-type ESMapType<K, V> = Map<K, V>;
+type ValuableParams<Tag extends string, T, V> = {
+    _tag: Tag;
+    impl: T;
+    value: V;
+};
 /**
- * Reference to the native JavaScript Map
- * @module Map
- * @category Collections
+ * Represents a type that can extract its inner value. Creates a Valuable wrapper that adds value extraction capabilities.
+ * @param params - Configuration parameters
+ * @module Valuable
+ * @category Utilities
  */
-declare const ESMap: MapConstructor;
+declare function Valuable<Tag extends string, V, T = object>(params: ValuableParams<Tag, T, V>): T & {
+    toValue: () => {
+        _tag: Tag;
+        value: V;
+    };
+    _tag: Tag;
+};
+type Valuable<Tag extends string, V, T = object> = Typeable<Tag, T> & {
+    toValue: () => {
+        _tag: Tag;
+        value: V;
+    };
+};
 
 /**
  * Stack data structure - Last In, First Out (LIFO)
@@ -1326,4 +1733,4 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
     fromBinary: <A>(binary: string) => Stack<A>;
 };
 
-export { type Async, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, Foldable, FoldableUtils, FunctypeBase, HKT, ISO8601Date, Identity, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, UUID, type UniversalContainer, UrlString, ValidatedBrand, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };
+export { type Async, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorCode, type ErrorFormatterOptions, type ErrorMessage, type ErrorStatus, type ErrorWithTaskInfo, Extractable, FPromise, type FieldValidation, Foldable, FoldableUtils, type FormValidation, FunctypeBase, HKT, ISO8601Date, Identity, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Ref, Ref as RefType, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, Validation, type ValidationRule, type Validator, Valuable, type ValuableParams, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };