typetify 1.0.0 → 2.0.0

package/dist/index.d.mts

@@ -6,18 +6,817 @@ 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 { 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, when, unless, match, tryCatch, tryCatchAsync, ifElse, constant } from './flow/index.mjs';
+export { TryCatchAsyncResult, TryCatchResult, compose, pipe } 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 { Memoize, Debounce, Throttle, Bind, Log, Measure, Retry, Deprecated, Sealed, Frozen, Validate, Lazy } from './decorator/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 +1286,58 @@ 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;
     concat: typeof concat;
     differenceBy: typeof differenceBy;
     differenceWith: typeof differenceWith;
@@ -575,7 +1426,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,8 +1458,6 @@ declare const _: {
     };
     setLogLevel: typeof setLogLevel;
     getLogLevel: typeof getLogLevel;
-    pipe: typeof pipe;
-    compose: typeof compose;
     tap: typeof tap;
     when: typeof when;
     unless: typeof unless;
@@ -765,4 +1613,4 @@ declare const _: {
     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, _, andThen, ary, assert, assertDefined, assertNever, average, awaitTo, batch, camelCase, capitalize, castArray, 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, flattenDeep, flattenDepth, flip, flow, 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, 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, remove, retry, reverse, round, route, safeJsonParse, safeJsonStringify, sample, set, setLogLevel, shuffle, signal, sleep, slice, slugify, smartCache, memoize as smartMemoize, 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 };