typetify 2.2.0 → 4.0.1

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import { isDefined, isNil, assert, fail, noop, identity, unreachable } from './c
 export { assertDefined } from './core/index.js';
 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.js';
 export { toArray } from './guards/index.js';
-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.js';
-export { get } from './object/index.js';
-import { awaitTo, sleep, withTimeout, retry, debounce, throttle, once, onceAsync, defer, parallel } from './async/index.js';
-export { Deferred, RetryOptions } from './async/index.js';
-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.js';
+import { pick, omit, keysTyped, valuesTyped, entriesTyped, fromEntriesTyped, mapObject, filterObject, mergeShallow, clone, cloneDeep, set, deepMerge, isEqual, has, unset, paths, transform, deepGet, deepGetOr, deepSet, deepHas, deepPath, deepPluck, findKey, findLastKey, at, invertBy } from './object/index.js';
+export { get, invert } from './object/index.js';
+import { awaitTo, sleep, withTimeout, retry, debounce, throttle, onceAsync, defer, parallel } from './async/index.js';
+export { Deferred, RetryOptions, once } from './async/index.js';
+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, reject, size, keyBy, sampleSize } from './collection/index.js';
 export { intersection } from './collection/index.js';
 import { safeJsonParse, safeJsonStringify, parseNumber, parseInteger, parseBoolean, parseDate, coerceString, coerceArray, trimAll, defaults, clamp, isEmail, isUrl, isUuid, isIpAddress, parseUrl } from './input/index.js';
 export { JsonParseResult, JsonStringifyResult } from './input/index.js';
@@ -15,18 +15,32 @@ export { TryCatchAsyncResult, TryCatchResult, compose, ifElse, pipe, unless, whe
 import { debug, invariant, assertNever, exhaustive, todo, deprecated, measure, measureAsync, setLogLevel, getLogLevel } from './dx/index.js';
 export { LogLevel, MeasureResult, log } from './dx/index.js';
 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.js';
-import { capitalize, uncapitalize, camelCase, kebabCase, snakeCase, pascalCase, truncate, slugify, template, words } from './string/index.js';
+import { capitalize, uncapitalize, camelCase, kebabCase, snakeCase, pascalCase, truncate, slugify, template, words, deburr, escape, unescape, escapeRegExp, pad, padStart, padEnd } from './string/index.js';
 import { negate, flip, partial, curry, ary, unary } from './fn/index.js';
 export { memoize } from './fn/index.js';
-import { sum, average, median, round, randomInt, randomFloat, percentage, min, max } from './math/index.js';
+import { sum, average, median, round, randomFloat, percentage, min, max } from './math/index.js';
+export { randomInt } from './math/index.js';
 export { E as Err, N as None, O as Ok, a as Option, R as Result, S as Some } from './types-VsDp2t8s.js';
 import { ok, err, some as some$1, none, mapResult, mapOption, mapErr, orElse, matchResult, matchOption, isOk, isErr, unwrapOption, unwrapOr, unwrapOptionOr, fromNullable, toNullable } from './result/index.js';
 export { andThen, unwrap } from './result/index.js';
 import { Memoize, Debounce, Throttle, Bind, Log, Measure, Retry, Deprecated, Sealed, Frozen, Validate, Lazy } from './decorator/index.js';
-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.js';
+import { querySelector, querySelectorAll, classNames, addClass, removeClass, toggleClass, hasClass, addEventListener, once, delegate, isInViewport, getRect, scrollIntoView, scrollTo, getScrollPosition, setStyle, setStyles, getComputedStyleValue, getComputedStyles, show, hide, toggle } from './dom/index.js';
+import { createStorage, localStorageTyped, sessionStorageTyped, withExpiry, createMemoryStorage, getCookie, setCookie, removeCookie, hasCookie } from './storage/index.js';
+export { CookieOptions, ExpiryStorage, ExpiryStorageOptions, StorageOptions, TypedStorage } from './storage/index.js';
+import { hexToRgb, rgbToHex, rgbToHsl, hslToRgb, parseColor, formatRgb, formatHsl, lighten, darken, saturate, desaturate, opacity, mix, invert, grayscale, luminance, contrast, isLight, isDark, getContrastColor, isSimilar, getDominant, getTemperature } from './color/index.js';
+export { HSL, RGB } from './color/index.js';
+import { request, get, post, put, patch, del, buildUrl, HttpError, createHttpClient, requestWithRetry, withRetry, parseAuthHeader, bearerAuth, basicAuth, parseCookieHeader, buildCookieHeader, mergeHeaders } from './http/index.js';
+export { ContentTypes, HttpClient, HttpClientConfig, HttpHeaders, HttpResponse, RetryOptions as HttpRetryOptions, RequestOptions } from './http/index.js';
+import { toDate, formatDate, toISODateString, toISOString, toUnixTimestamp, fromUnixTimestamp, addTime, subtractTime, startOf, endOf, diff, isBefore, isAfter, isSameDate, isSameDay, isBetween, isToday, isYesterday, isTomorrow, isPast, isFuture, isLeapYear, isWeekend, isWeekday, timeAgo, formatDuration, parseDuration } from './datetime/index.js';
+export { DateInput, DurationUnit, RelativeTimeOptions } from './datetime/index.js';
+import { parsePath, dirname, basename, extname, joinPath, resolvePath, relativePath, normalizePath, isAbsolute, toPosix, toWindows, removeTrailingSlash, ensureTrailingSlash, commonPath } from './path/index.js';
+export { ParsedPath } from './path/index.js';
+import { hash, sha256, sha512, hmac, timingSafeEqual, uuid, randomBytes, randomString, randomInt, generateToken, urlSafeToken, base64Encode, base64Decode, base64UrlEncode, base64UrlDecode, stringToHex, hexToString, bytesToHex, hexToBytes, utf8Encode, utf8Decode } from './encrypt/index.js';
+export { HashAlgorithm } from './encrypt/index.js';
+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, getTyped, getPath, getOr, getPathOr, getOrLazy, tryGet, tryGetOr, tryGetResult, safe, unwrap, chain, optionalOr, optionalChain } from './logic/index.js';
 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.js';
 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.js';
-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.js';
+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, parse, safeParse, validate, is, parseJson, createGuard, createParser } from './schema/index.js';
 
 /**
  * Type-Safe Environment Variables
@@ -1295,17 +1309,171 @@ declare function zipWith<T, R>(iteratee: (...values: T[]) => R, ...arrays: reado
  * ```
  */
 declare const _: {
-    createFeatureFlags: typeof createFeatureFlags;
-    flag: {
+    readonly hash: typeof hash;
+    readonly sha256: typeof sha256;
+    readonly sha512: typeof sha512;
+    readonly hmac: typeof hmac;
+    readonly timingSafeEqual: typeof timingSafeEqual;
+    readonly uuid: typeof uuid;
+    readonly randomBytes: typeof randomBytes;
+    readonly randomString: typeof randomString;
+    readonly randomInt: typeof randomInt;
+    readonly generateToken: typeof generateToken;
+    readonly urlSafeToken: typeof urlSafeToken;
+    readonly base64Encode: typeof base64Encode;
+    readonly base64Decode: typeof base64Decode;
+    readonly base64UrlEncode: typeof base64UrlEncode;
+    readonly base64UrlDecode: typeof base64UrlDecode;
+    readonly stringToHex: typeof stringToHex;
+    readonly hexToString: typeof hexToString;
+    readonly bytesToHex: typeof bytesToHex;
+    readonly hexToBytes: typeof hexToBytes;
+    readonly utf8Encode: typeof utf8Encode;
+    readonly utf8Decode: typeof utf8Decode;
+    readonly parsePath: typeof parsePath;
+    readonly dirname: typeof dirname;
+    readonly basename: typeof basename;
+    readonly extname: typeof extname;
+    readonly joinPath: typeof joinPath;
+    readonly resolvePath: typeof resolvePath;
+    readonly relativePath: typeof relativePath;
+    readonly normalizePath: typeof normalizePath;
+    readonly isAbsolute: typeof isAbsolute;
+    readonly toPosix: typeof toPosix;
+    readonly toWindows: typeof toWindows;
+    readonly removeTrailingSlash: typeof removeTrailingSlash;
+    readonly ensureTrailingSlash: typeof ensureTrailingSlash;
+    readonly commonPath: typeof commonPath;
+    readonly toDate: typeof toDate;
+    readonly formatDate: typeof formatDate;
+    readonly toISODateString: typeof toISODateString;
+    readonly toISOString: typeof toISOString;
+    readonly toUnixTimestamp: typeof toUnixTimestamp;
+    readonly fromUnixTimestamp: typeof fromUnixTimestamp;
+    readonly addTime: typeof addTime;
+    readonly subtractTime: typeof subtractTime;
+    readonly startOf: typeof startOf;
+    readonly endOf: typeof endOf;
+    readonly diff: typeof diff;
+    readonly isBefore: typeof isBefore;
+    readonly isAfter: typeof isAfter;
+    readonly isSameDate: typeof isSameDate;
+    readonly isSameDay: typeof isSameDay;
+    readonly isBetween: typeof isBetween;
+    readonly isToday: typeof isToday;
+    readonly isYesterday: typeof isYesterday;
+    readonly isTomorrow: typeof isTomorrow;
+    readonly isPast: typeof isPast;
+    readonly isFuture: typeof isFuture;
+    readonly isLeapYear: typeof isLeapYear;
+    readonly isWeekend: typeof isWeekend;
+    readonly isWeekday: typeof isWeekday;
+    readonly timeAgo: typeof timeAgo;
+    readonly formatDuration: typeof formatDuration;
+    readonly parseDuration: typeof parseDuration;
+    readonly request: typeof request;
+    readonly get: typeof get;
+    readonly post: typeof post;
+    readonly put: typeof put;
+    readonly patch: typeof patch;
+    readonly del: typeof del;
+    readonly buildUrl: typeof buildUrl;
+    readonly HttpError: typeof HttpError;
+    readonly createHttpClient: typeof createHttpClient;
+    readonly requestWithRetry: typeof requestWithRetry;
+    readonly withRetry: typeof withRetry;
+    readonly HttpHeaders: {
+        readonly ContentType: "Content-Type";
+        readonly Accept: "Accept";
+        readonly Authorization: "Authorization";
+        readonly CacheControl: "Cache-Control";
+        readonly UserAgent: "User-Agent";
+        readonly AcceptLanguage: "Accept-Language";
+        readonly ContentLength: "Content-Length";
+        readonly XRequestId: "X-Request-Id";
+        readonly XForwardedFor: "X-Forwarded-For";
+        readonly XRealIp: "X-Real-IP";
+    };
+    readonly ContentTypes: {
+        readonly JSON: "application/json";
+        readonly FormData: "multipart/form-data";
+        readonly FormUrlEncoded: "application/x-www-form-urlencoded";
+        readonly Text: "text/plain";
+        readonly HTML: "text/html";
+        readonly XML: "application/xml";
+        readonly Binary: "application/octet-stream";
+    };
+    readonly parseAuthHeader: typeof parseAuthHeader;
+    readonly bearerAuth: typeof bearerAuth;
+    readonly basicAuth: typeof basicAuth;
+    readonly parseCookieHeader: typeof parseCookieHeader;
+    readonly buildCookieHeader: typeof buildCookieHeader;
+    readonly mergeHeaders: typeof mergeHeaders;
+    readonly hexToRgb: typeof hexToRgb;
+    readonly rgbToHex: typeof rgbToHex;
+    readonly rgbToHsl: typeof rgbToHsl;
+    readonly hslToRgb: typeof hslToRgb;
+    readonly parseColor: typeof parseColor;
+    readonly formatRgb: typeof formatRgb;
+    readonly formatHsl: typeof formatHsl;
+    readonly lighten: typeof lighten;
+    readonly darken: typeof darken;
+    readonly saturate: typeof saturate;
+    readonly desaturate: typeof desaturate;
+    readonly opacity: typeof opacity;
+    readonly mix: typeof mix;
+    readonly invert: typeof invert;
+    readonly grayscale: typeof grayscale;
+    readonly luminance: typeof luminance;
+    readonly contrast: typeof contrast;
+    readonly isLight: typeof isLight;
+    readonly isDark: typeof isDark;
+    readonly getContrastColor: typeof getContrastColor;
+    readonly isSimilar: typeof isSimilar;
+    readonly getDominant: typeof getDominant;
+    readonly getTemperature: typeof getTemperature;
+    readonly createStorage: typeof createStorage;
+    readonly localStorageTyped: typeof localStorageTyped;
+    readonly sessionStorageTyped: typeof sessionStorageTyped;
+    readonly withExpiry: typeof withExpiry;
+    readonly createMemoryStorage: typeof createMemoryStorage;
+    readonly getCookie: typeof getCookie;
+    readonly setCookie: typeof setCookie;
+    readonly removeCookie: typeof removeCookie;
+    readonly hasCookie: typeof hasCookie;
+    readonly querySelector: typeof querySelector;
+    readonly querySelectorAll: typeof querySelectorAll;
+    readonly classNames: typeof classNames;
+    readonly addClass: typeof addClass;
+    readonly removeClass: typeof removeClass;
+    readonly toggleClass: typeof toggleClass;
+    readonly hasClass: typeof hasClass;
+    readonly addEventListener: typeof addEventListener;
+    readonly once: typeof once;
+    readonly delegate: typeof delegate;
+    readonly isInViewport: typeof isInViewport;
+    readonly getRect: typeof getRect;
+    readonly scrollIntoView: typeof scrollIntoView;
+    readonly scrollTo: typeof scrollTo;
+    readonly getScrollPosition: typeof getScrollPosition;
+    readonly setStyle: typeof setStyle;
+    readonly setStyles: typeof setStyles;
+    readonly getComputedStyleValue: typeof getComputedStyleValue;
+    readonly getComputedStyles: typeof getComputedStyles;
+    readonly show: typeof show;
+    readonly hide: typeof hide;
+    readonly toggle: typeof toggle;
+    readonly createFeatureFlags: typeof createFeatureFlags;
+    readonly 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: {
+    readonly createForm: typeof createForm;
+    readonly field: typeof field;
+    readonly route: typeof route;
+    readonly createRouter: typeof createRouter;
+    readonly env: {
         string(options?: {
             default?: string;
         }): EnvVar<string>;
@@ -1329,407 +1497,417 @@ declare const _: {
             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;
-    dropRight: typeof dropRight;
-    dropRightWhile: typeof dropRightWhile;
-    fill: typeof fill;
-    findIndex: typeof findIndex;
-    findLastIndex: typeof findLastIndex;
-    flattenDeep: typeof flattenDeep;
-    flattenDepth: typeof flattenDepth;
-    fromPairs: typeof fromPairs;
-    indexOf: typeof indexOf;
-    intersectionBy: typeof intersectionBy;
-    intersectionWith: typeof intersectionWith;
-    join: typeof join;
-    lastIndexOf: typeof lastIndexOf;
-    nth: typeof nth;
-    pull: typeof pull;
-    pullAll: typeof pullAll;
-    pullAllBy: typeof pullAllBy;
-    pullAllWith: typeof pullAllWith;
-    pullAt: typeof pullAt;
-    remove: typeof remove;
-    reverse: typeof reverse;
-    slice: typeof slice;
-    sortedIndex: typeof sortedIndex;
-    sortedIndexBy: typeof sortedIndexBy;
-    sortedIndexOf: typeof sortedIndexOf;
-    sortedLastIndex: typeof sortedLastIndex;
-    sortedLastIndexBy: typeof sortedLastIndexBy;
-    sortedLastIndexOf: typeof sortedLastIndexOf;
-    sortedUniq: typeof sortedUniq;
-    sortedUniqBy: typeof sortedUniqBy;
-    takeRight: typeof takeRight;
-    takeRightWhile: typeof takeRightWhile;
-    unionBy: typeof unionBy;
-    unionWith: typeof unionWith;
-    uniqBy: typeof uniqBy;
-    uniqWith: typeof uniqWith;
-    unzipWith: typeof unzipWith;
-    without: typeof without;
-    xor: typeof xor;
-    xorBy: typeof xorBy;
-    xorWith: typeof xorWith;
-    zipObject: typeof zipObject;
-    zipObjectDeep: typeof zipObjectDeep;
-    zipWith: typeof zipWith;
-    Memoize: typeof Memoize;
-    Debounce: typeof Debounce;
-    Throttle: typeof Throttle;
-    Bind: typeof Bind;
-    Log: typeof Log;
-    Measure: typeof Measure;
-    Retry: typeof Retry;
-    Deprecated: typeof Deprecated;
-    Sealed: typeof Sealed;
-    Frozen: typeof Frozen;
-    Validate: typeof Validate;
-    Lazy: typeof Lazy;
-    ok: typeof ok;
-    err: typeof err;
-    some: typeof some$1;
-    none: typeof none;
-    mapResult: typeof mapResult;
-    mapOption: typeof mapOption;
-    mapErr: typeof mapErr;
-    orElse: typeof orElse;
-    matchResult: typeof matchResult;
-    matchOption: typeof matchOption;
-    isOk: typeof isOk;
-    isErr: typeof isErr;
-    unwrapOption: typeof unwrapOption;
-    unwrapOr: typeof unwrapOr;
-    unwrapOptionOr: typeof unwrapOptionOr;
-    fromNullable: typeof fromNullable;
-    toNullable: typeof toNullable;
-    sum: typeof sum;
-    average: typeof average;
-    median: typeof median;
-    round: typeof round;
-    randomInt: typeof randomInt;
-    randomFloat: typeof randomFloat;
-    percentage: typeof percentage;
-    min: typeof min;
-    max: typeof max;
-    negate: typeof negate;
-    flip: typeof flip;
-    partial: typeof partial;
-    curry: typeof curry;
-    ary: typeof ary;
-    unary: typeof unary;
-    capitalize: typeof capitalize;
-    uncapitalize: typeof uncapitalize;
-    camelCase: typeof camelCase;
-    kebabCase: typeof kebabCase;
-    snakeCase: typeof snakeCase;
-    pascalCase: typeof pascalCase;
-    truncate: typeof truncate;
-    slugify: typeof slugify;
-    template: typeof template;
-    words: typeof words;
-    debug: typeof debug;
-    invariant: typeof invariant;
-    assertNever: typeof assertNever;
-    exhaustive: typeof exhaustive;
-    todo: typeof todo;
-    deprecated: typeof deprecated;
-    measure: typeof measure;
-    measureAsync: typeof measureAsync;
-    log: {
+    readonly createEnv: typeof createEnv;
+    readonly createContainer: typeof createContainer;
+    readonly createTypedContainer: typeof createTypedContainer;
+    readonly pipe: typeof pipe;
+    readonly pipeAsync: typeof pipeAsync;
+    readonly flow: typeof flow;
+    readonly createMiddleware: typeof createMiddleware;
+    readonly compose: typeof compose;
+    readonly createEventBus: typeof createEventBus;
+    readonly createTypedEmitter: typeof createTypedEmitter;
+    readonly smartCache: typeof smartCache;
+    readonly memoize: typeof memoize;
+    readonly signal: typeof signal;
+    readonly computed: typeof computed;
+    readonly effect: typeof effect;
+    readonly batch: typeof batch;
+    readonly createUndoableState: typeof createUndoableState;
+    readonly createAutoUndoableState: typeof createAutoUndoableState;
+    readonly string: typeof string;
+    readonly number: typeof number;
+    readonly boolean: typeof boolean;
+    readonly literal: typeof literal;
+    readonly array: typeof array;
+    readonly object: typeof object;
+    readonly optional: typeof optional;
+    readonly nullable: typeof nullable;
+    readonly union: typeof union$1;
+    readonly intersection: typeof intersection;
+    readonly record: typeof record;
+    readonly tuple: typeof tuple;
+    readonly unknownSchema: typeof unknown;
+    readonly anySchema: typeof any;
+    readonly date: typeof date;
+    readonly email: typeof email;
+    readonly url: typeof url;
+    readonly parse: typeof parse;
+    readonly safeParse: typeof safeParse;
+    readonly validate: typeof validate;
+    readonly is: typeof is;
+    readonly parseJson: typeof parseJson;
+    readonly createGuard: typeof createGuard;
+    readonly createParser: typeof createParser;
+    readonly filterDefined: typeof filterDefined;
+    readonly filterDefinedFn: typeof filterDefinedFn;
+    readonly filterTruthy: typeof filterTruthy;
+    readonly filterTruthyFn: typeof filterTruthyFn;
+    readonly filterByGuard: typeof filterByGuard;
+    readonly filterByRefinement: typeof filterByRefinement;
+    readonly filterBy: typeof filterBy;
+    readonly partitionByGuard: typeof partitionByGuard;
+    readonly assertType: typeof assertType;
+    readonly assertDefined: typeof assertDefined;
+    readonly assertNotNull: typeof assertNotNull;
+    readonly assertCondition: typeof assertCondition;
+    readonly createAssertion: typeof createAssertion;
+    readonly narrowUnion: typeof narrowUnion;
+    readonly createDiscriminantGuard: typeof createDiscriminantGuard;
+    readonly switchUnion: typeof switchUnion;
+    readonly exhaustiveCheck: typeof exhaustiveCheck;
+    readonly excludeNull: typeof excludeNull;
+    readonly excludeUndefined: typeof excludeUndefined;
+    readonly excludeNullish: typeof excludeNullish;
+    readonly withDefault: typeof withDefault;
+    readonly withDefaultLazy: typeof withDefaultLazy;
+    readonly mapNullable: typeof mapNullable;
+    readonly chainNullable: typeof chainNullable;
+    readonly refine: typeof refine;
+    readonly oneOf: typeof oneOf;
+    readonly allOf: typeof allOf;
+    readonly not: typeof not;
+    readonly arrayOf: typeof arrayOf;
+    readonly objectOf: typeof objectOf;
+    readonly createIterator: typeof createIterator;
+    readonly lazyRange: typeof range;
+    readonly lazyMap: typeof map;
+    readonly lazyFilter: typeof filter;
+    readonly lazyTake: typeof take;
+    readonly lazySkip: typeof skip;
+    readonly lazyChunk: typeof chunk;
+    readonly lazyFlatten: typeof flatten;
+    readonly lazyZip: typeof zip;
+    readonly enumerate: typeof enumerate;
+    readonly cycle: typeof cycle;
+    readonly repeat: typeof repeat;
+    readonly fromAsync: typeof fromAsync;
+    readonly toArray: typeof toArray;
+    readonly iterReduce: typeof reduce;
+    readonly iterForEach: typeof forEach;
+    readonly iterFind: typeof find;
+    readonly iterSome: typeof some;
+    readonly iterEvery: typeof every;
+    readonly when: typeof when;
+    readonly whenValue: typeof whenValue;
+    readonly unless: typeof unless;
+    readonly unlessValue: typeof unlessValue;
+    readonly ifElse: typeof ifElse;
+    readonly ifElseLazy: typeof ifElseLazy;
+    readonly cond: typeof cond;
+    readonly condLazy: typeof condLazy;
+    readonly condBy: typeof condBy;
+    readonly matchValue: typeof matchValue;
+    readonly matchWithDefault: typeof matchWithDefault;
+    readonly matchLazy: typeof matchLazy;
+    readonly matchType: typeof matchType;
+    readonly and: typeof and;
+    readonly allTrue: typeof allTrue;
+    readonly andThen: typeof andThen;
+    readonly or: typeof or;
+    readonly anyTrue: typeof anyTrue;
+    readonly orThen: typeof orThen;
+    readonly notFn: typeof notFn;
+    readonly coalesce: typeof coalesce;
+    readonly coalesceLazy: typeof coalesceLazy;
+    readonly defaultTo: typeof defaultTo;
+    readonly defaultToLazy: typeof defaultToLazy;
+    readonly defaultToIf: typeof defaultToIf;
+    readonly defaultToIfEmpty: typeof defaultToIfEmpty;
+    readonly firstTruthy: typeof firstTruthy;
+    readonly firstWhere: typeof firstWhere;
+    readonly firstDefined: typeof firstDefined;
+    readonly allTruthy: typeof allTruthy;
+    readonly allWhere: typeof allWhere;
+    readonly allDefined: typeof allDefined;
+    readonly getTyped: typeof getTyped;
+    readonly getPath: typeof getPath;
+    readonly getOr: typeof getOr;
+    readonly getPathOr: typeof getPathOr;
+    readonly getOrLazy: typeof getOrLazy;
+    readonly tryGet: typeof tryGet;
+    readonly tryGetOr: typeof tryGetOr;
+    readonly tryGetResult: typeof tryGetResult;
+    readonly safe: typeof safe;
+    readonly unwrap: typeof unwrap;
+    readonly chain: typeof chain;
+    readonly optionalOr: typeof optionalOr;
+    readonly optionalChain: typeof optionalChain;
+    readonly concat: typeof concat;
+    readonly differenceBy: typeof differenceBy;
+    readonly differenceWith: typeof differenceWith;
+    readonly dropRight: typeof dropRight;
+    readonly dropRightWhile: typeof dropRightWhile;
+    readonly fill: typeof fill;
+    readonly findIndex: typeof findIndex;
+    readonly findLastIndex: typeof findLastIndex;
+    readonly flattenDeep: typeof flattenDeep;
+    readonly flattenDepth: typeof flattenDepth;
+    readonly fromPairs: typeof fromPairs;
+    readonly indexOf: typeof indexOf;
+    readonly intersectionBy: typeof intersectionBy;
+    readonly intersectionWith: typeof intersectionWith;
+    readonly join: typeof join;
+    readonly lastIndexOf: typeof lastIndexOf;
+    readonly nth: typeof nth;
+    readonly pull: typeof pull;
+    readonly pullAll: typeof pullAll;
+    readonly pullAllBy: typeof pullAllBy;
+    readonly pullAllWith: typeof pullAllWith;
+    readonly pullAt: typeof pullAt;
+    readonly remove: typeof remove;
+    readonly reverse: typeof reverse;
+    readonly slice: typeof slice;
+    readonly sortedIndex: typeof sortedIndex;
+    readonly sortedIndexBy: typeof sortedIndexBy;
+    readonly sortedIndexOf: typeof sortedIndexOf;
+    readonly sortedLastIndex: typeof sortedLastIndex;
+    readonly sortedLastIndexBy: typeof sortedLastIndexBy;
+    readonly sortedLastIndexOf: typeof sortedLastIndexOf;
+    readonly sortedUniq: typeof sortedUniq;
+    readonly sortedUniqBy: typeof sortedUniqBy;
+    readonly takeRight: typeof takeRight;
+    readonly takeRightWhile: typeof takeRightWhile;
+    readonly unionBy: typeof unionBy;
+    readonly unionWith: typeof unionWith;
+    readonly uniqBy: typeof uniqBy;
+    readonly uniqWith: typeof uniqWith;
+    readonly unzipWith: typeof unzipWith;
+    readonly without: typeof without;
+    readonly xor: typeof xor;
+    readonly xorBy: typeof xorBy;
+    readonly xorWith: typeof xorWith;
+    readonly zipObject: typeof zipObject;
+    readonly zipObjectDeep: typeof zipObjectDeep;
+    readonly zipWith: typeof zipWith;
+    readonly Memoize: typeof Memoize;
+    readonly Debounce: typeof Debounce;
+    readonly Throttle: typeof Throttle;
+    readonly Bind: typeof Bind;
+    readonly Log: typeof Log;
+    readonly Measure: typeof Measure;
+    readonly Retry: typeof Retry;
+    readonly Deprecated: typeof Deprecated;
+    readonly Sealed: typeof Sealed;
+    readonly Frozen: typeof Frozen;
+    readonly Validate: typeof Validate;
+    readonly Lazy: typeof Lazy;
+    readonly ok: typeof ok;
+    readonly err: typeof err;
+    readonly some: typeof some$1;
+    readonly none: typeof none;
+    readonly mapResult: typeof mapResult;
+    readonly mapOption: typeof mapOption;
+    readonly mapErr: typeof mapErr;
+    readonly orElse: typeof orElse;
+    readonly matchResult: typeof matchResult;
+    readonly matchOption: typeof matchOption;
+    readonly isOk: typeof isOk;
+    readonly isErr: typeof isErr;
+    readonly unwrapOption: typeof unwrapOption;
+    readonly unwrapOr: typeof unwrapOr;
+    readonly unwrapOptionOr: typeof unwrapOptionOr;
+    readonly fromNullable: typeof fromNullable;
+    readonly toNullable: typeof toNullable;
+    readonly sum: typeof sum;
+    readonly average: typeof average;
+    readonly median: typeof median;
+    readonly round: typeof round;
+    readonly randomFloat: typeof randomFloat;
+    readonly percentage: typeof percentage;
+    readonly min: typeof min;
+    readonly max: typeof max;
+    readonly negate: typeof negate;
+    readonly flip: typeof flip;
+    readonly partial: typeof partial;
+    readonly curry: typeof curry;
+    readonly ary: typeof ary;
+    readonly unary: typeof unary;
+    readonly capitalize: typeof capitalize;
+    readonly uncapitalize: typeof uncapitalize;
+    readonly camelCase: typeof camelCase;
+    readonly kebabCase: typeof kebabCase;
+    readonly snakeCase: typeof snakeCase;
+    readonly pascalCase: typeof pascalCase;
+    readonly truncate: typeof truncate;
+    readonly slugify: typeof slugify;
+    readonly template: typeof template;
+    readonly words: typeof words;
+    readonly deburr: typeof deburr;
+    readonly escape: typeof escape;
+    readonly unescape: typeof unescape;
+    readonly escapeRegExp: typeof escapeRegExp;
+    readonly pad: typeof pad;
+    readonly padStart: typeof padStart;
+    readonly padEnd: typeof padEnd;
+    readonly debug: typeof debug;
+    readonly invariant: typeof invariant;
+    readonly assertNever: typeof assertNever;
+    readonly exhaustive: typeof exhaustive;
+    readonly todo: typeof todo;
+    readonly deprecated: typeof deprecated;
+    readonly measure: typeof measure;
+    readonly measureAsync: typeof measureAsync;
+    readonly log: {
         debug(message: string, ...args: unknown[]): void;
         info(message: string, ...args: unknown[]): void;
         warn(message: string, ...args: unknown[]): void;
         error(message: string, ...args: unknown[]): void;
     };
-    setLogLevel: typeof setLogLevel;
-    getLogLevel: typeof getLogLevel;
-    tap: typeof tap;
-    match: typeof match;
-    tryCatch: typeof tryCatch;
-    tryCatchAsync: typeof tryCatchAsync;
-    constant: typeof constant;
-    safeJsonParse: typeof safeJsonParse;
-    safeJsonStringify: typeof safeJsonStringify;
-    parseNumber: typeof parseNumber;
-    parseInteger: typeof parseInteger;
-    parseBoolean: typeof parseBoolean;
-    parseDate: typeof parseDate;
-    coerceString: typeof coerceString;
-    coerceArray: typeof coerceArray;
-    trimAll: typeof trimAll;
-    defaults: typeof defaults;
-    clamp: typeof clamp;
-    isEmail: typeof isEmail;
-    isUrl: typeof isUrl;
-    isUuid: typeof isUuid;
-    isIpAddress: typeof isIpAddress;
-    parseUrl: typeof parseUrl;
-    unique: typeof unique;
-    groupBy: typeof groupBy;
-    indexBy: typeof indexBy;
-    partition: typeof partition;
-    chunk: typeof chunk$1;
-    compact: typeof compact;
-    flatten: typeof flatten$1;
-    sortBy: typeof sortBy;
-    first: typeof first;
-    last: typeof last;
-    range: typeof range$1;
-    shuffle: typeof shuffle;
-    sample: typeof sample;
-    zip: typeof zip$1;
-    unzip: typeof unzip;
-    difference: typeof difference;
-    take: typeof take$1;
-    drop: typeof drop;
-    takeWhile: typeof takeWhile;
-    dropWhile: typeof dropWhile;
-    findLast: typeof findLast;
-    countBy: typeof countBy;
-    maxBy: typeof maxBy;
-    minBy: typeof minBy;
-    sumBy: typeof sumBy;
-    head: typeof head;
-    tail: typeof tail;
-    init: typeof init;
-    awaitTo: typeof awaitTo;
-    sleep: typeof sleep;
-    withTimeout: typeof withTimeout;
-    retry: typeof retry;
-    debounce: typeof debounce;
-    throttle: typeof throttle;
-    once: typeof once;
-    onceAsync: typeof onceAsync;
-    defer: typeof defer;
-    parallel: typeof parallel;
-    pick: typeof pick;
-    omit: typeof omit;
-    keysTyped: typeof keysTyped;
-    valuesTyped: typeof valuesTyped;
-    entriesTyped: typeof entriesTyped;
-    fromEntriesTyped: typeof fromEntriesTyped;
-    mapObject: typeof mapObject;
-    filterObject: typeof filterObject;
-    mergeShallow: typeof mergeShallow;
-    clone: typeof clone;
-    cloneDeep: typeof cloneDeep;
-    set: typeof set;
-    invert: typeof invert;
-    deepMerge: typeof deepMerge;
-    isEqual: typeof isEqual;
-    has: typeof has;
-    unset: typeof unset;
-    paths: typeof paths;
-    transform: typeof transform;
-    deepGet: typeof deepGet;
-    deepGetOr: typeof deepGetOr;
-    deepSet: typeof deepSet;
-    deepHas: typeof deepHas;
-    deepPath: typeof deepPath;
-    deepPluck: typeof deepPluck;
-    isObject: typeof isObject;
-    isPlainObject: typeof isPlainObject;
-    isString: typeof isString;
-    isNumber: typeof isNumber;
-    isBoolean: typeof isBoolean;
-    isFunction: typeof isFunction;
-    isArray: typeof isArray;
-    isDate: typeof isDate;
-    isPromise: typeof isPromise;
-    isError: typeof isError;
-    isSymbol: typeof isSymbol;
-    hasKey: typeof hasKey;
-    hasKeys: typeof hasKeys;
-    isEmpty: typeof isEmpty;
-    isNonEmpty: typeof isNonEmpty;
-    castArray: typeof castArray;
-    cloneWith: typeof cloneWith;
-    cloneDeepWith: typeof cloneDeepWith;
-    conformsTo: typeof conformsTo;
-    eq: typeof eq;
-    gt: typeof gt;
-    gte: typeof gte;
-    lt: typeof lt;
-    lte: typeof lte;
-    isArguments: typeof isArguments;
-    isArrayBuffer: typeof isArrayBuffer;
-    isArrayLike: typeof isArrayLike;
-    isArrayLikeObject: typeof isArrayLikeObject;
-    isBuffer: typeof isBuffer;
-    isElement: typeof isElement;
-    isEqualWith: typeof isEqualWith;
-    isFinite: typeof isFinite;
-    isInteger: typeof isInteger;
-    isLength: typeof isLength;
-    isMap: typeof isMap;
-    isMatch: typeof isMatch;
-    isMatchWith: typeof isMatchWith;
-    isNaN: typeof isNaN;
-    isNative: typeof isNative;
-    isNull: typeof isNull;
-    isUndefined: typeof isUndefined;
-    isObjectLike: typeof isObjectLike;
-    isRegExp: typeof isRegExp;
-    isSafeInteger: typeof isSafeInteger;
-    isSet: typeof isSet;
-    isTypedArray: typeof isTypedArray;
-    isWeakMap: typeof isWeakMap;
-    isWeakSet: typeof isWeakSet;
-    toFinite: typeof toFinite;
-    toInteger: typeof toInteger;
-    toLength: typeof toLength;
-    toNumber: typeof toNumber;
-    toPlainObject: typeof toPlainObject;
-    toSafeInteger: typeof toSafeInteger;
-    toString: typeof toString;
-    isDefined: typeof isDefined;
-    isNil: typeof isNil;
-    assert: typeof assert;
-    fail: typeof fail;
-    noop: typeof noop;
-    identity: typeof identity;
-    unreachable: typeof unreachable;
+    readonly setLogLevel: typeof setLogLevel;
+    readonly getLogLevel: typeof getLogLevel;
+    readonly tap: typeof tap;
+    readonly match: typeof match;
+    readonly tryCatch: typeof tryCatch;
+    readonly tryCatchAsync: typeof tryCatchAsync;
+    readonly constant: typeof constant;
+    readonly safeJsonParse: typeof safeJsonParse;
+    readonly safeJsonStringify: typeof safeJsonStringify;
+    readonly parseNumber: typeof parseNumber;
+    readonly parseInteger: typeof parseInteger;
+    readonly parseBoolean: typeof parseBoolean;
+    readonly parseDate: typeof parseDate;
+    readonly coerceString: typeof coerceString;
+    readonly coerceArray: typeof coerceArray;
+    readonly trimAll: typeof trimAll;
+    readonly defaults: typeof defaults;
+    readonly clamp: typeof clamp;
+    readonly isEmail: typeof isEmail;
+    readonly isUrl: typeof isUrl;
+    readonly isUuid: typeof isUuid;
+    readonly isIpAddress: typeof isIpAddress;
+    readonly parseUrl: typeof parseUrl;
+    readonly unique: typeof unique;
+    readonly groupBy: typeof groupBy;
+    readonly indexBy: typeof indexBy;
+    readonly partition: typeof partition;
+    readonly chunk: typeof chunk$1;
+    readonly compact: typeof compact;
+    readonly flatten: typeof flatten$1;
+    readonly sortBy: typeof sortBy;
+    readonly first: typeof first;
+    readonly last: typeof last;
+    readonly range: typeof range$1;
+    readonly shuffle: typeof shuffle;
+    readonly sample: typeof sample;
+    readonly zip: typeof zip$1;
+    readonly unzip: typeof unzip;
+    readonly difference: typeof difference;
+    readonly take: typeof take$1;
+    readonly drop: typeof drop;
+    readonly takeWhile: typeof takeWhile;
+    readonly dropWhile: typeof dropWhile;
+    readonly findLast: typeof findLast;
+    readonly countBy: typeof countBy;
+    readonly maxBy: typeof maxBy;
+    readonly minBy: typeof minBy;
+    readonly sumBy: typeof sumBy;
+    readonly head: typeof head;
+    readonly tail: typeof tail;
+    readonly init: typeof init;
+    readonly reject: typeof reject;
+    readonly size: typeof size;
+    readonly keyBy: typeof keyBy;
+    readonly sampleSize: typeof sampleSize;
+    readonly awaitTo: typeof awaitTo;
+    readonly sleep: typeof sleep;
+    readonly withTimeout: typeof withTimeout;
+    readonly retry: typeof retry;
+    readonly debounce: typeof debounce;
+    readonly throttle: typeof throttle;
+    readonly onceAsync: typeof onceAsync;
+    readonly defer: typeof defer;
+    readonly parallel: typeof parallel;
+    readonly pick: typeof pick;
+    readonly omit: typeof omit;
+    readonly keysTyped: typeof keysTyped;
+    readonly valuesTyped: typeof valuesTyped;
+    readonly entriesTyped: typeof entriesTyped;
+    readonly fromEntriesTyped: typeof fromEntriesTyped;
+    readonly mapObject: typeof mapObject;
+    readonly filterObject: typeof filterObject;
+    readonly mergeShallow: typeof mergeShallow;
+    readonly clone: typeof clone;
+    readonly cloneDeep: typeof cloneDeep;
+    readonly set: typeof set;
+    readonly deepMerge: typeof deepMerge;
+    readonly isEqual: typeof isEqual;
+    readonly has: typeof has;
+    readonly unset: typeof unset;
+    readonly paths: typeof paths;
+    readonly transform: typeof transform;
+    readonly deepGet: typeof deepGet;
+    readonly deepGetOr: typeof deepGetOr;
+    readonly deepSet: typeof deepSet;
+    readonly deepHas: typeof deepHas;
+    readonly deepPath: typeof deepPath;
+    readonly deepPluck: typeof deepPluck;
+    readonly findKey: typeof findKey;
+    readonly findLastKey: typeof findLastKey;
+    readonly at: typeof at;
+    readonly invertBy: typeof invertBy;
+    readonly isObject: typeof isObject;
+    readonly isPlainObject: typeof isPlainObject;
+    readonly isString: typeof isString;
+    readonly isNumber: typeof isNumber;
+    readonly isBoolean: typeof isBoolean;
+    readonly isFunction: typeof isFunction;
+    readonly isArray: typeof isArray;
+    readonly isDate: typeof isDate;
+    readonly isPromise: typeof isPromise;
+    readonly isError: typeof isError;
+    readonly isSymbol: typeof isSymbol;
+    readonly hasKey: typeof hasKey;
+    readonly hasKeys: typeof hasKeys;
+    readonly isEmpty: typeof isEmpty;
+    readonly isNonEmpty: typeof isNonEmpty;
+    readonly castArray: typeof castArray;
+    readonly cloneWith: typeof cloneWith;
+    readonly cloneDeepWith: typeof cloneDeepWith;
+    readonly conformsTo: typeof conformsTo;
+    readonly eq: typeof eq;
+    readonly gt: typeof gt;
+    readonly gte: typeof gte;
+    readonly lt: typeof lt;
+    readonly lte: typeof lte;
+    readonly isArguments: typeof isArguments;
+    readonly isArrayBuffer: typeof isArrayBuffer;
+    readonly isArrayLike: typeof isArrayLike;
+    readonly isArrayLikeObject: typeof isArrayLikeObject;
+    readonly isBuffer: typeof isBuffer;
+    readonly isElement: typeof isElement;
+    readonly isEqualWith: typeof isEqualWith;
+    readonly isFinite: typeof isFinite;
+    readonly isInteger: typeof isInteger;
+    readonly isLength: typeof isLength;
+    readonly isMap: typeof isMap;
+    readonly isMatch: typeof isMatch;
+    readonly isMatchWith: typeof isMatchWith;
+    readonly isNaN: typeof isNaN;
+    readonly isNative: typeof isNative;
+    readonly isNull: typeof isNull;
+    readonly isUndefined: typeof isUndefined;
+    readonly isObjectLike: typeof isObjectLike;
+    readonly isRegExp: typeof isRegExp;
+    readonly isSafeInteger: typeof isSafeInteger;
+    readonly isSet: typeof isSet;
+    readonly isTypedArray: typeof isTypedArray;
+    readonly isWeakMap: typeof isWeakMap;
+    readonly isWeakSet: typeof isWeakSet;
+    readonly toFinite: typeof toFinite;
+    readonly toInteger: typeof toInteger;
+    readonly toLength: typeof toLength;
+    readonly toNumber: typeof toNumber;
+    readonly toPlainObject: typeof toPlainObject;
+    readonly toSafeInteger: typeof toSafeInteger;
+    readonly toString: typeof toString;
+    readonly isDefined: typeof isDefined;
+    readonly isNil: typeof isNil;
+    readonly assert: typeof assert;
+    readonly fail: typeof fail;
+    readonly noop: typeof noop;
+    readonly identity: typeof identity;
+    readonly unreachable: typeof unreachable;
 };
 
-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 };
+export { Bind, type CacheOptions, type Container, Debounce, Deprecated, type EventBus, type FeatureFlags, type FieldState, type FormState, Frozen, HttpError, Lazy, Log, Measure, Memoize, type Middleware, type MiddlewarePipeline, type ReadonlySignal, Retry, type Route, type Router, Sealed, type Signal, Throttle, type UndoableOptions, type UndoableState, Validate, _, addClass, addEventListener, addTime, ary, assert, assertNever, at, average, awaitTo, base64Decode, base64Encode, base64UrlDecode, base64UrlEncode, basename, basicAuth, batch, bearerAuth, buildCookieHeader, buildUrl, bytesToHex, camelCase, capitalize, castArray, chunk$1 as chunk, clamp, classNames, clone, cloneDeep, cloneDeepWith, cloneWith, coerceArray, coerceString, commonPath, compact, compose as composeMiddleware, computed, concat, conformsTo, constant, contrast, countBy, createAutoUndoableState, createContainer, createEnv, createEventBus, createFeatureFlags, createForm, createHttpClient, createMemoryStorage, createMiddleware, createRouter, createStorage, createTypedContainer, createTypedEmitter, createUndoableState, randomInt as cryptoRandomInt, curry, darken, debounce, debug, deburr, deepMerge, _ as default, defaults, defer, delegate, deprecated, desaturate, diff, difference, differenceBy, differenceWith, dirname, drop, dropRight, dropRightWhile, dropWhile, effect, endOf, ensureTrailingSlash, entriesTyped, env, eq, err, escape, escapeRegExp, exhaustive, extname, fail, field, fill, filterObject, findIndex, findKey, findLast, findLastIndex, findLastKey, first, flag, flatten$1 as flatten, flattenDeep, flattenDepth, flip, flow, formatDate, formatDuration, formatHsl, formatRgb, fromEntriesTyped, fromNullable, fromPairs, fromUnixTimestamp, generateToken, getComputedStyleValue, getComputedStyles, getContrastColor, getCookie, getDominant, getLogLevel, getRect, getScrollPosition, getTemperature, grayscale, groupBy, gt, gte, has, hasClass, hasCookie, hasKey, hasKeys, hash, head, hexToBytes, hexToRgb, hexToString, hide, hmac, hslToRgb, del as httpDelete, get as httpGet, patch as httpPatch, post as httpPost, put as httpPut, request as httpRequest, identity, indexBy, indexOf, init, intersectionBy, intersectionWith, invariant, invertBy, invert as invertColor, isAbsolute as isAbsolutePath, isAfter, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBefore, isBetween, isBoolean, isBuffer, isDark, isDate, isDefined, isElement, isEmail, isEmpty, isEqual, isEqualWith, isErr, isError, isFinite, isFunction, isFuture, isInViewport, isInteger, isIpAddress, isLeapYear, isLength, isLight, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNonEmpty, isNull, isNumber, isObject, isObjectLike, isOk, isPast, isPlainObject, isPromise, isRegExp, isSafeInteger, isSameDate, isSameDay, isSet, isSimilar, isString, isSymbol, isToday, isTomorrow, isTypedArray, isUndefined, isUrl, isUuid, isWeakMap, isWeakSet, isWeekday, isWeekend, isYesterday, join, joinPath, kebabCase, keyBy, keysTyped, last, lastIndexOf, lighten, localStorageTyped, lt, lte, luminance, mapErr, mapObject, mapOption, mapResult, match, matchOption, matchResult, max, maxBy, measure, measureAsync, median, mergeHeaders, mergeShallow, min, minBy, mix, negate, none, noop, normalizePath, nth, ok, omit, onceAsync, once as onceEvent, opacity, orElse, pad, padEnd, padStart, parallel, parseAuthHeader, parseBoolean, parseColor, parseCookieHeader, parseDate, parseDuration, parseInteger, parseNumber, parsePath, parseUrl, partial, partition, pascalCase, paths, percentage, pick, pipeAsync, pipe as pipeValue, pull, pullAll, pullAllBy, pullAllWith, pullAt, querySelector, querySelectorAll, randomBytes, randomFloat, randomString, range$1 as range, reject, relativePath, remove, removeClass, removeCookie, removeTrailingSlash, requestWithRetry, resolvePath, retry, reverse, rgbToHex, rgbToHsl, round, route, safeJsonParse, safeJsonStringify, sample, sampleSize, saturate, scrollIntoView, scrollTo, sessionStorageTyped, set, setCookie, setLogLevel, setStyle, setStyles, sha256, sha512, show, shuffle, signal, size, sleep, slice, slugify, smartCache, memoize as smartMemoize, snakeCase, some$1 as some, sortBy, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, startOf, stringToHex, subtractTime, sum, sumBy, tail, take$1 as take, takeRight, takeRightWhile, takeWhile, tap, template, throttle, timeAgo, timingSafeEqual, toDate, toFinite, toISODateString, toISOString, toInteger, toLength, toNullable, toNumber, toPlainObject, toPosix, toSafeInteger, toString, toUnixTimestamp, toWindows, todo, toggle, toggleClass, transform, trimAll, truncate, tryCatch, tryCatchAsync, unary, uncapitalize, unescape, union, unionBy, unionWith, uniqBy, uniqWith, unique, unreachable, unset, unwrapOption, unwrapOptionOr, unwrapOr, unzip, unzipWith, urlSafeToken, utf8Decode, utf8Encode, uuid, valuesTyped, withExpiry, withRetry, withTimeout, without, words, xor, xorBy, xorWith, zip$1 as zip, zipObject, zipObjectDeep, zipWith };