typetify 1.0.0 → 2.1.0

package/dist/index.d.mts

@@ -1,22 +1,830 @@
-import { isDefined, isNil, assert, assertDefined, fail, noop, identity, unreachable } from './core/index.mjs';
-import { isObject, isPlainObject, isString, isNumber, isBoolean, isFunction, isArray, isDate, isPromise, isError, isSymbol, hasKey, hasKeys, isEmpty, isNonEmpty, castArray, cloneWith, cloneDeepWith, conformsTo, eq, gt, gte, lt, lte, isArguments, isArrayBuffer, isArrayLike, isArrayLikeObject, isBuffer, isElement, isEqualWith, isFinite, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNull, isUndefined, isObjectLike, isRegExp, isSafeInteger, isSet, isTypedArray, isWeakMap, isWeakSet, toArray, toFinite, toInteger, toLength, toNumber, toPlainObject, toSafeInteger, toString } from './guards/index.mjs';
-import { pick, omit, keysTyped, valuesTyped, entriesTyped, fromEntriesTyped, mapObject, filterObject, mergeShallow, clone, cloneDeep, get, set, invert, deepMerge, isEqual, has, unset, paths, transform, deepGet, deepGetOr, deepSet, deepHas, deepPath, deepPluck } from './object/index.mjs';
+import { isDefined, isNil, assert, fail, noop, identity, unreachable } from './core/index.mjs';
+export { assertDefined } from './core/index.mjs';
+import { isObject, isPlainObject, isString, isNumber, isBoolean, isFunction, isArray, isDate, isPromise, isError, isSymbol, hasKey, hasKeys, isEmpty, isNonEmpty, castArray, cloneWith, cloneDeepWith, conformsTo, eq, gt, gte, lt, lte, isArguments, isArrayBuffer, isArrayLike, isArrayLikeObject, isBuffer, isElement, isEqualWith, isFinite, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNull, isUndefined, isObjectLike, isRegExp, isSafeInteger, isSet, isTypedArray, isWeakMap, isWeakSet, toFinite, toInteger, toLength, toNumber, toPlainObject, toSafeInteger, toString } from './guards/index.mjs';
+export { toArray } from './guards/index.mjs';
+import { pick, omit, keysTyped, valuesTyped, entriesTyped, fromEntriesTyped, mapObject, filterObject, mergeShallow, clone, cloneDeep, set, invert, deepMerge, isEqual, has, unset, paths, transform, deepGet, deepGetOr, deepSet, deepHas, deepPath, deepPluck } from './object/index.mjs';
+export { get } from './object/index.mjs';
 import { awaitTo, sleep, withTimeout, retry, debounce, throttle, once, onceAsync, defer, parallel } from './async/index.mjs';
 export { Deferred, RetryOptions } from './async/index.mjs';
-import { unique, groupBy, indexBy, partition, chunk, compact, flatten, sortBy, first, last, range, shuffle, sample, zip, unzip, difference, intersection, take, drop, takeWhile, dropWhile, findLast, countBy, maxBy, minBy, sumBy, head, tail, init } from './collection/index.mjs';
+import { unique, groupBy, indexBy, partition, chunk as chunk$1, compact, flatten as flatten$1, sortBy, first, last, range as range$1, shuffle, sample, zip as zip$1, unzip, difference, take as take$1, drop, takeWhile, dropWhile, findLast, countBy, maxBy, minBy, sumBy, head, tail, init } from './collection/index.mjs';
+export { intersection } from './collection/index.mjs';
 import { safeJsonParse, safeJsonStringify, parseNumber, parseInteger, parseBoolean, parseDate, coerceString, coerceArray, trimAll, defaults, clamp, isEmail, isUrl, isUuid, isIpAddress, parseUrl } from './input/index.mjs';
 export { JsonParseResult, JsonStringifyResult } from './input/index.mjs';
-import { pipe, compose, tap, when, unless, match, tryCatch, tryCatchAsync, ifElse, constant } from './flow/index.mjs';
-export { TryCatchAsyncResult, TryCatchResult } from './flow/index.mjs';
+import { tap, match, tryCatch, tryCatchAsync, constant } from './flow/index.mjs';
+export { TryCatchAsyncResult, TryCatchResult, compose, ifElse, pipe, unless, when } from './flow/index.mjs';
 import { debug, invariant, assertNever, exhaustive, todo, deprecated, measure, measureAsync, setLogLevel, getLogLevel } from './dx/index.mjs';
 export { LogLevel, MeasureResult, log } from './dx/index.mjs';
 export { A as ArrayElement, b as Awaited, B as Brand, c as DeepPartial, d as DeepReadonly, e as DeepRequired, f as Dictionary, E as ElementOf, g as EnumValue, K as KeysOfType, M as Merge, i as Mutable, j as NonNullableDeep, k as Nullable, O as Optional, l as OptionalKeys, n as PartialBy, P as Prettify, o as PromiseValue, R as ReadonlyDictionary, p as RequireAtLeastOne, q as RequireExactlyOne, r as RequireKeys, s as RequiredBy, U as UnionToIntersection, V as ValueOf, u as brand, v as createMap, w as createSet, x as defineConst, y as defineEnum, z as defineTuple, C as narrow } from './types-CPlzx7Jp.mjs';
 import { capitalize, uncapitalize, camelCase, kebabCase, snakeCase, pascalCase, truncate, slugify, template, words } from './string/index.mjs';
-import { memoize, negate, flip, partial, curry, ary, unary } from './fn/index.mjs';
+import { negate, flip, partial, curry, ary, unary } from './fn/index.mjs';
+export { memoize } from './fn/index.mjs';
 import { sum, average, median, round, randomInt, randomFloat, percentage, min, max } from './math/index.mjs';
 export { E as Err, N as None, O as Ok, a as Option, R as Result, S as Some } from './types-VsDp2t8s.mjs';
-import { ok, err, some, none, mapResult, mapOption, mapErr, andThen, orElse, matchResult, matchOption, isOk, isErr, unwrap, unwrapOption, unwrapOr, unwrapOptionOr, fromNullable, toNullable } from './result/index.mjs';
+import { ok, err, some as some$1, none, mapResult, mapOption, mapErr, orElse, matchResult, matchOption, isOk, isErr, unwrapOption, unwrapOr, unwrapOptionOr, fromNullable, toNullable } from './result/index.mjs';
+export { andThen, unwrap } from './result/index.mjs';
 import { Memoize, Debounce, Throttle, Bind, Log, Measure, Retry, Deprecated, Sealed, Frozen, Validate, Lazy } from './decorator/index.mjs';
+import { when, whenValue, unless, unlessValue, ifElse, ifElseLazy, cond, condLazy, condBy, matchValue, matchWithDefault, matchLazy, matchType, and, allTrue, andThen, or, anyTrue, orThen, notFn, coalesce, coalesceLazy, defaultTo, defaultToLazy, defaultToIf, defaultToIfEmpty, firstTruthy, firstWhere, firstDefined, allTruthy, allWhere, allDefined, get, getTyped, getPath, getOr, getPathOr, getOrLazy, tryGet, tryGetOr, tryGetResult, safe, unwrap, chain, optionalOr, optionalChain } from './logic/index.mjs';
+import { createIterator, lazyRange as range, lazyMap as map, lazyFilter as filter, lazyTake as take, lazySkip as skip, lazyChunk as chunk, lazyFlatten as flatten, lazyZip as zip, enumerate, cycle, repeat, fromAsync, toArray, iterReduce as reduce, iterForEach as forEach, iterFind as find, iterSome as some, iterEvery as every } from './iterator/index.mjs';
+import { filterDefined, filterDefinedFn, filterTruthy, filterTruthyFn, filterByGuard, filterByRefinement, filterBy, partitionByGuard, assertType, assertDefined, assertNotNull, assertCondition, createAssertion, narrowUnion, createDiscriminantGuard, switchUnion, exhaustiveCheck, excludeNull, excludeUndefined, excludeNullish, withDefault, withDefaultLazy, mapNullable, chainNullable, refine, oneOf, allOf, not, arrayOf, objectOf } from './narrowing/index.mjs';
+import { string, number, boolean, literal, array, object, optional, nullable, union as union$1, intersection, record, tuple, unknownSchema as unknown, anySchema as any, date, email, url, uuid, parse, safeParse, validate, is, parseJson, createGuard, createParser } from './schema/index.mjs';
+
+/**
+ * Type-Safe Environment Variables
+ */
+type EnvSchema = Record<string, EnvVar<unknown>>;
+interface EnvVar<T> {
+    _type: T;
+    _parse: (value: string | undefined) => T;
+    _default?: T | undefined;
+}
+/**
+ * Environment variable type builders
+ */
+declare const env: {
+    /**
+     * String environment variable
+     */
+    string(options?: {
+        default?: string;
+    }): EnvVar<string>;
+    /**
+     * Number environment variable
+     */
+    number(options?: {
+        default?: number;
+    }): EnvVar<number>;
+    /**
+     * Boolean environment variable
+     */
+    boolean(options?: {
+        default?: boolean;
+    }): EnvVar<boolean>;
+    /**
+     * Enum environment variable
+     */
+    enum<T extends string>(values: readonly T[], options?: {
+        default?: T;
+    }): EnvVar<T>;
+    /**
+     * URL environment variable
+     */
+    url(options?: {
+        default?: string;
+    }): EnvVar<string>;
+    /**
+     * JSON environment variable
+     */
+    json<T>(options?: {
+        default?: T;
+    }): EnvVar<T>;
+    /**
+     * Array environment variable (comma-separated)
+     */
+    array(options?: {
+        default?: string[];
+        separator?: string;
+    }): EnvVar<string[]>;
+};
+type InferEnv<T extends EnvSchema> = {
+    [K in keyof T]: T[K]['_type'];
+};
+/**
+ * Creates a type-safe environment configuration.
+ *
+ * @example
+ * const config = createEnv({
+ *   DATABASE_URL: env.url(),
+ *   API_KEY: env.string(),
+ *   PORT: env.number({ default: 3000 }),
+ *   NODE_ENV: env.enum(['development', 'production', 'test'] as const),
+ *   DEBUG: env.boolean({ default: false }),
+ *   ALLOWED_ORIGINS: env.array({ default: ['localhost'] }),
+ * })
+ *
+ * // All values are typed!
+ * config.DATABASE_URL // string (validated as URL)
+ * config.PORT         // number
+ * config.NODE_ENV     // 'development' | 'production' | 'test'
+ * config.DEBUG        // boolean
+ */
+declare function createEnv<T extends EnvSchema>(schema: T, envSource?: Record<string, string | undefined>): InferEnv<T>;
+
+/**
+ * Type-Safe Feature Flags
+ */
+type FlagType = 'boolean' | 'string' | 'number';
+interface FlagConfig {
+    type: FlagType;
+    default: unknown;
+}
+type InferFlagType<T extends FlagType> = T extends 'boolean' ? boolean : T extends 'string' ? string : T extends 'number' ? number : never;
+type FlagSchema = Record<string, FlagConfig>;
+type InferFlags<T extends FlagSchema> = {
+    [K in keyof T]: InferFlagType<T[K]['type']>;
+};
+/**
+ * Flag type builders
+ */
+declare const flag: {
+    boolean(defaultValue?: boolean): FlagConfig;
+    string(defaultValue?: string): FlagConfig;
+    number(defaultValue?: number): FlagConfig;
+};
+interface FeatureFlags<T extends FlagSchema> {
+    /** Check if a boolean flag is enabled */
+    is<K extends keyof T>(key: K): T[K]['type'] extends 'boolean' ? boolean : never;
+    /** Get a flag value */
+    get<K extends keyof T>(key: K): InferFlagType<T[K]['type']>;
+    /** Set a flag value */
+    set<K extends keyof T>(key: K, value: InferFlagType<T[K]['type']>): void;
+    /** Get all flags */
+    all(): InferFlags<T>;
+    /** Reset all flags to defaults */
+    reset(): void;
+    /** Load flags from an object */
+    load(flags: Partial<InferFlags<T>>): void;
+}
+/**
+ * Creates a type-safe feature flag system.
+ *
+ * @example
+ * const flags = createFeatureFlags({
+ *   newDashboard: flag.boolean(false),
+ *   betaFeatures: flag.boolean(false),
+ *   maxUploadSize: flag.number(10),
+ *   theme: flag.string('light'),
+ * })
+ *
+ * // Check boolean flags
+ * if (flags.is('newDashboard')) {
+ *   renderNewDashboard()
+ * }
+ *
+ * // Get any flag value
+ * const maxSize = flags.get('maxUploadSize') // number
+ * const theme = flags.get('theme') // string
+ *
+ * // Set flags
+ * flags.set('betaFeatures', true)
+ * flags.set('maxUploadSize', 50)
+ *
+ * // Load from config/API
+ * flags.load({
+ *   newDashboard: true,
+ *   maxUploadSize: 100,
+ * })
+ */
+declare function createFeatureFlags<T extends FlagSchema>(schema: T): FeatureFlags<T>;
+
+/**
+ * Reactive Signals - Fine-grained reactivity like Solid.js
+ *
+ * Signals are the foundation of reactive programming.
+ * They hold a value and notify subscribers when it changes.
+ */
+type Subscriber<T> = (value: T) => void;
+type Unsubscribe$1 = () => void;
+interface Signal<T> {
+    /** Get the current value */
+    (): T;
+    /** Set a new value */
+    set(value: T): void;
+    /** Update value using a function */
+    update(fn: (current: T) => T): void;
+    /** Subscribe to changes */
+    subscribe(fn: Subscriber<T>): Unsubscribe$1;
+    /** Get value without tracking */
+    peek(): T;
+}
+interface ReadonlySignal<T> {
+    /** Get the current value */
+    (): T;
+    /** Subscribe to changes */
+    subscribe(fn: Subscriber<T>): Unsubscribe$1;
+    /** Get value without tracking */
+    peek(): T;
+}
+/**
+ * Creates a reactive signal that notifies subscribers on change.
+ *
+ * @example
+ * const count = signal(0)
+ *
+ * // Read value
+ * console.log(count()) // 0
+ *
+ * // Set value
+ * count.set(5)
+ *
+ * // Update with function
+ * count.update(n => n + 1)
+ *
+ * // Subscribe to changes
+ * const unsubscribe = count.subscribe(value => {
+ *   console.log('Count changed:', value)
+ * })
+ */
+declare function signal<T>(initialValue: T): Signal<T>;
+/**
+ * Creates a computed value that automatically updates when dependencies change.
+ *
+ * @example
+ * const firstName = signal('John')
+ * const lastName = signal('Doe')
+ *
+ * const fullName = computed(() => `${firstName()} ${lastName()}`)
+ *
+ * console.log(fullName()) // "John Doe"
+ *
+ * firstName.set('Jane')
+ * console.log(fullName()) // "Jane Doe"
+ */
+declare function computed<T>(fn: () => T): ReadonlySignal<T>;
+/**
+ * Runs a function whenever its dependencies change.
+ *
+ * @example
+ * const count = signal(0)
+ *
+ * const stop = effect(() => {
+ *   console.log('Count is:', count())
+ * })
+ *
+ * count.set(1) // Logs: "Count is: 1"
+ * count.set(2) // Logs: "Count is: 2"
+ *
+ * stop() // Stop the effect
+ */
+declare function effect(fn: () => void | (() => void)): Unsubscribe$1;
+declare function batch(fn: () => void): void;
+
+/**
+ * Undoable State - State management with undo/redo history
+ *
+ * Perfect for editors, forms, and any UI that needs history.
+ */
+
+interface UndoableState<T> {
+    /** Current state value */
+    value: Signal<T>;
+    /** Undo the last change */
+    undo(): void;
+    /** Redo the last undone change */
+    redo(): void;
+    /** Check if undo is available */
+    canUndo(): boolean;
+    /** Check if redo is available */
+    canRedo(): boolean;
+    /** Clear all history */
+    clearHistory(): void;
+    /** Get history length */
+    historyLength(): number;
+    /** Commit current state (creates a checkpoint) */
+    commit(): void;
+}
+interface UndoableOptions {
+    /** Maximum history size (default: 100) */
+    maxHistory?: number;
+    /** Debounce commits in ms (default: 0 = no debounce) */
+    debounce?: number;
+}
+/**
+ * Creates an undoable state with undo/redo capabilities.
+ *
+ * @example
+ * const state = createUndoableState({ count: 0, text: '' })
+ *
+ * state.value.set({ count: 1, text: 'hello' })
+ * state.commit()
+ *
+ * state.value.set({ count: 2, text: 'world' })
+ * state.commit()
+ *
+ * console.log(state.value().count) // 2
+ *
+ * state.undo()
+ * console.log(state.value().count) // 1
+ *
+ * state.redo()
+ * console.log(state.value().count) // 2
+ *
+ * @example
+ * // With auto-commit on every change
+ * const counter = createUndoableState(0)
+ *
+ * counter.value.set(1)
+ * counter.commit()
+ * counter.value.set(2)
+ * counter.commit()
+ *
+ * counter.undo() // Back to 1
+ * counter.undo() // Back to 0
+ */
+declare function createUndoableState<T>(initialValue: T, options?: UndoableOptions): UndoableState<T>;
+/**
+ * Creates an undoable state that auto-commits on every change.
+ *
+ * @example
+ * const state = createAutoUndoableState({ name: '', age: 0 })
+ *
+ * state.set({ name: 'John', age: 30 })
+ * state.set({ name: 'Jane', age: 25 })
+ *
+ * state.undo() // { name: 'John', age: 30 }
+ * state.undo() // { name: '', age: 0 }
+ */
+declare function createAutoUndoableState<T>(initialValue: T, options?: UndoableOptions): {
+    (): T;
+    set(value: T): void;
+    update(fn: (current: T) => T): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+};
+
+/**
+ * Smart Cache - Intelligent caching with TTL and invalidation
+ */
+interface CacheOptions<K extends unknown[], V> {
+    /** Time to live in milliseconds or string like '5m', '1h', '1d' */
+    ttl?: number | string;
+    /** Maximum cache size */
+    maxSize?: number;
+    /** Custom key generator */
+    key?: (...args: K) => string;
+    /** Events that invalidate the cache */
+    invalidateOn?: string[];
+    /** Called when cache is hit */
+    onHit?: (key: string, value: V) => void;
+    /** Called when cache is missed */
+    onMiss?: (key: string) => void;
+}
+/**
+ * Creates a smart cache wrapper around a function.
+ *
+ * @example
+ * const fetchUser = smartCache(
+ *   async (userId: string) => {
+ *     const response = await fetch(`/api/users/${userId}`)
+ *     return response.json()
+ *   },
+ *   {
+ *     ttl: '5m',
+ *     maxSize: 100,
+ *     key: (userId) => `user:${userId}`
+ *   }
+ * )
+ *
+ * // First call - fetches from API
+ * const user1 = await fetchUser('123')
+ *
+ * // Second call - returns cached value
+ * const user2 = await fetchUser('123')
+ *
+ * // Invalidate cache
+ * fetchUser.invalidate('123')
+ *
+ * // Clear all cache
+ * fetchUser.clear()
+ */
+declare function smartCache<K extends unknown[], V>(fn: (...args: K) => V | Promise<V>, options?: CacheOptions<K, V>): ((...args: K) => Promise<V>) & {
+    invalidate: (...args: K) => void;
+    invalidateAll: () => void;
+    clear: () => void;
+    has: (...args: K) => boolean;
+    size: () => number;
+};
+/**
+ * Creates a simple memoization cache (no TTL, infinite size).
+ *
+ * @example
+ * const expensive = memoize((n: number) => {
+ *   console.log('Computing...')
+ *   return n * n
+ * })
+ *
+ * expensive(5) // Logs "Computing...", returns 25
+ * expensive(5) // Returns 25 (cached)
+ */
+declare function memoize<K extends unknown[], V>(fn: (...args: K) => V): (...args: K) => V;
+
+/**
+ * Type-Safe Event Bus - Decoupled communication with full type safety
+ */
+type EventHandler<T> = (data: T) => void;
+type Unsubscribe = () => void;
+interface EventBus<Events extends Record<string, unknown>> {
+    /** Subscribe to an event */
+    on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): Unsubscribe;
+    /** Subscribe to an event (fires only once) */
+    once<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): Unsubscribe;
+    /** Emit an event */
+    emit<K extends keyof Events>(event: K, data: Events[K]): void;
+    /** Remove all handlers for an event */
+    off<K extends keyof Events>(event: K): void;
+    /** Remove all handlers */
+    clear(): void;
+    /** Get number of handlers for an event */
+    listenerCount<K extends keyof Events>(event: K): number;
+}
+/**
+ * Creates a type-safe event bus for decoupled communication.
+ *
+ * @example
+ * // Define your events with their payload types
+ * type AppEvents = {
+ *   'user.login': { userId: string; timestamp: number }
+ *   'user.logout': { userId: string }
+ *   'order.created': { orderId: string; amount: number }
+ *   'notification': string
+ * }
+ *
+ * const events = createEventBus<AppEvents>()
+ *
+ * // Subscribe to events (fully typed!)
+ * events.on('user.login', (data) => {
+ *   console.log(`User ${data.userId} logged in at ${data.timestamp}`)
+ * })
+ *
+ * // Emit events (type-checked!)
+ * events.emit('user.login', {
+ *   userId: '123',
+ *   timestamp: Date.now()
+ * })
+ *
+ * // TypeScript error: missing 'timestamp'
+ * events.emit('user.login', { userId: '123' })
+ *
+ * // TypeScript error: unknown event
+ * events.emit('unknown.event', {})
+ */
+declare function createEventBus<Events extends Record<string, unknown>>(): EventBus<Events>;
+/**
+ * Creates a typed event emitter for a single component/class.
+ *
+ * @example
+ * class UserService {
+ *   private events = createTypedEmitter<{
+ *     created: User
+ *     updated: User
+ *     deleted: string
+ *   }>()
+ *
+ *   readonly on = this.events.on
+ *
+ *   async createUser(data: CreateUserDto) {
+ *     const user = await db.users.create(data)
+ *     this.events.emit('created', user)
+ *     return user
+ *   }
+ * }
+ */
+declare function createTypedEmitter<Events extends Record<string, unknown>>(): EventBus<Events>;
+
+/**
+ * Pipeline - Functional composition with full type inference
+ */
+/**
+ * Pipes a value through a series of functions.
+ * Each function receives the result of the previous one.
+ *
+ * @example
+ * const result = pipe(
+ *   [1, 2, 3, 4, 5],
+ *   arr => arr.filter(x => x % 2 === 0),
+ *   arr => arr.map(x => x * 2),
+ *   arr => arr.reduce((a, b) => a + b, 0)
+ * )
+ * // result: 12
+ *
+ * @example
+ * // With async functions
+ * const user = await pipeAsync(
+ *   userId,
+ *   id => fetchUser(id),
+ *   user => enrichUserData(user),
+ *   user => validateUser(user)
+ * )
+ */
+declare function pipe<A>(value: A): A;
+declare function pipe<A, B>(value: A, fn1: (a: A) => B): B;
+declare function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;
+declare function pipe<A, B, C, D>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): D;
+declare function pipe<A, B, C, D, E>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): E;
+declare function pipe<A, B, C, D, E, F>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): F;
+declare function pipe<A, B, C, D, E, F, G>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G): G;
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I): I;
+/**
+ * Async version of pipe that handles promises.
+ */
+declare function pipeAsync<A>(value: A): Promise<A>;
+declare function pipeAsync<A, B>(value: A, fn1: (a: A) => B | Promise<B>): Promise<B>;
+declare function pipeAsync<A, B, C>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>): Promise<C>;
+declare function pipeAsync<A, B, C, D>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>): Promise<D>;
+declare function pipeAsync<A, B, C, D, E>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>): Promise<E>;
+declare function pipeAsync<A, B, C, D, E, F>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>, fn5: (e: E) => F | Promise<F>): Promise<F>;
+/**
+ * Creates a pipeline function that can be reused.
+ *
+ * @example
+ * const processUser = flow(
+ *   (user: User) => validateUser(user),
+ *   user => enrichUser(user),
+ *   user => formatUser(user)
+ * )
+ *
+ * const result = processUser(rawUser)
+ */
+declare function flow<A, B>(fn1: (a: A) => B): (a: A) => B;
+declare function flow<A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;
+declare function flow<A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;
+declare function flow<A, B, C, D, E>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): (a: A) => E;
+declare function flow<A, B, C, D, E, F>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): (a: A) => F;
+
+/**
+ * Middleware Pipeline - Express-style middleware with type safety
+ */
+type NextFunction = () => Promise<void> | void;
+type Middleware<Context> = (ctx: Context, next: NextFunction) => Promise<void> | void;
+interface MiddlewarePipeline<Context> {
+    /** Add a middleware to the pipeline */
+    use(middleware: Middleware<Context>): MiddlewarePipeline<Context>;
+    /** Execute the pipeline with a context */
+    execute(ctx: Context): Promise<void>;
+    /** Create a handler that executes the pipeline */
+    handler(): (ctx: Context) => Promise<void>;
+}
+/**
+ * Creates a middleware pipeline for processing requests or data.
+ *
+ * @example
+ * interface RequestContext {
+ *   user?: User
+ *   body: unknown
+ *   headers: Record<string, string>
+ * }
+ *
+ * const pipeline = createMiddleware<RequestContext>()
+ *   .use(async (ctx, next) => {
+ *     // Authentication
+ *     const token = ctx.headers['authorization']
+ *     ctx.user = await validateToken(token)
+ *     await next()
+ *   })
+ *   .use(async (ctx, next) => {
+ *     // Logging
+ *     console.log('Request from:', ctx.user?.id)
+ *     await next()
+ *     console.log('Request completed')
+ *   })
+ *   .use(async (ctx, next) => {
+ *     // Rate limiting
+ *     await checkRateLimit(ctx.user?.id)
+ *     await next()
+ *   })
+ *
+ * // Execute the pipeline
+ * await pipeline.execute({
+ *   body: { name: 'John' },
+ *   headers: { authorization: 'Bearer ...' }
+ * })
+ */
+declare function createMiddleware<Context>(): MiddlewarePipeline<Context>;
+/**
+ * Composes multiple middlewares into a single middleware.
+ *
+ * @example
+ * const authMiddleware = compose(
+ *   validateToken,
+ *   checkPermissions,
+ *   loadUser
+ * )
+ *
+ * pipeline.use(authMiddleware)
+ */
+declare function compose<Context>(...middlewares: Middleware<Context>[]): Middleware<Context>;
+
+/**
+ * Dependency Injection Container - Type-safe DI with automatic resolution
+ */
+type Factory<T> = (container: Container) => T;
+type ServiceKey = string | symbol;
+interface Container {
+    /** Register a service factory */
+    register<T>(key: ServiceKey, factory: Factory<T>): Container;
+    /** Register a singleton service */
+    singleton<T>(key: ServiceKey, factory: Factory<T>): Container;
+    /** Register a constant value */
+    constant<T>(key: ServiceKey, value: T): Container;
+    /** Resolve a service by key */
+    resolve<T>(key: ServiceKey): T;
+    /** Check if a service is registered */
+    has(key: ServiceKey): boolean;
+    /** Create a child container */
+    createChild(): Container;
+}
+/**
+ * Creates a dependency injection container.
+ *
+ * @example
+ * // Define your services
+ * class Logger {
+ *   log(msg: string) { console.log(msg) }
+ * }
+ *
+ * class Database {
+ *   constructor(private logger: Logger) {}
+ *   query(sql: string) {
+ *     this.logger.log(`Executing: ${sql}`)
+ *     return []
+ *   }
+ * }
+ *
+ * class UserService {
+ *   constructor(private db: Database) {}
+ *   getUsers() {
+ *     return this.db.query('SELECT * FROM users')
+ *   }
+ * }
+ *
+ * // Create container and register services
+ * const container = createContainer()
+ *   .singleton('logger', () => new Logger())
+ *   .singleton('db', (c) => new Database(c.resolve('logger')))
+ *   .register('userService', (c) => new UserService(c.resolve('db')))
+ *
+ * // Resolve services
+ * const userService = container.resolve<UserService>('userService')
+ * userService.getUsers()
+ *
+ * @example
+ * // With constants
+ * const container = createContainer()
+ *   .constant('apiUrl', 'https://api.example.com')
+ *   .constant('apiKey', process.env.API_KEY)
+ *   .singleton('api', (c) => new ApiClient(
+ *     c.resolve('apiUrl'),
+ *     c.resolve('apiKey')
+ *   ))
+ */
+declare function createContainer(parent?: Container): Container;
+/**
+ * Creates a typed container with predefined service types.
+ *
+ * @example
+ * interface Services {
+ *   logger: Logger
+ *   db: Database
+ *   userService: UserService
+ * }
+ *
+ * const container = createTypedContainer<Services>()
+ *   .singleton('logger', () => new Logger())
+ *   .singleton('db', (c) => new Database(c.resolve('logger')))
+ *
+ * // Fully typed!
+ * const logger = container.resolve('logger') // Type: Logger
+ */
+declare function createTypedContainer<Services extends Record<string, unknown>>(): {
+    register<K extends keyof Services>(key: K, factory: (container: {
+        resolve<K2 extends keyof Services>(key: K2): Services[K2];
+    }) => Services[K]): ReturnType<typeof createTypedContainer<Services>>;
+    singleton<K extends keyof Services>(key: K, factory: (container: {
+        resolve<K2 extends keyof Services>(key: K2): Services[K2];
+    }) => Services[K]): ReturnType<typeof createTypedContainer<Services>>;
+    constant<K extends keyof Services>(key: K, value: Services[K]): ReturnType<typeof createTypedContainer<Services>>;
+    resolve<K extends keyof Services>(key: K): Services[K];
+    has(key: keyof Services): boolean;
+};
+
+/**
+ * Type-Safe Router - Routes with typed parameters
+ */
+type ParamType = 'string' | 'number' | 'boolean';
+interface RouteParams {
+    [key: string]: ParamType;
+}
+type InferParamType<T extends ParamType> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : never;
+type InferParams<T extends RouteParams> = {
+    [K in keyof T]: InferParamType<T[K]>;
+};
+interface Route<Params extends RouteParams = Record<string, never>> {
+    path: string;
+    params: Params;
+    build: (params: InferParams<Params>) => string;
+    match: (path: string) => InferParams<Params> | null;
+}
+/**
+ * Creates a type-safe route definition.
+ *
+ * @example
+ * const userRoute = route('/users/:id', { id: 'string' })
+ *
+ * // Build URL (type-checked!)
+ * userRoute.build({ id: '123' }) // '/users/123'
+ *
+ * // Match URL
+ * userRoute.match('/users/123') // { id: '123' }
+ * userRoute.match('/posts/123') // null
+ */
+declare function route<Params extends RouteParams = Record<string, never>>(path: string, params?: Params): Route<Params>;
+interface Router<Routes extends Record<string, Route<RouteParams>>> {
+    routes: Routes;
+    navigate: <K extends keyof Routes>(name: K, params: Routes[K] extends Route<infer P> ? InferParams<P> : never) => string;
+    match: (path: string) => {
+        name: keyof Routes;
+        params: Record<string, unknown>;
+    } | null;
+}
+/**
+ * Creates a type-safe router with named routes.
+ *
+ * @example
+ * const router = createRouter({
+ *   home: route('/'),
+ *   users: route('/users'),
+ *   user: route('/users/:id', { id: 'string' }),
+ *   post: route('/posts/:postId/comments/:commentId', {
+ *     postId: 'number',
+ *     commentId: 'number'
+ *   }),
+ * })
+ *
+ * // Navigate (fully typed!)
+ * router.navigate('user', { id: '123' }) // '/users/123'
+ * router.navigate('post', { postId: 1, commentId: 5 }) // '/posts/1/comments/5'
+ *
+ * // TypeScript error: missing 'id'
+ * router.navigate('user', {})
+ *
+ * // Match current path
+ * const matched = router.match('/users/123')
+ * // { name: 'user', params: { id: '123' } }
+ */
+declare function createRouter<Routes extends Record<string, Route<RouteParams>>>(routes: Routes): Router<Routes>;
+
+/**
+ * Type-Safe Form - Form handling with validation
+ */
+
+interface FieldState<T> {
+    value: Signal<T>;
+    error: Signal<string | null>;
+    touched: Signal<boolean>;
+    dirty: Signal<boolean>;
+}
+interface FormState<T extends Record<string, unknown>> {
+    fields: {
+        [K in keyof T]: FieldState<T[K]>;
+    };
+    values: () => T;
+    errors: () => Partial<Record<keyof T, string>>;
+    isValid: () => boolean;
+    isDirty: () => boolean;
+    isTouched: () => boolean;
+    reset: () => void;
+    validate: () => boolean;
+    submit: (handler: (values: T) => void | Promise<void>) => Promise<void>;
+}
+type Validator<T> = (value: T) => string | null;
+interface FieldConfig<T> {
+    initial: T;
+    validate?: Validator<T> | undefined;
+}
+/**
+ * Creates a form field configuration.
+ */
+declare function field<T>(initial: T, validate?: Validator<T>): FieldConfig<T>;
+/**
+ * Creates a type-safe form with validation.
+ *
+ * @example
+ * const form = createForm({
+ *   email: field('', (v) => !v.includes('@') ? 'Invalid email' : null),
+ *   password: field('', (v) => v.length < 8 ? 'Min 8 characters' : null),
+ *   remember: field(false),
+ * })
+ *
+ * // Access field values
+ * form.fields.email.value.set('test@example.com')
+ *
+ * // Check validation
+ * console.log(form.isValid()) // true/false
+ * console.log(form.errors()) // { email: null, password: 'Min 8 characters' }
+ *
+ * // Submit form
+ * await form.submit(async (values) => {
+ *   await api.login(values)
+ * })
+ *
+ * // Reset form
+ * form.reset()
+ */
+declare function createForm<T extends Record<string, unknown>>(config: {
+    [K in keyof T]: FieldConfig<T[K]>;
+}): FormState<T>;
 
 /**
  * Creates a new array concatenating array with any additional arrays and/or values.
@@ -487,6 +1295,178 @@ declare function zipWith<T, R>(iteratee: (...values: T[]) => R, ...arrays: reado
  * ```
  */
 declare const _: {
+    createFeatureFlags: typeof createFeatureFlags;
+    flag: {
+        boolean(defaultValue?: boolean): FlagConfig;
+        string(defaultValue?: string): FlagConfig;
+        number(defaultValue?: number): FlagConfig;
+    };
+    createForm: typeof createForm;
+    field: typeof field;
+    route: typeof route;
+    createRouter: typeof createRouter;
+    env: {
+        string(options?: {
+            default?: string;
+        }): EnvVar<string>;
+        number(options?: {
+            default?: number;
+        }): EnvVar<number>;
+        boolean(options?: {
+            default?: boolean;
+        }): EnvVar<boolean>;
+        enum<T extends string>(values: readonly T[], options?: {
+            default?: T;
+        }): EnvVar<T>;
+        url(options?: {
+            default?: string;
+        }): EnvVar<string>;
+        json<T>(options?: {
+            default?: T;
+        }): EnvVar<T>;
+        array(options?: {
+            default?: string[];
+            separator?: string;
+        }): EnvVar<string[]>;
+    };
+    createEnv: typeof createEnv;
+    createContainer: typeof createContainer;
+    createTypedContainer: typeof createTypedContainer;
+    pipe: typeof pipe;
+    pipeAsync: typeof pipeAsync;
+    flow: typeof flow;
+    createMiddleware: typeof createMiddleware;
+    compose: typeof compose;
+    createEventBus: typeof createEventBus;
+    createTypedEmitter: typeof createTypedEmitter;
+    smartCache: typeof smartCache;
+    memoize: typeof memoize;
+    signal: typeof signal;
+    computed: typeof computed;
+    effect: typeof effect;
+    batch: typeof batch;
+    createUndoableState: typeof createUndoableState;
+    createAutoUndoableState: typeof createAutoUndoableState;
+    string: typeof string;
+    number: typeof number;
+    boolean: typeof boolean;
+    literal: typeof literal;
+    array: typeof array;
+    object: typeof object;
+    optional: typeof optional;
+    nullable: typeof nullable;
+    union: typeof union$1;
+    intersection: typeof intersection;
+    record: typeof record;
+    tuple: typeof tuple;
+    unknownSchema: typeof unknown;
+    anySchema: typeof any;
+    date: typeof date;
+    email: typeof email;
+    url: typeof url;
+    uuid: typeof uuid;
+    parse: typeof parse;
+    safeParse: typeof safeParse;
+    validate: typeof validate;
+    is: typeof is;
+    parseJson: typeof parseJson;
+    createGuard: typeof createGuard;
+    createParser: typeof createParser;
+    filterDefined: typeof filterDefined;
+    filterDefinedFn: typeof filterDefinedFn;
+    filterTruthy: typeof filterTruthy;
+    filterTruthyFn: typeof filterTruthyFn;
+    filterByGuard: typeof filterByGuard;
+    filterByRefinement: typeof filterByRefinement;
+    filterBy: typeof filterBy;
+    partitionByGuard: typeof partitionByGuard;
+    assertType: typeof assertType;
+    assertDefined: typeof assertDefined;
+    assertNotNull: typeof assertNotNull;
+    assertCondition: typeof assertCondition;
+    createAssertion: typeof createAssertion;
+    narrowUnion: typeof narrowUnion;
+    createDiscriminantGuard: typeof createDiscriminantGuard;
+    switchUnion: typeof switchUnion;
+    exhaustiveCheck: typeof exhaustiveCheck;
+    excludeNull: typeof excludeNull;
+    excludeUndefined: typeof excludeUndefined;
+    excludeNullish: typeof excludeNullish;
+    withDefault: typeof withDefault;
+    withDefaultLazy: typeof withDefaultLazy;
+    mapNullable: typeof mapNullable;
+    chainNullable: typeof chainNullable;
+    refine: typeof refine;
+    oneOf: typeof oneOf;
+    allOf: typeof allOf;
+    not: typeof not;
+    arrayOf: typeof arrayOf;
+    objectOf: typeof objectOf;
+    createIterator: typeof createIterator;
+    lazyRange: typeof range;
+    lazyMap: typeof map;
+    lazyFilter: typeof filter;
+    lazyTake: typeof take;
+    lazySkip: typeof skip;
+    lazyChunk: typeof chunk;
+    lazyFlatten: typeof flatten;
+    lazyZip: typeof zip;
+    enumerate: typeof enumerate;
+    cycle: typeof cycle;
+    repeat: typeof repeat;
+    fromAsync: typeof fromAsync;
+    toArray: typeof toArray;
+    iterReduce: typeof reduce;
+    iterForEach: typeof forEach;
+    iterFind: typeof find;
+    iterSome: typeof some;
+    iterEvery: typeof every;
+    when: typeof when;
+    whenValue: typeof whenValue;
+    unless: typeof unless;
+    unlessValue: typeof unlessValue;
+    ifElse: typeof ifElse;
+    ifElseLazy: typeof ifElseLazy;
+    cond: typeof cond;
+    condLazy: typeof condLazy;
+    condBy: typeof condBy;
+    matchValue: typeof matchValue;
+    matchWithDefault: typeof matchWithDefault;
+    matchLazy: typeof matchLazy;
+    matchType: typeof matchType;
+    and: typeof and;
+    allTrue: typeof allTrue;
+    andThen: typeof andThen;
+    or: typeof or;
+    anyTrue: typeof anyTrue;
+    orThen: typeof orThen;
+    notFn: typeof notFn;
+    coalesce: typeof coalesce;
+    coalesceLazy: typeof coalesceLazy;
+    defaultTo: typeof defaultTo;
+    defaultToLazy: typeof defaultToLazy;
+    defaultToIf: typeof defaultToIf;
+    defaultToIfEmpty: typeof defaultToIfEmpty;
+    firstTruthy: typeof firstTruthy;
+    firstWhere: typeof firstWhere;
+    firstDefined: typeof firstDefined;
+    allTruthy: typeof allTruthy;
+    allWhere: typeof allWhere;
+    allDefined: typeof allDefined;
+    get: typeof get;
+    getTyped: typeof getTyped;
+    getPath: typeof getPath;
+    getOr: typeof getOr;
+    getPathOr: typeof getPathOr;
+    getOrLazy: typeof getOrLazy;
+    tryGet: typeof tryGet;
+    tryGetOr: typeof tryGetOr;
+    tryGetResult: typeof tryGetResult;
+    safe: typeof safe;
+    unwrap: typeof unwrap;
+    chain: typeof chain;
+    optionalOr: typeof optionalOr;
+    optionalChain: typeof optionalChain;
     concat: typeof concat;
     differenceBy: typeof differenceBy;
     differenceWith: typeof differenceWith;
@@ -522,7 +1502,6 @@ declare const _: {
     sortedUniqBy: typeof sortedUniqBy;
     takeRight: typeof takeRight;
     takeRightWhile: typeof takeRightWhile;
-    union: typeof union;
     unionBy: typeof unionBy;
     unionWith: typeof unionWith;
     uniqBy: typeof uniqBy;
@@ -549,18 +1528,16 @@ declare const _: {
     Lazy: typeof Lazy;
     ok: typeof ok;
     err: typeof err;
-    some: typeof some;
+    some: typeof some$1;
     none: typeof none;
     mapResult: typeof mapResult;
     mapOption: typeof mapOption;
     mapErr: typeof mapErr;
-    andThen: typeof andThen;
     orElse: typeof orElse;
     matchResult: typeof matchResult;
     matchOption: typeof matchOption;
     isOk: typeof isOk;
     isErr: typeof isErr;
-    unwrap: typeof unwrap;
     unwrapOption: typeof unwrapOption;
     unwrapOr: typeof unwrapOr;
     unwrapOptionOr: typeof unwrapOptionOr;
@@ -575,7 +1552,6 @@ declare const _: {
     percentage: typeof percentage;
     min: typeof min;
     max: typeof max;
-    memoize: typeof memoize;
     negate: typeof negate;
     flip: typeof flip;
     partial: typeof partial;
@@ -608,15 +1584,10 @@ declare const _: {
     };
     setLogLevel: typeof setLogLevel;
     getLogLevel: typeof getLogLevel;
-    pipe: typeof pipe;
-    compose: typeof compose;
     tap: typeof tap;
-    when: typeof when;
-    unless: typeof unless;
     match: typeof match;
     tryCatch: typeof tryCatch;
     tryCatchAsync: typeof tryCatchAsync;
-    ifElse: typeof ifElse;
     constant: typeof constant;
     safeJsonParse: typeof safeJsonParse;
     safeJsonStringify: typeof safeJsonStringify;
@@ -638,20 +1609,19 @@ declare const _: {
     groupBy: typeof groupBy;
     indexBy: typeof indexBy;
     partition: typeof partition;
-    chunk: typeof chunk;
+    chunk: typeof chunk$1;
     compact: typeof compact;
-    flatten: typeof flatten;
+    flatten: typeof flatten$1;
     sortBy: typeof sortBy;
     first: typeof first;
     last: typeof last;
-    range: typeof range;
+    range: typeof range$1;
     shuffle: typeof shuffle;
     sample: typeof sample;
-    zip: typeof zip;
+    zip: typeof zip$1;
     unzip: typeof unzip;
     difference: typeof difference;
-    intersection: typeof intersection;
-    take: typeof take;
+    take: typeof take$1;
     drop: typeof drop;
     takeWhile: typeof takeWhile;
     dropWhile: typeof dropWhile;
@@ -684,7 +1654,6 @@ declare const _: {
     mergeShallow: typeof mergeShallow;
     clone: typeof clone;
     cloneDeep: typeof cloneDeep;
-    get: typeof get;
     set: typeof set;
     invert: typeof invert;
     deepMerge: typeof deepMerge;
@@ -747,7 +1716,6 @@ declare const _: {
     isTypedArray: typeof isTypedArray;
     isWeakMap: typeof isWeakMap;
     isWeakSet: typeof isWeakSet;
-    toArray: typeof toArray;
     toFinite: typeof toFinite;
     toInteger: typeof toInteger;
     toLength: typeof toLength;
@@ -758,11 +1726,10 @@ declare const _: {
     isDefined: typeof isDefined;
     isNil: typeof isNil;
     assert: typeof assert;
-    assertDefined: typeof assertDefined;
     fail: typeof fail;
     noop: typeof noop;
     identity: typeof identity;
     unreachable: typeof unreachable;
 };
 
-export { Bind, Debounce, Deprecated, Frozen, Lazy, Log, Measure, Memoize, Retry, Sealed, Throttle, Validate, _, andThen, ary, assert, assertDefined, assertNever, average, awaitTo, camelCase, capitalize, castArray, chunk, clamp, clone, cloneDeep, cloneDeepWith, cloneWith, coerceArray, coerceString, compact, compose, concat, conformsTo, constant, countBy, curry, debounce, debug, deepMerge, _ as default, defaults, defer, deprecated, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, entriesTyped, eq, err, exhaustive, fail, fill, filterObject, findIndex, findLast, findLastIndex, first, flatten, flattenDeep, flattenDepth, flip, fromEntriesTyped, fromNullable, fromPairs, get, getLogLevel, groupBy, gt, gte, has, hasKey, hasKeys, head, identity, ifElse, indexBy, indexOf, init, intersection, intersectionBy, intersectionWith, invariant, invert, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isDefined, isElement, isEmail, isEmpty, isEqual, isEqualWith, isErr, isError, isFinite, isFunction, isInteger, isIpAddress, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNonEmpty, isNull, isNumber, isObject, isObjectLike, isOk, isPlainObject, isPromise, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isUrl, isUuid, isWeakMap, isWeakSet, join, kebabCase, keysTyped, last, lastIndexOf, lt, lte, mapErr, mapObject, mapOption, mapResult, match, matchOption, matchResult, max, maxBy, measure, measureAsync, median, memoize, mergeShallow, min, minBy, negate, none, noop, nth, ok, omit, once, onceAsync, orElse, parallel, parseBoolean, parseDate, parseInteger, parseNumber, parseUrl, partial, partition, pascalCase, paths, percentage, pick, pipe, pull, pullAll, pullAllBy, pullAllWith, pullAt, randomFloat, randomInt, range, remove, retry, reverse, round, safeJsonParse, safeJsonStringify, sample, set, setLogLevel, shuffle, sleep, slice, slugify, snakeCase, some, sortBy, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, tap, template, throttle, toArray, toFinite, toInteger, toLength, toNullable, toNumber, toPlainObject, toSafeInteger, toString, todo, transform, trimAll, truncate, tryCatch, tryCatchAsync, unary, uncapitalize, union, unionBy, unionWith, uniqBy, uniqWith, unique, unless, unreachable, unset, unwrap, unwrapOption, unwrapOptionOr, unwrapOr, unzip, unzipWith, valuesTyped, when, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith };
+export { Bind, type CacheOptions, type Container, Debounce, Deprecated, type EventBus, type FeatureFlags, type FieldState, type FormState, Frozen, Lazy, Log, Measure, Memoize, type Middleware, type MiddlewarePipeline, type ReadonlySignal, Retry, type Route, type Router, Sealed, type Signal, Throttle, type UndoableOptions, type UndoableState, Validate, _, ary, assert, assertNever, average, awaitTo, batch, camelCase, capitalize, castArray, chunk$1 as chunk, clamp, clone, cloneDeep, cloneDeepWith, cloneWith, coerceArray, coerceString, compact, compose as composeMiddleware, computed, concat, conformsTo, constant, countBy, createAutoUndoableState, createContainer, createEnv, createEventBus, createFeatureFlags, createForm, createMiddleware, createRouter, createTypedContainer, createTypedEmitter, createUndoableState, curry, debounce, debug, deepMerge, _ as default, defaults, defer, deprecated, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, effect, entriesTyped, env, eq, err, exhaustive, fail, field, fill, filterObject, findIndex, findLast, findLastIndex, first, flag, flatten$1 as flatten, flattenDeep, flattenDepth, flip, flow, fromEntriesTyped, fromNullable, fromPairs, getLogLevel, groupBy, gt, gte, has, hasKey, hasKeys, head, identity, indexBy, indexOf, init, intersectionBy, intersectionWith, invariant, invert, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isDefined, isElement, isEmail, isEmpty, isEqual, isEqualWith, isErr, isError, isFinite, isFunction, isInteger, isIpAddress, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNonEmpty, isNull, isNumber, isObject, isObjectLike, isOk, isPlainObject, isPromise, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isUrl, isUuid, isWeakMap, isWeakSet, join, kebabCase, keysTyped, last, lastIndexOf, lt, lte, mapErr, mapObject, mapOption, mapResult, match, matchOption, matchResult, max, maxBy, measure, measureAsync, median, mergeShallow, min, minBy, negate, none, noop, nth, ok, omit, once, onceAsync, orElse, parallel, parseBoolean, parseDate, parseInteger, parseNumber, parseUrl, partial, partition, pascalCase, paths, percentage, pick, pipeAsync, pipe as pipeValue, pull, pullAll, pullAllBy, pullAllWith, pullAt, randomFloat, randomInt, range$1 as range, remove, retry, reverse, round, route, safeJsonParse, safeJsonStringify, sample, set, setLogLevel, shuffle, signal, sleep, slice, slugify, smartCache, memoize as smartMemoize, snakeCase, some$1 as some, sortBy, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, sum, sumBy, tail, take$1 as take, takeRight, takeRightWhile, takeWhile, tap, template, throttle, toFinite, toInteger, toLength, toNullable, toNumber, toPlainObject, toSafeInteger, toString, todo, transform, trimAll, truncate, tryCatch, tryCatchAsync, unary, uncapitalize, union, unionBy, unionWith, uniqBy, uniqWith, unique, unreachable, unset, unwrapOption, unwrapOptionOr, unwrapOr, unzip, unzipWith, valuesTyped, withTimeout, without, words, xor, xorBy, xorWith, zip$1 as zip, zipObject, zipObjectDeep, zipWith };