functype 0.8.69 → 0.8.70

package/dist/index.d.ts

@@ -1,15 +1,125 @@
-export { Brand, BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unbrand, createBrander, hasBrand, unbrand } from './branded/index.js';
-import { E as Either, F as Foldable, O as Option, L as List, T as Traversable, S as Serializable, P as Pipe, M as Matchable } from './Either-BfXNbTHo.js';
-export { a as Collection, C as Converters, I as IterableType, c as Left, h as MatchableUtils, N as None, k as OptionConstructor, R as Right, l as SerializationMethods, m as Set, j as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-BfXNbTHo.js';
-import { T as Typeable, a as Type, F as Functor, V as Valuable } from './Valuable-CtuVEKTZ.js';
-export { A as AbstractFunctor, c as ArrayFunctor, b as AsyncFunctor, E as ExtractTag, d as TypeableParams, e as ValuableParams, i as isTypeable } from './Valuable-CtuVEKTZ.js';
+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, T as Traversable, S as Serializable, P as Pipe, M as Matchable } from './Either-DlOLCe3b.js';
+export { a as Collection, C as Converters, I as IterableType, c as Left, h as MatchableUtils, N as None, k as OptionConstructor, R as Right, l as SerializationMethods, m as Set, j as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-DlOLCe3b.js';
+import { T as Type, a as Typeable, F as Functor, V as Valuable } from './Valuable-D4BtNlTV.js';
+export { A as AbstractFunctor, c as ArrayFunctor, b as AsyncFunctor, E as ExtractTag, d as TypeableParams, e as ValuableParams, i as isTypeable } from './Valuable-D4BtNlTV.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 { a as ESMap, E as ESMapType, M as Map, S as SafeTraversable } from './Map-vivbm5n0.js';
+export { a as ESMap, E as ESMapType, M as Map, S as SafeTraversable } from './Map-R4vpSnzG.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;
+    readonly of: (value: T) => Option<Brand<K, T>>;
+    readonly from: (value: T) => Either<string, Brand<K, T>>;
+    readonly unsafeOf: (value: T) => Brand<K, T>;
+    readonly is: (value: unknown) => value is Brand<K, T>;
+    readonly refine: <K2 extends string>(brand: K2, validate: (value: Brand<K, T>) => boolean) => ValidatedBrand<K2, Brand<K, T>>;
+};
+/**
+ * Create a validated brand with runtime validation
+ * @example
+ * const Email = ValidatedBrand("Email", (s: string) => /^[^@]+@[^@]+\.[^@]+$/.test(s))
+ * const email = Email.of("user@example.com") // Some(Brand<"Email", string>)
+ *
+ * @example
+ * // With Either for error messages
+ * const Port = ValidatedBrand("Port", (n: number) => n >= 1 && n <= 65535)
+ * const result = Port.from(8080) // Right(Brand<"Port", number>)
+ * const error = Port.from(70000) // Left("Invalid Port: validation failed")
+ *
+ * @example
+ * // Type guard usage
+ * const value: unknown = "test@example.com"
+ * if (Email.is(value)) {
+ *   // value is Brand<"Email", string>
+ * }
+ */
+declare function ValidatedBrand<K extends string, T>(brand: K, validate: (value: T) => boolean): ValidatedBrand<K, T>;
+/**
+ * Positive number brand (> 0)
+ * @example
+ * const price = PositiveNumber.of(19.99) // Some(Brand<"PositiveNumber", number>)
+ * const invalid = PositiveNumber.of(-5) // None
+ * const checked = PositiveNumber.from(0) // Left("Invalid PositiveNumber: validation failed")
+ */
+declare const PositiveNumber: ValidatedBrand<"PositiveNumber", number>;
+declare const NonNegativeNumber: ValidatedBrand<"NonNegativeNumber", number>;
+declare const IntegerNumber: ValidatedBrand<"IntegerNumber", number>;
+declare const PositiveInteger: ValidatedBrand<"PositiveInteger", Brand<"PositiveNumber", number>>;
+/**
+ * Non-empty string brand
+ * @example
+ * const name = NonEmptyString.of("John") // Some(Brand<"NonEmptyString", string>)
+ * const empty = NonEmptyString.of("") // None
+ */
+declare const NonEmptyString: ValidatedBrand<"NonEmptyString", string>;
+/**
+ * Email address brand with basic validation
+ * @example
+ * const email = EmailAddress.of("user@example.com") // Some(Brand<"EmailAddress", string>)
+ * const invalid = EmailAddress.of("not-an-email") // None
+ *
+ * @example
+ * // Using with forms
+ * const processEmail = (input: string) => {
+ *   return EmailAddress.from(input)
+ *     .map(email => sendWelcomeEmail(email))
+ *     .getOrElse("Invalid email address")
+ * }
+ */
+declare const EmailAddress: ValidatedBrand<"EmailAddress", string>;
+declare const UrlString: ValidatedBrand<"UrlString", string>;
+declare const UUID: ValidatedBrand<"UUID", string>;
+declare const ISO8601Date: ValidatedBrand<"ISO8601Date", string>;
+/**
+ * Create a number brand with min/max bounds
+ * @example
+ * const Percentage = BoundedNumber("Percentage", 0, 100)
+ * const valid = Percentage.of(75) // Some(Brand<"Percentage", number>)
+ * const invalid = Percentage.of(150) // None
+ *
+ * @example
+ * const Port = BoundedNumber("Port", 1, 65535)
+ * const httpPort = Port.unsafeOf(80) // Brand<"Port", number>
+ * // Port.unsafeOf(70000) // throws Error
+ */
+declare function BoundedNumber(brand: string, min: number, max: number): ValidatedBrand<string, number>;
+/**
+ * Create a string brand with length constraints
+ * @example
+ * const Username = BoundedString("Username", 3, 20)
+ * const valid = Username.of("johndoe") // Some(Brand<"Username", string>)
+ * const tooShort = Username.of("jo") // None
+ * const tooLong = Username.of("verylongusernamethatexceedslimit") // None
+ */
+declare function BoundedString(brand: string, minLength: number, maxLength: number): ValidatedBrand<string, string>;
+/**
+ * Create a string brand that matches a regex pattern
+ * @example
+ * const HexColor = PatternString("HexColor", /^#[0-9a-f]{6}$/i)
+ * const red = HexColor.of("#ff0000") // Some(Brand<"HexColor", string>)
+ * const invalid = HexColor.of("red") // None
+ *
+ * @example
+ * const PhoneNumber = PatternString("PhoneNumber", /^\+?[1-9]\d{1,14}$/)
+ * const phone = PhoneNumber.from("+1234567890")
+ *   .map(p => formatPhoneNumber(p))
+ *   .getOrElse("Invalid phone number")
+ */
+declare function PatternString(brand: string, pattern: RegExp): ValidatedBrand<string, string>;
+
 /**
  * Creates a function-object hybrid similar to Scala's companion objects.
  * This utility allows creating TypeScript function objects with attached methods,
@@ -34,6 +144,280 @@ export { Tuple } from './tuple/index.js';
  */
 declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
 
+type LazyCondChain<T> = {
+    when: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
+    elseWhen: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
+    else: (value: () => T) => T;
+};
+/**
+ * Conditional expression that enforces exhaustive returns without early returns.
+ * Similar to Scala's if/else expressions that always return a value.
+ *
+ * @example
+ * const discount = Cond.of<number>()
+ *   .when(isPremiumMember, 0.2)
+ *   .elseWhen(isRegularMember, 0.1)
+ *   .else(0)
+ *
+ * @example
+ * // Chaining multiple conditions
+ * const status = Cond.of<string>()
+ *   .when(response.status >= 500, "Server Error")
+ *   .elseWhen(response.status >= 400, "Client Error")
+ *   .elseWhen(response.status >= 200, "Success")
+ *   .else("Unknown")
+ */
+type Cond<T extends Type> = {
+    /**
+     * Add an if condition
+     */
+    when: (condition: boolean, value: T | (() => T)) => Cond<T>;
+    /**
+     * Add an else-if condition
+     */
+    elseWhen: (condition: boolean, value: T | (() => T)) => Cond<T>;
+    /**
+     * Terminal else clause - required to get the result
+     */
+    else: (value: T | (() => T)) => T;
+    /**
+     * Get the result if a condition was met, throws if no condition met
+     */
+    getOrThrow: () => T;
+};
+/**
+ * Conditional expression builder for functional if/else chains
+ * @example
+ * // Basic usage
+ * const size = Cond.of<string>()
+ *   .when(value > 100, "large")
+ *   .elseWhen(value > 50, "medium")
+ *   .else("small")
+ *
+ * @example
+ * // Pattern matching
+ * const message = Cond.match(errorCode)({
+ *   404: "Not Found",
+ *   500: "Server Error",
+ *   200: "OK"
+ * })
+ *
+ * @example
+ * // Lazy evaluation
+ * const result = Cond.lazy<string>()
+ *   .when(() => checkCondition1(), () => "Result 1")
+ *   .when(() => checkCondition2(), () => "Result 2")
+ *   .else(() => "Default")
+ */
+declare const Cond: (<T extends Type>() => Cond<T>) & {
+    /**
+     * Create a conditional expression that must end with else
+     * @example
+     * const x = 7
+     * const result = Cond.of<string>()
+     *   .when(x > 10, "large")
+     *   .elseWhen(x > 5, "medium")
+     *   .else("small")
+     * // result = "medium"
+     *
+     * @example
+     * // With lazy evaluation
+     * const discount = Cond.of<number>()
+     *   .when(isPremium, () => calculatePremiumDiscount())
+     *   .when(isLoyal, () => calculateLoyaltyDiscount())
+     *   .else(0)
+     */
+    of: <T extends Type>() => Cond<T>;
+    /**
+     * Pattern matching helper that ensures exhaustiveness
+     * @example
+     * type Status = "pending" | "success" | "error"
+     * const status: Status = "success"
+     * const result = Cond.match(status)({
+     *   "pending": "Waiting...",
+     *   "success": "Done!",
+     *   "error": "Failed!"
+     * })
+     * // result = "Done!"
+     *
+     * @example
+     * // With function values
+     * const action = "compute"
+     * const result = Cond.match(action)({
+     *   "compute": () => expensiveComputation(),
+     *   "cache": () => getCachedValue(),
+     *   "skip": () => defaultValue
+     * })
+     */
+    match: <T extends string | number | symbol>(value: T) => <R extends Type>(cases: Record<T, R | (() => R)>) => R;
+    /**
+     * Create a lazy conditional that defers evaluation
+     * @example
+     * // Only evaluates conditions and values when needed
+     * const getMessage = Cond.lazy<string>()
+     *   .when(() => isError(), () => computeErrorMessage())
+     *   .when(() => isWarning(), () => computeWarningMessage())
+     *   .else(() => "Success")
+     *
+     * @example
+     * // Complex conditional with expensive checks
+     * const result = Cond.lazy<Action>()
+     *   .when(
+     *     () => user.role === "admin" && checkAdminPermissions(),
+     *     () => ({ type: "admin", permissions: loadAdminPermissions() })
+     *   )
+     *   .when(
+     *     () => user.role === "user" && user.isActive,
+     *     () => ({ type: "user", permissions: loadUserPermissions() })
+     *   )
+     *   .else(() => ({ type: "guest", permissions: [] }))
+     */
+    lazy: <T extends Type>() => LazyCondChain<T>;
+};
+
+/**
+ * Pattern matching construct similar to Scala's match expressions.
+ * Enforces exhaustive matching and returns values.
+ *
+ * @example
+ * const result = Match(value)
+ *   .case(x => x > 100, "large")
+ *   .case(x => x > 50, "medium")
+ *   .default("small")
+ *
+ * @example
+ * // Matching exact values
+ * const message = Match(status)
+ *   .caseValue("pending", "Please wait...")
+ *   .caseValue("success", "Completed!")
+ *   .caseValue("error", "Failed")
+ *   .default("Unknown")
+ */
+type Match<T extends Type, R extends Type> = {
+    /**
+     * Add a case with a predicate
+     */
+    case: (predicate: (value: T) => boolean, result: R | ((value: T) => R)) => Match<T, R>;
+    /**
+     * Add a case that matches a specific value
+     */
+    caseValue: (match: T, result: R | (() => R)) => Match<T, R>;
+    /**
+     * Add a case that matches multiple values
+     */
+    caseValues: (matches: T[], result: R | (() => R)) => Match<T, R>;
+    /**
+     * Default case - required to get result
+     */
+    default: (result: R | ((value: T) => R)) => R;
+    /**
+     * Get result if a case matched, throws if no match
+     */
+    getOrThrow: () => R;
+};
+/**
+ * Pattern matching utility for type-safe conditional logic
+ * @example
+ * // Basic pattern matching
+ * const result = Match(value)
+ *   .case(x => x > 0, "positive")
+ *   .case(x => x < 0, "negative")
+ *   .default("zero")
+ *
+ * @example
+ * // Exhaustive matching for union types
+ * type Color = "red" | "green" | "blue"
+ * const hex = Match.exhaustive<Color, string>({
+ *   red: "#FF0000",
+ *   green: "#00FF00",
+ *   blue: "#0000FF"
+ * })(color)
+ *
+ * @example
+ * // Partial matching with default
+ * const name = Match.partial<number, string>({
+ *   1: "one",
+ *   2: "two",
+ *   3: "three"
+ * }).withDefault(n => `number ${n}`)(value)
+ */
+declare const Match: (<T extends Type, R extends Type>(value: T) => Match<T, R>) & {
+    /**
+     * Create a type-safe exhaustive match for union types
+     * @example
+     * type Status = "pending" | "success" | "error"
+     * const status: Status = "success"
+     * const result = Match.exhaustive<Status, string>({
+     *   pending: "Waiting...",
+     *   success: "Done!",
+     *   error: "Failed!"
+     * })(status)
+     * // result = "Done!"
+     *
+     * @example
+     * // For function values, wrap in object to prevent execution
+     * type Operation = "add" | "subtract" | "multiply"
+     * const ops = Match.exhaustive<Operation, { fn: (a: number, b: number) => number }>({
+     *   add: { fn: (a, b) => a + b },
+     *   subtract: { fn: (a, b) => a - b },
+     *   multiply: { fn: (a, b) => a * b }
+     * })
+     * 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;
+    /**
+     * Create a partial match that requires a default
+     * @example
+     * const httpCode = 404
+     * const message = Match.partial<number, string>({
+     *   200: "OK",
+     *   201: "Created",
+     *   404: "Not Found",
+     *   500: "Server Error"
+     * }).withDefault("Unknown Status")(httpCode)
+     * // message = "Not Found"
+     *
+     * @example
+     * // With function default
+     * const getMessage = Match.partial<number, string>({
+     *   0: "Zero",
+     *   1: "One",
+     *   2: "Two"
+     * }).withDefault((n) => `Number: ${n}`)
+     * getMessage(5) // "Number: 5"
+     */
+    partial: <T extends string | number | symbol, R extends Type>(cases: Partial<Record<T, R | ((value: T) => R)>>) => {
+        withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
+    };
+    /**
+     * Pattern match with guards
+     * @example
+     * const score = 85
+     * const grade = Match.withGuards<number, string>([
+     *   [n => n >= 90, "A"],
+     *   [n => n >= 80, "B"],
+     *   [n => n >= 70, "C"],
+     *   [n => n >= 60, "D"]
+     * ]).withDefault("F")(score)
+     * // grade = "B"
+     *
+     * @example
+     * // With function results for custom messages
+     * const age = 25
+     * const category = Match.withGuards<number, string>([
+     *   [n => n < 13, n => `Child (${n} years)`],
+     *   [n => n < 20, n => `Teenager (${n} years)`],
+     *   [n => n < 60, n => `Adult (${n} years)`],
+     *   [n => n >= 60, n => `Senior (${n} years)`]
+     * ]).withDefault("Unknown")(age)
+     * // category = "Adult (25 years)"
+     */
+    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;
+    };
+};
+
 /**
  * Base Object from which most other objects inherit
  * @param type - The type name for the object
@@ -261,6 +645,205 @@ declare const Task: (<T = unknown>(params?: TaskParams) => {
 };
 type Task = ReturnType<typeof Task>;
 
+/**
+ * Code context for LLM-based self-healing and analysis
+ */
+type CodeContext = {
+    /** The source code being executed */
+    source: string;
+    /** File path or identifier */
+    filePath?: string;
+    /** Function/method name */
+    functionName?: string;
+    /** Line number where error occurred */
+    lineNumber?: number;
+    /** Input parameters that caused the issue */
+    inputParams?: Record<string, unknown>;
+    /** Expected output type/shape */
+    expectedOutput?: unknown;
+    /** Stack trace at time of error */
+    stackTrace?: string;
+    /** Previous execution attempts */
+    attempts?: Array<{
+        timestamp: Date;
+        error: string;
+        modifications?: string;
+    }>;
+    /** Additional context for LLM */
+    llmContext?: {
+        /** Description of what the code should do */
+        intent: string;
+        /** Known constraints or requirements */
+        constraints?: string[];
+        /** Related code/dependencies */
+        dependencies?: string[];
+        /** Business rules or domain knowledge */
+        domain?: string;
+    };
+};
+/**
+ * Fitness function result for code quality assessment
+ */
+type FitnessResult = {
+    /** Overall fitness score (0-100) */
+    score: number;
+    /** Individual metric scores */
+    metrics: {
+        /** Correctness score (0-100) */
+        correctness: number;
+        /** Performance score (0-100) */
+        performance: number;
+        /** Maintainability score (0-100) */
+        maintainability: number;
+        /** Security score (0-100) */
+        security: number;
+        /** Type safety score (0-100) */
+        typeSafety: number;
+    };
+    /** Detailed feedback for improvement */
+    feedback: string[];
+    /** Suggestions for self-healing */
+    suggestions: string[];
+};
+/**
+ * Partial fitness result from individual functions
+ */
+type PartialFitnessResult = {
+    /** Partial metric scores */
+    metrics?: Partial<FitnessResult["metrics"]>;
+    /** Detailed feedback for improvement */
+    feedback?: string[];
+    /** Suggestions for self-healing */
+    suggestions?: string[];
+};
+/**
+ * Configuration for self-healing behavior
+ */
+type SelfHealingConfig = {
+    /** Maximum number of self-healing attempts */
+    maxAttempts: number;
+    /** Whether to use LLM for code generation */
+    enableLLMHealing: boolean;
+    /** Minimum fitness score to accept */
+    minFitnessScore: number;
+    /** Custom fitness functions */
+    customFitnessFunctions?: Array<(context: CodeContext, result?: unknown) => Promise<PartialFitnessResult>>;
+    /** LLM provider configuration */
+    llmConfig?: {
+        provider: "openai" | "anthropic" | "custom";
+        apiKey?: string;
+        model?: string;
+        temperature?: number;
+        customEndpoint?: string;
+    };
+};
+/**
+ * Self-healing attempt result
+ */
+type HealingAttempt = {
+    /** Attempt number */
+    attempt: number;
+    /** Timestamp of attempt */
+    timestamp: Date;
+    /** Error that triggered healing */
+    error: string;
+    /** Generated/modified code */
+    healedCode?: string;
+    /** Fitness score of healed code */
+    fitnessScore?: number;
+    /** Whether healing was successful */
+    success: boolean;
+    /** Reasoning for the healing approach */
+    reasoning?: string;
+};
+/**
+ * Code-aware task that can self-heal using LLM context
+ */
+type CodeAwareTask<T extends Type> = {
+    /** Execute with code context and self-healing */
+    executeWithHealing: (codeContext: CodeContext, config: SelfHealingConfig, cancellationToken?: CancellationToken) => Promise<{
+        result: Option<unknown>;
+        fitness: FitnessResult;
+        healingAttempts: HealingAttempt[];
+        finalCode: string;
+    }>;
+    /** Evaluate fitness of code without execution */
+    evaluateFitness: (codeContext: CodeContext, result?: unknown, customFunctions?: Array<(context: CodeContext, result?: unknown) => Promise<PartialFitnessResult>>) => Promise<FitnessResult>;
+    /** Generate healing suggestions using LLM */
+    generateHealingSuggestions: (codeContext: CodeContext, error: string, config: SelfHealingConfig) => Promise<{
+        suggestions: string[];
+        healedCode?: string;
+        reasoning: string;
+    }>;
+    /** Validate healed code before execution */
+    validateHealedCode: (original: CodeContext, healed: string, config: SelfHealingConfig) => Promise<{
+        isValid: boolean;
+        issues: string[];
+        riskLevel: "low" | "medium" | "high";
+    }>;
+};
+/**
+ * Code-aware task that provides LLM context for self-healing and fitness evaluation
+ * @example
+ * // Basic usage with self-healing
+ * const codeTask = CodeAwareTask<string>({ name: "DataProcessor" })
+ * const context = CodeAwareTask.createCodeContext(
+ *   "function processData(data) { return data.map(x => x.value) }",
+ *   "Process array of objects to extract values"
+ * )
+ *
+ * const result = await codeTask.executeWithHealing(
+ *   context,
+ *   CodeAwareTask.defaultConfig()
+ * )
+ *
+ * @example
+ * // Custom fitness evaluation
+ * const customFitness = CodeAwareTask.createCustomFitnessFunction(
+ *   "businessLogic",
+ *   async (context, result) => ({
+ *     score: 85,
+ *     feedback: ["Follows business rules correctly"],
+ *     suggestions: ["Consider adding validation"]
+ *   })
+ * )
+ *
+ * const fitness = await codeTask.evaluateFitness(context, result, [customFitness])
+ *
+ * @example
+ * // High-fitness configuration
+ * const strictConfig = CodeAwareTask.fitnessConfig(90)
+ * const result = await codeTask.executeWithHealing(context, strictConfig)
+ */
+declare const CodeAwareTask: (<T extends Type>(params?: TaskParams) => CodeAwareTask<T>) & {
+    /**
+     * Create a default self-healing configuration
+     */
+    defaultConfig: () => SelfHealingConfig;
+    /**
+     * Create a fitness-focused configuration
+     */
+    fitnessConfig: (minScore: number) => SelfHealingConfig;
+    /**
+     * Create a custom fitness function for domain-specific evaluation
+     */
+    createCustomFitnessFunction: (name: string, evaluator: (context: CodeContext, result?: unknown) => Promise<{
+        score: number;
+        feedback: string[];
+        suggestions?: string[];
+    }>) => (context: CodeContext, result?: unknown) => Promise<PartialFitnessResult>;
+    /**
+     * Utility to create code context from function
+     */
+    createCodeContext: (source: string, intent: string, options?: {
+        filePath?: string;
+        functionName?: string;
+        expectedOutput?: unknown;
+        constraints?: string[];
+        dependencies?: string[];
+    }) => CodeContext;
+};
+
 /**
  * Type definition for task information that may be attached to errors
  */
@@ -441,6 +1024,136 @@ type Identity<T> = {
 };
 declare function Identity<T>(value: T): Identity<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 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>;
+};
+/**
+ * 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>;
+};
+
 /**
  * Stack data structure - Last In, First Out (LIFO)
  * Implements the Traversable interface for working with ordered collections
@@ -531,4 +1244,4 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
     fromBinary: <A>(binary: string) => Stack<A>;
 };
 
-export { type Async, Base, type CancellationToken, type CancellationTokenSource, Companion, Either, type EitherKind, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, Foldable, FoldableUtils, Functor, HKT, Identity, type Kind, List, type ListKind, Matchable, NAME, Option, type OptionKind, ParseError, Pipe, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, type UniversalContainer, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };
+export { type Async, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, CodeAwareTask, type CodeContext, Companion, Cond, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, type FitnessResult, Foldable, FoldableUtils, Functor, HKT, type HealingAttempt, ISO8601Date, Identity, IntegerNumber, type Kind, LazyList, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Option, type OptionKind, ParseError, type PartialFitnessResult, PatternString, Pipe, PositiveInteger, PositiveNumber, type SelfHealingConfig, 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 };