@pawover/kit 0.0.0-alpha.9 → 0.0.0-beta.2

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["Class","T","Arguments","Pick","Constructor","AbstractClass","AbstractConstructor","UnionToIntersection","Union","Intersection","UnionToIntersection","KeysOfUnion","ObjectType","Record","IsAny","T","NoInfer","IsAny","IsOptionalKeyOf","Type","Key","Record","IsOptionalKeyOf","OptionalKeysOf","Type","Key","OptionalKeysOf","RequiredKeysOf","Type","Exclude","RequiredKeysOf","HasRequiredKeys","BaseType","IsNever","T","IsNever","If","Type","IfBranch","ElseBranch","If","IsAny","IsNever","Primitive","UnknownArray","BuiltIns","Date","RegExp","NonRecursiveType","Function","Promise","MapsSetsOrArrays","ReadonlyMap","WeakKey","WeakMap","ReadonlySet","WeakSet","IsBothExtends","BaseType","FirstType","SecondType","HasMultipleCallSignatures","T","IsNotFalse","IsPrimitive","Not","A","IfNotAnyOrNever","IfAny","IfNever","IsAnyOrNever","IsExactOptionalPropertyTypesEnabled","Simplify","T","KeyType","IsNever","IsEqual","A","B","_IsEqual","G","OmitIndexSignature","ObjectType","KeyType","Record","PickIndexSignature","ObjectType","KeyType","Record","OmitIndexSignature","PickIndexSignature","Simplify","SimpleMerge","Destination","Source","Key","Merge","Simplify","IsEqual","KeysOfUnion","RequiredKeysOf","Merge","OptionalKeysOf","IsAny","If","IsNever","FilterDefinedKeys","FilterOptionalKeys","MapsSetsOrArrays","NonRecursiveType","ToString","BuildObject","Key","Value","CopiedFrom","PropertyKey","Pick","NumberKey","IsPlainObject","T","ObjectValue","K","NumberK","UndefinedToOptional","Exclude","HomomorphicPick","Keys","P","Extract","ValueOfUnion","Union","ReadonlyKeysOfUnion","ApplyDefaultOptions","Options","Defaults","SpecifiedOptions","Required","Omit","Record","Partial","CollapseLiterals","ApplyDefaultOptions","IsEqual","Filter","KeyType","ExcludeType","ExceptOptions","DefaultExceptOptions","Except","ObjectType","KeysType","Options","_Except","Required","Record","Partial","Except","If","IfNotAnyOrNever","IsAny","IsNever","RequireAtLeastOne","ObjectType","KeysType","_RequireAtLeastOne","Key","Pick","Required","Exclude","Partial","HasRequiredKeys","RequireAtLeastOne","NonEmptyObject","T","IsNever","UnionToIntersection","LastOfUnion","T","UnionToTuple","L","Exclude","Except","HomomorphicPick","Simplify","SetOptional","BaseType","Keys","Parameters","ReturnType","_SetOptional","Partial","ValueOf","ObjectType","ValueType","ApplyDefaultOptions","ReplaceOptions","DefaultReplaceOptions","Replace","Input","Search","Replacement","Options","_Replace","Accumulator","Required","Tail","Head","alphabetical","T","boil","ReadonlyArray2D","cartesianProduct","K","Array","castArray","CastArray","U","Exclude","castArrayIfExists","CastArrayIfExists","Extract","cluster","Size","Cluster","Concat","TNestedElement","TElement","concat","counting","TId","Record","diff","first","TArray","TDefault","flat","fork","group","Key","intersects","isArrayEqual","iterate","last","list","mapify","Value","Map","merge","objectify","pluck","TMapping","Mapping","MappedOutput","remove","replace","replaceOrAppend","select","selectFirst","shift","sift","Falsy","sort","toggle","unique","unzip","zip","T1","T2","T3","T4","T5","zipToObject","V","all","I","Awaited","Promise","defer","TResponse","guard","TFunction","GuardReturnType","TResolved","ReturnType","map","PromiseLike","AbortSignal$2","ParallelOptions","parallel","queueByKey","TArgs","TResult","reduce","AbortSignal$1","RetryOptions","retry","sleep","timeout","TError","Error","BigInt","BigIntToLocaleStringOptions","Symbol","toStringTag","BigInt64Array","ArrayBufferLike","IterableIterator","ArrayLike","Intl","NumberFormatOptions","BigUint64Array","Awaitable","Any","Class","TReturn","ExtractNotAny","SwitchAny","SwitchNever","NoInfer$1","StrictExtract","CompatibleProperty","TConstraint","BoxedPrimitive","TObject","P","Comparable","ComparableProperty","Comparator","Intersect","Simplify","Ok","Err","Result","ResultPromise","RequiredKeys","Omit","OptionalKeys","IsExactType","Left","Right","Primitive","String","Number","Boolean","TypedArray","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","DataView","ArrayBuffer","SharedArrayBuffer","CustomClassRegistry","CustomClass","BuiltInType","ES2021","WebAPI","NodeJS","ES2020","Date","RegExp","ReadonlyMap","ReadonlySet","WeakKey","WeakMap","WeakSet","Function","GlobalObjectType","WebDocumentAPI","Identifier","globalThis","InstanceType","toResult","TryitResult","tryit","PromiseWithResolvers","withResolvers","callable","TValue","TObj","TFunc","chain","T6","T7","T8","T9","T10","T11","compose","F1Result","F1Args","F1NextArgs","LastResult","F2Result","F2NextArgs","F3NextArgs","F3Result","F4NextArgs","F4Result","F5NextArgs","F5Result","F6NextArgs","F6Result","F7NextArgs","F7Result","F8NextArgs","F8Result","F9NextArgs","F9Result","DebounceFunction","DebounceOptions","debounce","delay","leading","flip","Args","Flip","B","A","R","MemoOptions","memo","memoLastCall","OnceFunction","Return","This","once","Once","RemoveItemsInFront","TItems","TItemsToRemove","partial","TA","Partial","partob","PartialArgs","promiseChain","proxied","ThrottledFunction","throttle","interval","trailing","always","castComparator","MappedInput","TInput","TOutput","ComparatorMapping","Compared","castMapping","MappingFunction","OptionalMapping","TPropertyValue","Arg","identity","noop","clamp","inRange","lerp","max","min","parseDuration","DurationString","TUnit","TShortUnit","NoInfer","DurationParser","Options","parseQuantity","QuantityString","QuantityParser","range","Generator","round","sum","toFloat","toInt","assign","TInitial","TOverride","Assign","Pick","TConflictOverride","TConflictInitial","AssignDeep","SimplifyMutable","AtomicValue","IsOptional","clone","CloningStrategy","Set","DefaultCloningStrategy","FastCloningStrategy","T_1","cloneDeep","construct","crush","Crush","Prop","KeyOf","ValueOf","KeyFilterFunction","KeyFilter","FilteredKeys","F","filterKey","get","getOrInsert","getOrInsertComputed","invert","TKey","isDangerousKey","PropertyKey","keys","listify","Item","LowercaseKeys","Lowercase","lowerize","mapEntries","TNewKey","TNewValue","mapKeys","mapValues","Required","omit","TKeys","pick","set","shake","TraverseOptions","Iterable","traverse","TraverseVisitor","TraverseContext","UppercaseKeys","Uppercase","upperize","AggregateError","AggregateErrorConstructor","AggregateErrorOrPolyfill","Unit","ShortUnit","units","short","DurationUnit","DurationShortUnit","shortUnits","DURATION_UNITS","DURATION_SHORT_UNITS","AbortSignal","SemaphorePermit","Semaphore","SemaphoreAcquireOptions","signal","weight","TimeoutError","absoluteJitter","draw","proportionalJitter","random","shuffle","uid","Series","series","camel","capitalize","dash","dedent","TemplateStringsArray","escapeHTML","pascal","similarity","snake","template","title","trim","assert","isArray","Input","ExtractArray","AsyncIterable","isAsyncIterable","isBigInt","isBoolean","isClass","ExtractClass","isDate","isEmpty","ToEmptyAble","ToEmpty","NeverEmpty","isEqual","TType","isError","isFloat","isFunction","isInt","isIntString","isIterable","isMap","ExtractMap","isMapEqual","isNullish","isNumber","isObject","isPlainObject","isPrimitive","isPromise","isRegExp","isResult","isResultErr","isResultOk","isSet","ExtractSet","isSetEqual","isString","isSymbol","isTagged","isUndefined","isWeakMap","isWeakSet","try"],"sources":["../src/utils/array/arrayCast.ts","../src/utils/array/arrayCompete.ts","../src/utils/array/arrayCounting.ts","../src/utils/array/arrayDifference.ts","../src/utils/array/arrayFirst.ts","../src/utils/array/arrayFork.ts","../src/utils/array/arrayIntersection.ts","../src/utils/array/arrayLast.ts","../src/utils/array/arrayMerge.ts","../src/utils/array/arrayPick.ts","../src/utils/array/arrayReplace.ts","../src/utils/array/arraySplit.ts","../src/utils/function/to.ts","../src/utils/math/toMathBignumber.ts","../src/utils/math/toMathDecimal.ts","../src/utils/math/toMathEvaluate.ts","../src/utils/object/cloneDeep.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/basic.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/union-to-intersection.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/keys-of-union.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-any.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-optional-key-of.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/optional-keys-of.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/required-keys-of.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/has-required-keys.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-never.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/if.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/internal/type.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/simplify.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-equal.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/omit-index-signature.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/pick-index-signature.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/merge.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/internal/object.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/except.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/require-at-least-one.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/non-empty-object.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/union-to-tuple.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/set-optional.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/value-of.d.ts","../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/replace.d.ts","../src/utils/object/enumEntries.ts","../src/utils/object/enumKeys.ts","../src/utils/object/enumTypeCheck.ts","../src/utils/object/enumValues.ts","../src/utils/object/mapEntries.ts","../node_modules/.pnpm/radashi@12.7.1/node_modules/radashi/dist/radashi.d.cts","../src/utils/object/objectAssign.ts","../src/utils/object/objectCrush.ts","../src/utils/object/objectEntries.ts","../src/utils/object/objectKeys.ts","../src/utils/object/objectPick.ts","../src/utils/object/objectSwitch.ts","../src/utils/object/objectValues.ts","../src/utils/string/stringInitialCase.ts","../src/utils/string/stringReplace.ts","../src/utils/string/stringTemplate.ts","../src/utils/string/stringToJson.ts","../src/utils/string/stringToNumber.ts","../src/utils/string/stringToPosix.ts","../src/utils/string/stringToValues.ts","../src/utils/string/stringTrim.ts","../src/utils/string/stringTruncate.ts","../src/utils/tree/types.ts","../src/utils/tree/treeFilter.ts","../src/utils/tree/treeFind.ts","../src/utils/tree/treeForEach.ts","../src/utils/tree/treeMap.ts","../src/utils/tree/rowsToTree.ts","../src/utils/tree/treeToRows.ts","../src/utils/typeof/isAbortSignal.ts","../src/utils/typeof/isArray.ts","../src/utils/typeof/isBigInt.ts","../src/utils/typeof/isBlob.ts","../src/utils/typeof/isBoolean.ts","../src/utils/typeof/isClass.ts","../src/utils/typeof/isDate.ts","../src/utils/typeof/isEqual.ts","../src/utils/typeof/isError.ts","../src/utils/typeof/isFalsy.ts","../src/utils/typeof/isFile.ts","../src/utils/typeof/isFunction.ts","../src/utils/typeof/isIterable.ts","../src/utils/typeof/isMap.ts","../src/utils/typeof/isNull.ts","../src/utils/typeof/isNumber.ts","../src/utils/typeof/isObject.ts","../src/utils/typeof/isPromise.ts","../src/utils/typeof/isReadableStream.ts","../src/utils/typeof/isRegExp.ts","../src/utils/typeof/isSet.ts","../src/utils/typeof/isString.ts","../src/utils/typeof/isSymbol.ts","../src/utils/typeof/isUndefined.ts","../src/utils/typeof/isURLSearchParams.ts","../src/utils/typeof/isWebSocket.ts","../src/utils/typeof/isWindow.ts"],"sourcesContent":["/**\nMatches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).\n\n@category Class\n*/\nexport type Class<T, Arguments extends unknown[] = any[]> = {\n\tprototype: Pick<T, keyof T>;\n\tnew(...arguments_: Arguments): T;\n};\n\n/**\nMatches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).\n\n@category Class\n*/\nexport type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;\n\n/**\nMatches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-classes-and-members).\n\n@category Class\n\n@privateRemarks\nWe cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)\n*/\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {\n\tprototype: Pick<T, keyof T>;\n}\n\n/**\nMatches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.\n\n@category Class\n*/\nexport type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;\n\nexport {};\n","/**\nConvert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n\nInspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).\n\n@example\n```\nimport type {UnionToIntersection} from 'type-fest';\n\ntype Union = {the(): void} | {great(arg: string): void} | {escape: boolean};\n\ntype Intersection = UnionToIntersection<Union>;\n//=> {the(): void; great(arg: string): void; escape: boolean};\n```\n\n@category Type\n*/\nexport type UnionToIntersection<Union> = (\n\t// `extends unknown` is always going to be the case and is used to convert the\n\t// `Union` into a [distributive conditional\n\t// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n\tUnion extends unknown\n\t\t// The union type is used as the only argument to a function since the union\n\t\t// of function arguments is an intersection.\n\t\t? (distributedUnion: Union) => void\n\t\t// This won't happen.\n\t\t: never\n\t\t// Infer the `Intersection` type since TypeScript represents the positional\n\t\t// arguments of unions of functions as an intersection of the union.\n) extends ((mergedIntersection: infer Intersection) => void)\n\t// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`\n\t? Intersection & Union\n\t: never;\n\nexport {};\n","import type {UnionToIntersection} from './union-to-intersection.d.ts';\n\n/**\nCreate a union of all keys from a given type, even those exclusive to specific union members.\n\nUnlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.\n\n@link https://stackoverflow.com/a/49402091\n\n@example\n```\nimport type {KeysOfUnion} from 'type-fest';\n\ntype A = {\n\tcommon: string;\n\ta: number;\n};\n\ntype B = {\n\tcommon: string;\n\tb: string;\n};\n\ntype C = {\n\tcommon: string;\n\tc: boolean;\n};\n\ntype Union = A | B | C;\n\ntype CommonKeys = keyof Union;\n//=> 'common'\n\ntype AllKeys = KeysOfUnion<Union>;\n//=> 'common' | 'a' | 'b' | 'c'\n```\n\n@category Object\n*/\nexport type KeysOfUnion<ObjectType> =\n  // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008\n  keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;\n\nexport {};\n","/**\nReturns a boolean for whether the given type is `any`.\n\n@link https://stackoverflow.com/a/49928360/1490091\n\nUseful in type utilities, such as disallowing `any`s to be passed to a function.\n\n@example\n```\nimport type {IsAny} from 'type-fest';\n\nconst typedObject = {a: 1, b: 2} as const;\nconst anyObject: any = {a: 1, b: 2};\n\nfunction get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {\n\treturn object[key];\n}\n\nconst typedA = get(typedObject, 'a');\n//=> 1\n\nconst anyA = get(anyObject, 'a');\n//=> any\n```\n\n@category Type Guard\n@category Utilities\n*/\nexport type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;\n\nexport {};\n","import type {IsAny} from './is-any.d.ts';\n\n/**\nReturns a boolean for whether the given key is an optional key of type.\n\nThis is useful when writing utility types or schema validators that need to differentiate `optional` keys.\n\n@example\n```\nimport type {IsOptionalKeyOf} from 'type-fest';\n\ntype User = {\n\tname: string;\n\tsurname: string;\n\n\tluckyNumber?: number;\n};\n\ntype Admin = {\n\tname: string;\n\tsurname?: string;\n};\n\ntype T1 = IsOptionalKeyOf<User, 'luckyNumber'>;\n//=> true\n\ntype T2 = IsOptionalKeyOf<User, 'name'>;\n//=> false\n\ntype T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;\n//=> boolean\n\ntype T4 = IsOptionalKeyOf<User | Admin, 'name'>;\n//=> false\n\ntype T5 = IsOptionalKeyOf<User | Admin, 'surname'>;\n//=> boolean\n```\n\n@category Type Guard\n@category Utilities\n*/\nexport type IsOptionalKeyOf<Type extends object, Key extends keyof Type> =\n\tIsAny<Type | Key> extends true ? never\n\t\t: Key extends keyof Type\n\t\t\t? Type extends Record<Key, Type[Key]>\n\t\t\t\t? false\n\t\t\t\t: true\n\t\t\t: false;\n\nexport {};\n","import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';\n\n/**\nExtract all optional keys from the given type.\n\nThis is useful when you want to create a new type that contains different type values for the optional keys only.\n\n@example\n```\nimport type {OptionalKeysOf, Except} from 'type-fest';\n\ntype User = {\n\tname: string;\n\tsurname: string;\n\n\tluckyNumber?: number;\n};\n\nconst REMOVE_FIELD = Symbol('remove field symbol');\ntype UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {\n\t[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;\n};\n\nconst update1: UpdateOperation<User> = {\n\tname: 'Alice',\n};\n\nconst update2: UpdateOperation<User> = {\n\tname: 'Bob',\n\tluckyNumber: REMOVE_FIELD,\n};\n```\n\n@category Utilities\n*/\nexport type OptionalKeysOf<Type extends object> =\n\tType extends unknown // For distributing `Type`\n\t\t? (keyof {[Key in keyof Type as\n\t\t\tIsOptionalKeyOf<Type, Key> extends false\n\t\t\t\t? never\n\t\t\t\t: Key\n\t\t\t]: never\n\t\t}) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`\n\t\t: never; // Should never happen\n\nexport {};\n","import type {OptionalKeysOf} from './optional-keys-of.d.ts';\n\n/**\nExtract all required keys from the given type.\n\nThis is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...\n\n@example\n```\nimport type {RequiredKeysOf} from 'type-fest';\n\ndeclare function createValidation<\n\tEntity extends object,\n\tKey extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,\n>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;\n\ntype User = {\n\tname: string;\n\tsurname: string;\n\tluckyNumber?: number;\n};\n\nconst validator1 = createValidation<User>('name', value => value.length < 25);\nconst validator2 = createValidation<User>('surname', value => value.length < 25);\n\n// @ts-expect-error\nconst validator3 = createValidation<User>('luckyNumber', value => value > 0);\n// Error: Argument of type '\"luckyNumber\"' is not assignable to parameter of type '\"name\" | \"surname\"'.\n```\n\n@category Utilities\n*/\nexport type RequiredKeysOf<Type extends object> =\n\tType extends unknown // For distributing `Type`\n\t\t? Exclude<keyof Type, OptionalKeysOf<Type>>\n\t\t: never; // Should never happen\n\nexport {};\n","import type {RequiredKeysOf} from './required-keys-of.d.ts';\n\n/**\nCreates a type that represents `true` or `false` depending on whether the given type has any required fields.\n\nThis is useful when you want to create an API whose behavior depends on the presence or absence of required fields.\n\n@example\n```\nimport type {HasRequiredKeys} from 'type-fest';\n\ntype GeneratorOptions<Template extends object> = {\n\tprop1: number;\n\tprop2: string;\n} & (HasRequiredKeys<Template> extends true\n\t? {template: Template}\n\t: {template?: Template});\n\ntype Template1 = {\n\toptionalSubParam?: string;\n};\n\ntype Template2 = {\n\trequiredSubParam: string;\n};\n\ntype Options1 = GeneratorOptions<Template1>;\ntype Options2 = GeneratorOptions<Template2>;\n\nconst optA: Options1 = {\n\tprop1: 0,\n\tprop2: 'hi',\n};\nconst optB: Options1 = {\n\tprop1: 0,\n\tprop2: 'hi',\n\ttemplate: {},\n};\nconst optC: Options1 = {\n\tprop1: 0,\n\tprop2: 'hi',\n\ttemplate: {\n\t\toptionalSubParam: 'optional value',\n\t},\n};\n\nconst optD: Options2 = {\n\tprop1: 0,\n\tprop2: 'hi',\n\ttemplate: {\n\t\trequiredSubParam: 'required value',\n\t},\n};\n\n```\n\n@category Utilities\n*/\nexport type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;\n\nexport {};\n","/**\nReturns a boolean for whether the given type is `never`.\n\n@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919\n@link https://stackoverflow.com/a/53984913/10292952\n@link https://www.zhenghao.io/posts/ts-never\n\nUseful in type utilities, such as checking if something does not occur.\n\n@example\n```\nimport type {IsNever, And} from 'type-fest';\n\ntype A = IsNever<never>;\n//=> true\n\ntype B = IsNever<any>;\n//=> false\n\ntype C = IsNever<unknown>;\n//=> false\n\ntype D = IsNever<never[]>;\n//=> false\n\ntype E = IsNever<object>;\n//=> false\n\ntype F = IsNever<string>;\n//=> false\n```\n\n@example\n```\nimport type {IsNever} from 'type-fest';\n\ntype IsTrue<T> = T extends true ? true : false;\n\n// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.\ntype A = IsTrue<never>;\n//   ^? type A = never\n\n// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.\ntype IsTrueFixed<T> =\n\tIsNever<T> extends true ? false : T extends true ? true : false;\n\ntype B = IsTrueFixed<never>;\n//   ^? type B = false\n```\n\n@category Type Guard\n@category Utilities\n*/\nexport type IsNever<T> = [T] extends [never] ? true : false;\n\nexport {};\n","import type {IsNever} from './is-never.d.ts';\n\n/**\nAn if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.\n\nUse-cases:\n- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.\n\nNote:\n- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.\n- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.\n\n@example\n```\nimport type {If} from 'type-fest';\n\ntype A = If<true, 'yes', 'no'>;\n//=> 'yes'\n\ntype B = If<false, 'yes', 'no'>;\n//=> 'no'\n\ntype C = If<boolean, 'yes', 'no'>;\n//=> 'yes' | 'no'\n\ntype D = If<any, 'yes', 'no'>;\n//=> 'yes' | 'no'\n\ntype E = If<never, 'yes', 'no'>;\n//=> 'no'\n```\n\n@example\n```\nimport type {If, IsAny, IsNever} from 'type-fest';\n\ntype A = If<IsAny<unknown>, 'is any', 'not any'>;\n//=> 'not any'\n\ntype B = If<IsNever<never>, 'is never', 'not never'>;\n//=> 'is never'\n```\n\n@example\n```\nimport type {If, IsEqual} from 'type-fest';\n\ntype IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;\n\ntype A = IfEqual<string, string, 'equal', 'not equal'>;\n//=> 'equal'\n\ntype B = IfEqual<string, number, 'equal', 'not equal'>;\n//=> 'not equal'\n```\n\nNote: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:\n\n@example\n```\nimport type {If, IsEqual, StringRepeat} from 'type-fest';\n\ntype HundredZeroes = StringRepeat<'0', 100>;\n\n// The following implementation is not tail recursive\ntype Includes<S extends string, Char extends string> =\n\tS extends `${infer First}${infer Rest}`\n\t\t? If<IsEqual<First, Char>,\n\t\t\t'found',\n\t\t\tIncludes<Rest, Char>>\n\t\t: 'not found';\n\n// Hence, instantiations with long strings will fail\n// @ts-expect-error\ntype Fails = Includes<HundredZeroes, '1'>;\n//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n// Error: Type instantiation is excessively deep and possibly infinite.\n\n// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive\ntype IncludesWithoutIf<S extends string, Char extends string> =\n\tS extends `${infer First}${infer Rest}`\n\t\t? IsEqual<First, Char> extends true\n\t\t\t? 'found'\n\t\t\t: IncludesWithoutIf<Rest, Char>\n\t\t: 'not found';\n\n// Now, instantiations with long strings will work\ntype Works = IncludesWithoutIf<HundredZeroes, '1'>;\n//=> 'not found'\n```\n\n@category Type Guard\n@category Utilities\n*/\nexport type If<Type extends boolean, IfBranch, ElseBranch> =\n\tIsNever<Type> extends true\n\t\t? ElseBranch\n\t\t: Type extends true\n\t\t\t? IfBranch\n\t\t\t: ElseBranch;\n\nexport {};\n","import type {If} from '../if.d.ts';\nimport type {IsAny} from '../is-any.d.ts';\nimport type {IsNever} from '../is-never.d.ts';\nimport type {Primitive} from '../primitive.d.ts';\nimport type {UnknownArray} from '../unknown-array.d.ts';\n\n/**\nMatches any primitive, `void`, `Date`, or `RegExp` value.\n*/\nexport type BuiltIns = Primitive | void | Date | RegExp;\n\n/**\nMatches non-recursive types.\n*/\nexport type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;\n\n/**\nMatches maps, sets, or arrays.\n*/\nexport type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;\n\n/**\nReturns a boolean for whether the two given types extends the base type.\n*/\nexport type IsBothExtends<BaseType, FirstType, SecondType> = FirstType extends BaseType\n\t? SecondType extends BaseType\n\t\t? true\n\t\t: false\n\t: false;\n\n/**\nTest if the given function has multiple call signatures.\n\nNeeded to handle the case of a single call signature with properties.\n\nMultiple call signatures cannot currently be supported due to a TypeScript limitation.\n@see https://github.com/microsoft/TypeScript/issues/29732\n*/\nexport type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =\n\tT extends {(...arguments_: infer A): unknown; (...arguments_: infer B): unknown}\n\t\t? B extends A\n\t\t\t? A extends B\n\t\t\t\t? false\n\t\t\t\t: true\n\t\t\t: true\n\t\t: false;\n\n/**\nReturns a boolean for whether the given `boolean` is not `false`.\n*/\nexport type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;\n\n/**\nReturns a boolean for whether the given type is primitive value or primitive type.\n\n@example\n```\ntype A = IsPrimitive<'string'>;\n//=> true\n\ntype B = IsPrimitive<string>;\n//=> true\n\ntype C = IsPrimitive<Object>;\n//=> false\n```\n*/\nexport type IsPrimitive<T> = [T] extends [Primitive] ? true : false;\n\n/**\nReturns a boolean for whether A is false.\n\n@example\n```\ntype A = Not<true>;\n//=> false\n\ntype B = Not<false>;\n//=> true\n```\n*/\nexport type Not<A extends boolean> = A extends true\n\t? false\n\t: A extends false\n\t\t? true\n\t\t: never;\n\n/**\nAn if-else-like type that resolves depending on whether the given type is `any` or `never`.\n\n@example\n```\n// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch\ntype A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;\n//=> 'VALID'\n\n// When `T` is `any` => Returns `IfAny` branch\ntype B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;\n//=> 'IS_ANY'\n\n// When `T` is `never` => Returns `IfNever` branch\ntype C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;\n//=> 'IS_NEVER'\n```\n\nNote: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:\n\n@example\n```ts\nimport type {StringRepeat} from 'type-fest';\n\ntype NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;\n\n// The following implementation is not tail recursive\ntype TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;\n\n// Hence, instantiations with long strings will fail\n// @ts-expect-error\ntype T1 = TrimLeft<NineHundredNinetyNineSpaces>;\n//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n// Error: Type instantiation is excessively deep and possibly infinite.\n\n// To fix this, move the recursion into a helper type\ntype TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;\n\ntype _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;\n\ntype T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;\n//=> ''\n```\n*/\nexport type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =\n\tIf<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;\n\n/**\nReturns a boolean for whether the given type is `any` or `never`.\n\nThis type can be better to use than {@link IfNotAnyOrNever `IfNotAnyOrNever`} in recursive types because it does not evaluate any branches.\n\n@example\n```\n// When `T` is a NOT `any` or `never` (like `string`) => Returns `false`\ntype A = IsAnyOrNever<string>;\n//=> false\n\n// When `T` is `any` => Returns `true`\ntype B = IsAnyOrNever<any>;\n//=> true\n\n// When `T` is `never` => Returns `true`\ntype C = IsAnyOrNever<never>;\n//=> true\n```\n*/\nexport type IsAnyOrNever<T> = IsNotFalse<IsAny<T> | IsNever<T>>;\n\n/**\nIndicates the value of `exactOptionalPropertyTypes` compiler option.\n*/\nexport type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?]\n\t? false\n\t: true;\n\nexport {};\n","/**\nUseful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.\n\n@example\n```\nimport type {Simplify} from 'type-fest';\n\ntype PositionProps = {\n\ttop: number;\n\tleft: number;\n};\n\ntype SizeProps = {\n\twidth: number;\n\theight: number;\n};\n\n// In your editor, hovering over `Props` will show a flattened object with all the properties.\ntype Props = Simplify<PositionProps & SizeProps>;\n```\n\nSometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.\n\nIf the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.\n\n@example\n```\nimport type {Simplify} from 'type-fest';\n\ninterface SomeInterface {\n\tfoo: number;\n\tbar?: string;\n\tbaz: number | undefined;\n}\n\ntype SomeType = {\n\tfoo: number;\n\tbar?: string;\n\tbaz: number | undefined;\n};\n\nconst literal = {foo: 123, bar: 'hello', baz: 456};\nconst someType: SomeType = literal;\nconst someInterface: SomeInterface = literal;\n\ndeclare function fn(object: Record<string, unknown>): void;\n\nfn(literal); // Good: literal object type is sealed\nfn(someType); // Good: type is sealed\n// @ts-expect-error\nfn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened\nfn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`\n```\n\n@link https://github.com/microsoft/TypeScript/issues/15300\n@see {@link SimplifyDeep}\n@category Object\n*/\nexport type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};\n\nexport {};\n","import type {IsNever} from './is-never.d.ts';\n/**\nReturns a boolean for whether the two given types are equal.\n\n@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650\n@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796\n\nUse-cases:\n- If you want to make a conditional branch based on the result of a comparison of two types.\n\n@example\n```\nimport type {IsEqual} from 'type-fest';\n\n// This type returns a boolean for whether the given array includes the given item.\n// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.\ntype Includes<Value extends readonly any[], Item> =\n\tValue extends readonly [Value[0], ...infer rest]\n\t\t? IsEqual<Value[0], Item> extends true\n\t\t\t? true\n\t\t\t: Includes<rest, Item>\n\t\t: false;\n```\n\n@category Type Guard\n@category Utilities\n*/\nexport type IsEqual<A, B> =\n\t[A] extends [B]\n\t\t? [B] extends [A]\n\t\t\t? _IsEqual<A, B>\n\t\t\t: false\n\t\t: false;\n\n// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.\ntype _IsEqual<A, B> =\n\t(<G>() => G extends A & G | G ? 1 : 2) extends\n\t(<G>() => G extends B & G | G ? 1 : 2)\n\t\t? true\n\t\t: false;\n\nexport {};\n","/**\nOmit any index signatures from the given object type, leaving only explicitly defined properties.\n\nThis is the counterpart of `PickIndexSignature`.\n\nUse-cases:\n- Remove overly permissive signatures from third-party types.\n\nThis type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).\n\nIt relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.\n\n(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)\n\n```\nconst indexed: Record<string, unknown> = {}; // Allowed\n\n// @ts-expect-error\nconst keyed: Record<'foo', unknown> = {}; // Error\n// => TS2739: Type '{}' is missing the following properties from type 'Record<\"foo\" | \"bar\", unknown>': foo, bar\n```\n\nInstead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:\n\n```\ntype Indexed = {} extends Record<string, unknown>\n\t? '✅ `{}` is assignable to `Record<string, unknown>`'\n\t: '❌ `{}` is NOT assignable to `Record<string, unknown>`';\n// => '✅ `{}` is assignable to `Record<string, unknown>`'\n\ntype Keyed = {} extends Record<'foo' | 'bar', unknown>\n\t? '✅ `{}` is assignable to `Record<\\'foo\\' | \\'bar\\', unknown>`'\n\t: '❌ `{}` is NOT assignable to `Record<\\'foo\\' | \\'bar\\', unknown>`';\n// => \"❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`\"\n```\n\nUsing a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...\n\n```\ntype OmitIndexSignature<ObjectType> = {\n\t[KeyType in keyof ObjectType // Map each key of `ObjectType`...\n\t]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.\n};\n```\n\n...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...\n\n```\ntype OmitIndexSignature<ObjectType> = {\n\t[KeyType in keyof ObjectType\n\t// Is `{}` assignable to `Record<KeyType, unknown>`?\n\tas {} extends Record<KeyType, unknown>\n\t\t? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`\n\t\t: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`\n\t]: ObjectType[KeyType];\n};\n```\n\nIf `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a \"real\" key and we want to keep it.\n\n@example\n```\nimport type {OmitIndexSignature} from 'type-fest';\n\ntype Example = {\n\t// These index signatures will be removed.\n\t[x: string]: any;\n\t[x: number]: any;\n\t[x: symbol]: any;\n\t[x: `head-${string}`]: string;\n\t[x: `${string}-tail`]: string;\n\t[x: `head-${string}-tail`]: string;\n\t[x: `${bigint}`]: string;\n\t[x: `embedded-${number}`]: string;\n\n\t// These explicitly defined keys will remain.\n\tfoo: 'bar';\n\tqux?: 'baz';\n};\n\ntype ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;\n// => { foo: 'bar'; qux?: 'baz' | undefined; }\n```\n\n@see {@link PickIndexSignature}\n@category Object\n*/\nexport type OmitIndexSignature<ObjectType> = {\n\t[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>\n\t\t? never\n\t\t: KeyType]: ObjectType[KeyType];\n};\n\nexport {};\n","/**\nPick only index signatures from the given object type, leaving out all explicitly defined properties.\n\nThis is the counterpart of `OmitIndexSignature`.\n\n@example\n```\nimport type {PickIndexSignature} from 'type-fest';\n\ndeclare const symbolKey: unique symbol;\n\ntype Example = {\n\t// These index signatures will remain.\n\t[x: string]: unknown;\n\t[x: number]: unknown;\n\t[x: symbol]: unknown;\n\t[x: `head-${string}`]: string;\n\t[x: `${string}-tail`]: string;\n\t[x: `head-${string}-tail`]: string;\n\t[x: `${bigint}`]: string;\n\t[x: `embedded-${number}`]: string;\n\n\t// These explicitly defined keys will be removed.\n\t['kebab-case-key']: string;\n\t[symbolKey]: string;\n\tfoo: 'bar';\n\tqux?: 'baz';\n};\n\ntype ExampleIndexSignature = PickIndexSignature<Example>;\n// {\n// \t[x: string]: unknown;\n// \t[x: number]: unknown;\n// \t[x: symbol]: unknown;\n// \t[x: `head-${string}`]: string;\n// \t[x: `${string}-tail`]: string;\n// \t[x: `head-${string}-tail`]: string;\n// \t[x: `${bigint}`]: string;\n// \t[x: `embedded-${number}`]: string;\n// }\n```\n\n@see {@link OmitIndexSignature}\n@category Object\n*/\nexport type PickIndexSignature<ObjectType> = {\n\t[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>\n\t\t? KeyType\n\t\t: never]: ObjectType[KeyType];\n};\n\nexport {};\n","import type {OmitIndexSignature} from './omit-index-signature.d.ts';\nimport type {PickIndexSignature} from './pick-index-signature.d.ts';\nimport type {Simplify} from './simplify.d.ts';\n\n// Merges two objects without worrying about index signatures.\ntype SimpleMerge<Destination, Source> = {\n\t[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];\n} & Source;\n\n/**\nMerge two types into a new type. Keys of the second type overrides keys of the first type.\n\n@example\n```\nimport type {Merge} from 'type-fest';\n\ntype Foo = {\n\t[x: string]: unknown;\n\t[x: number]: unknown;\n\tfoo: string;\n\tbar: symbol;\n};\n\ntype Bar = {\n\t[x: number]: number;\n\t[x: symbol]: unknown;\n\tbar: Date;\n\tbaz: boolean;\n};\n\nexport type FooBar = Merge<Foo, Bar>;\n// => {\n// \t[x: string]: unknown;\n// \t[x: number]: number;\n// \t[x: symbol]: unknown;\n// \tfoo: string;\n// \tbar: Date;\n// \tbaz: boolean;\n// }\n```\n\n@category Object\n*/\nexport type Merge<Destination, Source> =\nSimplify<\n\tSimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>\n\t& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>\n>;\n\nexport {};\n","import type {Simplify} from '../simplify.d.ts';\nimport type {IsEqual} from '../is-equal.d.ts';\nimport type {KeysOfUnion} from '../keys-of-union.d.ts';\nimport type {RequiredKeysOf} from '../required-keys-of.d.ts';\nimport type {Merge} from '../merge.d.ts';\nimport type {OptionalKeysOf} from '../optional-keys-of.d.ts';\nimport type {IsAny} from '../is-any.d.ts';\nimport type {If} from '../if.d.ts';\nimport type {IsNever} from '../is-never.d.ts';\nimport type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';\nimport type {MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';\nimport type {ToString} from './string.d.ts';\n\n/**\nCreate an object type with the given key `<Key>` and value `<Value>`.\n\nIt will copy the prefix and optional status of the same key from the given object `CopiedFrom` into the result.\n\n@example\n```\ntype A = BuildObject<'a', string>;\n//=> {a: string}\n\n// Copy `readonly` and `?` from the key `a` of `{readonly a?: any}`\ntype B = BuildObject<'a', string, {readonly a?: any}>;\n//=> {readonly a?: string}\n```\n*/\nexport type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends object = {}> =\n\tKey extends keyof CopiedFrom\n\t\t? Pick<{[_ in keyof CopiedFrom]: Value}, Key>\n\t\t: Key extends `${infer NumberKey extends number}`\n\t\t\t? NumberKey extends keyof CopiedFrom\n\t\t\t\t? Pick<{[_ in keyof CopiedFrom]: Value}, NumberKey>\n\t\t\t\t: {[_ in Key]: Value}\n\t\t\t: {[_ in Key]: Value};\n\n/**\nReturns a boolean for whether the given type is a plain key-value object.\n*/\nexport type IsPlainObject<T> =\n\tIsNever<T> extends true\n\t\t? false\n\t\t: T extends NonRecursiveType | MapsSetsOrArrays\n\t\t\t? false\n\t\t\t: T extends object\n\t\t\t\t? true\n\t\t\t\t: false;\n\n/**\nExtract the object field type if T is an object and K is a key of T, return `never` otherwise.\n\nIt creates a type-safe way to access the member type of `unknown` type.\n*/\nexport type ObjectValue<T, K> =\n\tK extends keyof T\n\t\t? T[K]\n\t\t: ToString<K> extends keyof T\n\t\t\t? T[ToString<K>]\n\t\t\t: K extends `${infer NumberK extends number}`\n\t\t\t\t? NumberK extends keyof T\n\t\t\t\t\t? T[NumberK]\n\t\t\t\t\t: never\n\t\t\t\t: never;\n\n/**\nFor an object T, if it has any properties that are a union with `undefined`, make those into optional properties instead.\n\n@example\n```\ntype User = {\n\tfirstName: string;\n\tlastName: string | undefined;\n};\n\ntype OptionalizedUser = UndefinedToOptional<User>;\n//=> {\n// \tfirstName: string;\n// \tlastName?: string;\n// }\n```\n*/\nexport type UndefinedToOptional<T extends object> = Simplify<\n\t{\n\t// Property is not a union with `undefined`, keep it as-is.\n\t\t[Key in keyof Pick<T, FilterDefinedKeys<T>>]: T[Key];\n\t} & {\n\t// Property _is_ a union with defined value. Set as optional (via `?`) and remove `undefined` from the union.\n\t\t[Key in keyof Pick<T, FilterOptionalKeys<T>>]?: Exclude<T[Key], undefined>;\n\t}\n>;\n\n/**\nWorks similar to the built-in `Pick` utility type, except for the following differences:\n- Distributes over union types and allows picking keys from any member of the union type.\n- Primitives types are returned as-is.\n- Picks all keys if `Keys` is `any`.\n- Doesn't pick `number` from a `string` index signature.\n\n@example\n```\ntype ImageUpload = {\n\turl: string;\n\tsize: number;\n\tthumbnailUrl: string;\n};\n\ntype VideoUpload = {\n\turl: string;\n\tduration: number;\n\tencodingFormat: string;\n};\n\n// Distributes over union types and allows picking keys from any member of the union type\ntype MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, \"url\" | \"size\" | \"duration\">;\n//=> {url: string; size: number} | {url: string; duration: number}\n\n// Primitive types are returned as-is\ntype Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;\n//=> string | number\n\n// Picks all keys if `Keys` is `any`\ntype Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;\n//=> {a: 1; b: 2} | {c: 3}\n\n// Doesn't pick `number` from a `string` index signature\ntype IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;\n//=> {}\n*/\nexport type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {\n\t[P in keyof T as Extract<P, Keys>]: T[P]\n};\n\n/**\nExtract all possible values for a given key from a union of object types.\n\n@example\n```\ntype Statuses = ValueOfUnion<{id: 1; status: 'open'} | {id: 2; status: 'closed'}, 'status'>;\n//=> \"open\" | \"closed\"\n```\n*/\nexport type ValueOfUnion<Union, Key extends KeysOfUnion<Union>> =\n\tUnion extends unknown ? Key extends keyof Union ? Union[Key] : never : never;\n\n/**\nExtract all readonly keys from a union of object types.\n\n@example\n```\ntype User = {\n\treadonly id: string;\n\tname: string;\n};\n\ntype Post = {\n\treadonly id: string;\n\treadonly author: string;\n\tbody: string;\n};\n\ntype ReadonlyKeys = ReadonlyKeysOfUnion<User | Post>;\n//=> \"id\" | \"author\"\n```\n*/\nexport type ReadonlyKeysOfUnion<Union> = Union extends unknown ? keyof {\n\t[Key in keyof Union as IsEqual<{[K in Key]: Union[Key]}, {readonly [K in Key]: Union[Key]}> extends true ? Key : never]: never\n} : never;\n\n/**\nMerges user specified options with default options.\n\n@example\n```\ntype PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};\ntype DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};\ntype SpecifiedOptions = {leavesOnly: true};\n\ntype Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;\n//=> {maxRecursionDepth: 10; leavesOnly: true}\n```\n\n@example\n```\n// Complains if default values are not provided for optional options\n\ntype PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};\ntype DefaultPathsOptions = {maxRecursionDepth: 10};\ntype SpecifiedOptions = {};\n\ntype Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;\n//                                              ~~~~~~~~~~~~~~~~~~~\n// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.\n```\n\n@example\n```\n// Complains if an option's default type does not conform to the expected type\n\ntype PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};\ntype DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};\ntype SpecifiedOptions = {};\n\ntype Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;\n//                                              ~~~~~~~~~~~~~~~~~~~\n// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.\n```\n\n@example\n```\n// Complains if an option's specified type does not conform to the expected type\n\ntype PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};\ntype DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};\ntype SpecifiedOptions = {leavesOnly: 'yes'};\n\ntype Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;\n//                                                                   ~~~~~~~~~~~~~~~~\n// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.\n```\n*/\nexport type ApplyDefaultOptions<\n\tOptions extends object,\n\tDefaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,\n\tSpecifiedOptions extends Options,\n> =\n\tIf<IsAny<SpecifiedOptions>, Defaults,\n\t\tIf<IsNever<SpecifiedOptions>, Defaults,\n\t\t\tSimplify<Merge<Defaults, {\n\t\t\t\t[Key in keyof SpecifiedOptions\n\t\t\t\tas Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key\n\t\t\t\t]: SpecifiedOptions[Key]\n\t\t\t}> & Required<Options>>>>; // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`\n\n/**\nCollapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.\n\nNote: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `(\"foo\" & Tag<\"Tag\", never>) | (string & Tag<\"Tag\", never>)` and not `string & Tag<\"Tag\", never>`.\n\nUse-case: For collapsing unions created using {@link LiteralUnion}.\n\n@example\n```\nimport type {LiteralUnion} from 'type-fest';\n\ntype A = CollapseLiterals<'foo' | 'bar' | (string & {})>;\n//=> string\n\ntype B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;\n//=> number\n\ntype C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;\n//=> `on${string}`\n\ntype D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;\n//=> 'click' | 'change' | `on${string}`\n\ntype E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;\n//=> string | null | undefined\n```\n*/\nexport type CollapseLiterals<T> = {} extends T\n\t? T\n\t: T extends infer U & {}\n\t\t? U\n\t\t: T;\n\nexport {};\n","import type {ApplyDefaultOptions} from './internal/index.d.ts';\nimport type {IsEqual} from './is-equal.d.ts';\n\n/**\nFilter out keys from an object.\n\nReturns `never` if `Exclude` is strictly equal to `Key`.\nReturns `never` if `Key` extends `Exclude`.\nReturns `Key` otherwise.\n\n@example\n```\ntype Filtered = Filter<'foo', 'foo'>;\n//=> never\n```\n\n@example\n```\ntype Filtered = Filter<'bar', string>;\n//=> never\n```\n\n@example\n```\ntype Filtered = Filter<'bar', 'foo'>;\n//=> 'bar'\n```\n\n@see {Except}\n*/\ntype Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);\n\nexport type ExceptOptions = {\n\t/**\n\tDisallow assigning non-specified properties.\n\n\tNote that any omitted properties in the resulting type will be present in autocomplete as `undefined`.\n\n\t@default false\n\t*/\n\trequireExactProps?: boolean;\n};\n\ntype DefaultExceptOptions = {\n\trequireExactProps: false;\n};\n\n/**\nCreate a type from an object type without certain keys.\n\nWe recommend setting the `requireExactProps` option to `true`.\n\nThis type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.\n\nThis type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).\n\n@example\n```\nimport type {Except} from 'type-fest';\n\ntype Foo = {\n\ta: number;\n\tb: string;\n};\n\ntype FooWithoutA = Except<Foo, 'a'>;\n//=> {b: string}\n\n// @ts-expect-error\nconst fooWithoutA: FooWithoutA = {a: 1, b: '2'};\n//=> errors: 'a' does not exist in type '{ b: string; }'\n\ntype FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;\n//=> {a: number} & Partial<Record<\"b\", never>>\n\n// @ts-expect-error\nconst fooWithoutB: FooWithoutB = {a: 1, b: '2'};\n//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.\n\n// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.\n\n// Consider the following example:\n\ntype UserData = {\n\t[metadata: string]: string;\n\temail: string;\n\tname: string;\n\trole: 'admin' | 'user';\n};\n\n// `Omit` clearly doesn't behave as expected in this case:\ntype PostPayload = Omit<UserData, 'email'>;\n//=> { [x: string]: string; [x: number]: string; }\n\n// In situations like this, `Except` works better.\n// It simply removes the `email` key while preserving all the other keys.\ntype PostPayloadFixed = Except<UserData, 'email'>;\n//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }\n```\n\n@category Object\n*/\nexport type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =\n\t_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;\n\ntype _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {\n\t[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];\n} & (Options['requireExactProps'] extends true\n\t? Partial<Record<KeysType, never>>\n\t: {});\n\nexport {};\n","import type {Except} from './except.d.ts';\nimport type {If} from './if.d.ts';\nimport type {IfNotAnyOrNever} from './internal/index.d.ts';\nimport type {IsAny} from './is-any.d.ts';\nimport type {IsNever} from './is-never.d.ts';\n\n/**\nCreate a type that requires at least one of the given keys. The remaining keys are kept as is.\n\n@example\n```\nimport type {RequireAtLeastOne} from 'type-fest';\n\ntype Responder = {\n\ttext?: () => string;\n\tjson?: () => string;\n\tsecure?: boolean;\n};\n\nconst responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {\n\tjson: () => '{\"message\": \"ok\"}',\n\tsecure: true,\n};\n```\n\n@category Object\n*/\nexport type RequireAtLeastOne<\n\tObjectType,\n\tKeysType extends keyof ObjectType = keyof ObjectType,\n> =\n\tIfNotAnyOrNever<ObjectType,\n\t\tIf<IsNever<KeysType>,\n\t\t\tnever,\n\t\t\t_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>\n\t\t>>;\n\ntype _RequireAtLeastOne<\n\tObjectType,\n\tKeysType extends keyof ObjectType,\n> = {\n\t// For each `Key` in `KeysType` make a mapped type:\n\t[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required\n\t// 2. Make all other keys in `KeysType` optional\n\t\tPartial<Pick<ObjectType, Exclude<KeysType, Key>>>;\n}[KeysType] &\n// 3. Add the remaining keys not in `KeysType`\nExcept<ObjectType, KeysType>;\n\nexport {};\n","import type {HasRequiredKeys} from './has-required-keys.d.ts';\nimport type {RequireAtLeastOne} from './require-at-least-one.d.ts';\n\n/**\nRepresents an object with at least 1 non-optional key.\n\nThis is useful when you need an object where all keys are optional, but there must be at least 1 key.\n\n@example\n```\nimport type {NonEmptyObject} from 'type-fest';\n\ntype User = {\n\tname: string;\n\tsurname: string;\n\tid: number;\n};\n\ntype UpdateRequest<Entity extends object> = NonEmptyObject<Partial<Entity>>;\n\nconst update1: UpdateRequest<User> = {\n\tname: 'Alice',\n\tsurname: 'Acme',\n};\n\n// At least 1 key is required, therefore this will report a 2322 error:\n// Type '{}' is not assignable to type 'UpdateRequest<User>'\n// @ts-expect-error\nconst update2: UpdateRequest<User> = {};\n```\n\n@see Use `IsEmptyObject` to check whether an object is empty.\n\n@category Object\n*/\nexport type NonEmptyObject<T extends object> = HasRequiredKeys<T> extends true ? T : RequireAtLeastOne<T, keyof T>;\n\nexport {};\n","import type {IsNever} from './is-never.d.ts';\nimport type {UnionToIntersection} from './union-to-intersection.d.ts';\n\n/**\nReturns the last element of a union type.\n\n@example\n```\ntype Last = LastOfUnion<1 | 2 | 3>;\n//=> 3\n```\n*/\ntype LastOfUnion<T> =\nUnionToIntersection<T extends any ? () => T : never> extends () => (infer R)\n\t? R\n\t: never;\n\n/**\nConvert a union type into an unordered tuple type of its elements.\n\n\"Unordered\" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.\n\nThis can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.\n\n@example\n```\nimport type {UnionToTuple} from 'type-fest';\n\ntype Numbers = 1 | 2 | 3;\ntype NumbersTuple = UnionToTuple<Numbers>;\n//=> [1, 2, 3]\n```\n\n@example\n```\nimport type {UnionToTuple} from 'type-fest';\n\nconst pets = {\n\tdog: '🐶',\n\tcat: '🐱',\n\tsnake: '🐍',\n};\n\ntype Pet = keyof typeof pets;\n//=> 'dog' | 'cat' | 'snake'\n\nconst petList = Object.keys(pets) as UnionToTuple<Pet>;\n//=> ['dog', 'cat', 'snake']\n```\n\n@category Array\n*/\nexport type UnionToTuple<T, L = LastOfUnion<T>> =\nIsNever<T> extends false\n\t? [...UnionToTuple<Exclude<T, L>>, L]\n\t: [];\n\nexport {};\n","import type {Except} from './except.d.ts';\nimport type {HomomorphicPick} from './internal/index.d.ts';\nimport type {Simplify} from './simplify.d.ts';\n\n/**\nCreate a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.\n\nUse-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.\n\n@example\n```\nimport type {SetOptional} from 'type-fest';\n\ntype Foo = {\n\ta: number;\n\tb?: string;\n\tc: boolean;\n};\n\ntype SomeOptional = SetOptional<Foo, 'b' | 'c'>;\n// type SomeOptional = {\n// \ta: number;\n// \tb?: string; // Was already optional and still is.\n// \tc?: boolean; // Is now optional.\n// }\n```\n\n@category Object\n*/\nexport type SetOptional<BaseType, Keys extends keyof BaseType> =\n\t(BaseType extends (...arguments_: never) => any\n\t\t? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>\n\t\t: unknown)\n\t& _SetOptional<BaseType, Keys>;\n\ntype _SetOptional<BaseType, Keys extends keyof BaseType> =\n\tBaseType extends unknown // To distribute `BaseType` when it's a union type.\n\t\t? Simplify<\n\t\t// Pick just the keys that are readonly from the base type.\n\t\t\tExcept<BaseType, Keys> &\n\t\t// Pick the keys that should be mutable from the base type and make them mutable.\n\t\t\tPartial<HomomorphicPick<BaseType, Keys>>\n\t\t>\n\t\t: never;\n\nexport {};\n","/**\nCreate a union of the given object's values, and optionally specify which keys to get the values from.\n\nPlease upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.\n\n@example\n```\nimport type {ValueOf} from 'type-fest';\n\ntype A = ValueOf<{id: number; name: string; active: boolean}>;\n//=> number | string | boolean\n\ntype B = ValueOf<{id: number; name: string; active: boolean}, 'name'>;\n//=> string\n\ntype C = ValueOf<{id: number; name: string; active: boolean}, 'id' | 'name'>;\n//=> number | string\n```\n\n@category Object\n*/\nexport type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];\n\nexport {};\n","import type {ApplyDefaultOptions} from './internal/index.d.ts';\n\nexport type ReplaceOptions = {\n\tall?: boolean;\n};\n\ntype DefaultReplaceOptions = {\n\tall: false;\n};\n\n/**\nRepresents a string with some or all matches replaced by a replacement.\n\nUse-case:\n- `kebab-case-path` to `dotted.path.notation`\n- Changing date/time format: `01-08-2042` → `01/08/2042`\n- Manipulation of type properties, for example, removal of prefixes\n\n@example\n```\nimport type {Replace} from 'type-fest';\n\ndeclare function replace<\n\tInput extends string,\n\tSearch extends string,\n\tReplacement extends string,\n>(\n\tinput: Input,\n\tsearch: Search,\n\treplacement: Replacement\n): Replace<Input, Search, Replacement>;\n\ndeclare function replaceAll<\n\tInput extends string,\n\tSearch extends string,\n\tReplacement extends string,\n>(\n\tinput: Input,\n\tsearch: Search,\n\treplacement: Replacement\n): Replace<Input, Search, Replacement, {all: true}>;\n\n// The return type is the exact string literal, not just `string`.\n\nreplace('hello ?', '?', '🦄');\n//=> 'hello 🦄'\n\nreplace('hello ??', '?', '❓');\n//=> 'hello ❓?'\n\nreplaceAll('10:42:00', ':', '-');\n//=> '10-42-00'\n\nreplaceAll('__userName__', '__', '');\n//=> 'userName'\n\nreplaceAll('My Cool Title', ' ', '');\n//=> 'MyCoolTitle'\n```\n\n@category String\n@category Template literal\n*/\nexport type Replace<\n\tInput extends string,\n\tSearch extends string,\n\tReplacement extends string,\n\tOptions extends ReplaceOptions = {},\n> = _Replace<Input, Search, Replacement, ApplyDefaultOptions<ReplaceOptions, DefaultReplaceOptions, Options>>;\n\ntype _Replace<\n\tInput extends string,\n\tSearch extends string,\n\tReplacement extends string,\n\tOptions extends Required<ReplaceOptions>,\n\tAccumulator extends string = '',\n> = Search extends string // For distributing `Search`\n\t? Replacement extends string // For distributing `Replacement`\n\t\t? Input extends `${infer Head}${Search}${infer Tail}`\n\t\t\t? Options['all'] extends true\n\t\t\t\t? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`>\n\t\t\t\t: `${Head}${Replacement}${Tail}`\n\t\t\t: `${Accumulator}${Input}`\n\t\t: never\n\t: never;\n\nexport {};\n","/**\n * Sort an array without modifying it and return the newly sorted\n * value. Allows for a string sorting value.\n *\n * @see https://radashi.js.org/reference/array/alphabetical\n * @version 12.1.0\n */\ndeclare function alphabetical<T>(array: readonly T[], getter: (item: T) => string, direction?: 'asc' | 'desc'): T[];\n\n/**\n * Go through a list of items, starting with the first item, and\n * comparing with the second. Keep the one you want then compare that\n * to the next item in the list with the same.\n *\n * @see https://radashi.js.org/reference/array/boil\n * @example\n * ```ts\n * boil([1, 2, 3, 0], (a, b) => a > b ? a : b) // 3\n * ```\n * @version 12.1.0\n */\ndeclare function boil<T>(array: readonly T[], compareFunc: (a: T, b: T) => T): T | null;\n\ntype ReadonlyArray2D<T> = readonly (readonly T[])[];\n/**\n * Create an [n-ary Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product#n-ary_Cartesian_product)\n * from the given arrays.\n *\n * @see https://radashi.js.org/reference/array/cartesianProduct\n * @example\n * ```ts\n * cartesianProduct([\n *   ['red', 'blue'],\n *   ['big', 'small'],\n *   ['fast', 'slow'],\n * ])\n * // [\n * //   ['red', 'big', 'fast'],\n * //   ['red', 'big', 'slow'],\n * //   ['red', 'small', 'fast'],\n * //   ['red', 'small', 'slow'],\n * //   ['blue', 'big', 'fast'],\n * //   ['blue', 'big', 'slow'],\n * //   ['blue', 'small', 'fast'],\n * //   ['blue', 'small', 'slow']\n * // ]\n * ```\n * @version 12.3.0\n */\ndeclare function cartesianProduct<const T extends ReadonlyArray2D<any>>(...arrays: [...T]): Array<{\n    [K in keyof T]: T[K][number];\n}>;\n\n/**\n * Casts the given value to an array. If the value is already an\n * array, a shallow copy is returned. Otherwise, a new array\n * containing the value is returned.\n *\n * @see https://radashi.js.org/reference/array/castArray\n * @example\n * ```ts\n * castArray(1) // => [1]\n * castArray([1, 2]) // => [1, 2]\n * castArray(null) // => [null]\n * castArray(undefined) // => [undefined]\n * ```\n * @version 12.2.0\n */\ndeclare function castArray<T>(value: T): CastArray<T>;\n/**\n * The return type of the {@link castArray} function.\n *\n * @see https://radashi.js.org/reference/array/castArray\n */\ntype CastArray<T> = [T] extends [never] ? never[] : [unknown] extends [T] ? unknown[] : (T extends any ? T extends readonly (infer U)[] ? U[] : never : never) | (Exclude<T, readonly any[]> extends never ? never : Exclude<T, readonly any[]>[]);\n\n/**\n * Casts the given value to an array if it's not equal to `null` or\n * `undefined`. If the value is an array, it returns a shallow copy of\n * the array. Otherwise, it returns a new array containing the value.\n *\n * @see https://radashi.js.org/reference/array/castArrayIfExists\n * @example\n * ```ts\n * castArrayIfExists(1) // => [1]\n * castArrayIfExists(null) // => null\n * castArrayIfExists(undefined) // => undefined\n * castArrayIfExists([1, 2, 3]) // => [1, 2, 3]\n * ```\n * @version 12.2.0\n */\ndeclare function castArrayIfExists<T>(value: T): CastArrayIfExists<T>;\n/**\n * The return type of the {@link castArrayIfExists} function.\n *\n * @see https://radashi.js.org/reference/array/castArrayIfExists\n */\ntype CastArrayIfExists<T> = [T] extends [never] ? never[] : [unknown] extends [T] ? unknown[] | null | undefined : (T extends any ? T extends readonly (infer U)[] ? U[] : never : never) | (Exclude<T, readonly any[] | null | undefined> extends never ? never : Exclude<T, readonly any[] | null | undefined>[]) | Extract<T, null | undefined>;\n\n/**\n * Splits a single list into many lists of the desired size.\n *\n * @see https://radashi.js.org/reference/array/cluster\n * @example\n * ```ts\n * cluster([1, 2, 3, 4, 5, 6], 2)\n * // [[1, 2], [3, 4], [5, 6]]\n * ```\n * @version 12.1.0\n */\ndeclare function cluster<T, Size extends number = 2>(array: readonly T[], size?: Size): Cluster<T, Size>[];\ntype Cluster<T, Size extends number> = Size extends 1 ? [T] : Size extends 2 ? [T, T] : Size extends 3 ? [T, T, T] : Size extends 4 ? [T, T, T, T] : Size extends 5 ? [T, T, T, T, T] : Size extends 6 ? [T, T, T, T, T, T] : Size extends 7 ? [T, T, T, T, T, T, T] : Size extends 8 ? [T, T, T, T, T, T, T, T] : T[];\n\ntype Concat<T extends readonly any[]> = T[number] extends infer TElement ? (TElement extends readonly (infer TNestedElement)[] ? Exclude<TNestedElement, undefined | null> : Exclude<TElement, undefined | null>)[] : unknown[];\n/**\n * Flattens and filters nullish values from arguments, returning a new\n * array containing only the non-nullish elements. Nested arrays are\n * flattened one level deep.\n *\n * @see https://radashi.js.org/reference/array/concat\n * @example\n * ```ts\n * const result = _.concat('', ['a'], undefined, [null, 'b'])\n * // => ['', 'a', 'b']\n * ```\n * @example\n * ```ts\n * const result = _.concat(1, [2, [3]], null)\n * // => [1, 2, [3]] // Note: only flattens one level\n * ```\n * @version 12.5.0\n */\ndeclare function concat<T extends readonly [any, any, ...any[]]>(...values: T): Concat<T>;\n\n/**\n * Counts the occurrences of each unique value returned by the `identity`\n * function when applied to each item in the array.\n *\n * @see https://radashi.js.org/reference/array/counting\n * @example\n * ```ts\n * counting([1, 2, 3, 4], (n) => n % 2 === 0 ? 'even' : 'odd')\n * // { even: 2, odd: 2 }\n * ```\n * @version 12.1.0\n */\ndeclare function counting<T, TId extends string | number | symbol>(array: readonly T[], identity: (item: T) => TId): Record<TId, number>;\n\n/**\n * Returns all items from the first list that do not exist in the\n * second list.\n *\n * @see https://radashi.js.org/reference/array/diff\n * @example\n * ```ts\n * diff([1, 2, 3, 4], [2, 4])\n * // [1, 3]\n *\n * diff([{a:1}, {a:2}, {a:3}], [{a:2}, {a:4}], (n) => n.a)\n * // [{a:1}, {a:3}]\n * ```\n * @version 12.1.0\n */\ndeclare function diff<T>(root: readonly T[], other: readonly T[], identity?: (item: T) => string | number | symbol): T[];\n\n/**\n * Get the first item in an array or a default value.\n *\n * @see https://radashi.js.org/reference/array/first\n * @example\n * ```ts\n * first([1, 2, 3, 4])\n * // 1\n *\n * first([], 0)\n * // 0\n * ```\n * @version 12.1.0\n */\ndeclare function first<const TArray extends readonly any[], const TDefault = undefined>(array: TArray, defaultValue?: TDefault): TArray extends readonly [infer TFirst, ...any[]] ? TFirst : TArray[number] | TDefault;\n\n/**\n * Given an array of arrays, returns a single dimensional array with\n * all items in it.\n *\n * @see https://radashi.js.org/reference/array/flat\n * @example\n * ```ts\n * flat([[1, 2], [[3], 4], [5]])\n * // [1, 2, [3], 4, 5]\n * ```\n * @version 12.1.0\n */\ndeclare function flat<T>(lists: readonly T[][]): T[];\n\n/**\n * Split an array into two array based on a true/false condition\n * function.\n *\n * @see https://radashi.js.org/reference/array/fork\n * @example\n * ```ts\n * fork([1, 2, 3, 4], (n) => n % 2 === 0)\n * // [[2, 4], [1, 3]]\n * ```\n * @version 12.1.0\n */\ndeclare function fork<T>(array: readonly T[], condition: (item: T) => boolean): [T[], T[]];\n\n/**\n * Categorizes elements from an `array` into distinct groups. The\n * function returns an object where each key is a category identifier\n * determined by the `getGroupId` function, and each value is an array\n * containing all elements that belong to that category.\n *\n * @see https://radashi.js.org/reference/array/group\n * @example\n * ```ts\n * group([1, 2, 3, 4], (n) => n % 2 === 0 ? 'even' : 'odd')\n * // { even: [2, 4], odd: [1, 3] }\n * ```\n * @version 12.1.0\n */\ndeclare function group<T, Key extends string | number | symbol>(array: readonly T[], getGroupId: (item: T, index: number) => Key): {\n    [K in Key]?: T[];\n};\n\n/**\n * Given two arrays, returns true if any elements intersect.\n *\n * @see https://radashi.js.org/reference/array/intersects\n * @example\n * ```ts\n * intersects([1, 2, 3], [4, 5, 6])\n * // false\n *\n * intersects([1, 0, 0], [0, 1], (n) => n > 1)\n * // true\n * ```\n * @version 12.1.0\n */\ndeclare function intersects<T, K>(listA: readonly T[], listB: readonly T[], identity?: (t: T) => K): boolean;\n\n/**\n * Checks if two arrays are equal in length and content using\n * `Object.is` comparison.\n *\n * @see https://radashi.js.org/reference/array/isArrayEqual\n * @example\n * ```ts\n * _.isArrayEqual([1, 2, 3], [1, 2, 3]) // => true\n * _.isArrayEqual([1, 2, 3], [1, 2, 4]) // => false\n * _.isArrayEqual([1, 2], [1, 2, 3]) // => false\n * _.isArrayEqual([], []) // => true\n * _.isArrayEqual([NaN], [NaN]) // => true (Object.is handles NaN)\n * _.isArrayEqual([0], [-0]) // => false (Object.is handles +0 and -0)\n * ```\n * @version 12.7.0\n */\ndeclare function isArrayEqual<T>(array1: T[], array2: T[]): boolean;\n\n/**\n * Like a reduce but does not require an array. Only need a number and\n * will iterate the function as many times as specified.\n *\n * NOTE: This is NOT zero indexed. If you pass count=5 you will get 1,\n * 2, 3, 4, 5 iteration in the callback function.\n *\n * @see https://radashi.js.org/reference/array/iterate\n * @example\n * ```ts\n * iterate(3, (total, i) => total + i, 0)\n * // 6\n * ```\n * @version 12.1.0\n */\ndeclare function iterate<T>(count: number, func: (currentValue: T, iteration: number) => T, initValue: T): T;\n\n/**\n * Get the last item in an array or a default value.\n *\n * @see https://radashi.js.org/reference/array/last\n * @example\n * ```ts\n * last([1, 2, 3, 4])\n * // 4\n *\n * last([], 0)\n * // 0\n * ```\n * @version 12.1.0\n */\ndeclare function last<const TArray extends readonly any[], const TDefault = undefined>(array: TArray, defaultValue?: TDefault): TArray extends readonly [...any[], infer TLast] ? TLast : TArray[number] | TDefault;\n\n/**\n * Creates a list of given start, end, value, and step parameters.\n *\n * @see https://radashi.js.org/reference/array/list\n * @example\n * ```ts\n * list(3)                  // 0, 1, 2, 3\n * list(0, 3)               // 0, 1, 2, 3\n * list(0, 3, 'y')          // y, y, y, y\n * list(0, 3, () => 'y')    // y, y, y, y\n * list(0, 3, i => i)       // 0, 1, 2, 3\n * list(0, 3, i => `y${i}`) // y0, y1, y2, y3\n * list(0, 3, obj)          // obj, obj, obj, obj\n * list(0, 6, i => i, 2)    // 0, 2, 4, 6\n * ```\n * @version 12.1.0\n */\ndeclare function list<T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number): T[];\n\n/**\n * Create a new `Map` instance from an array.\n *\n * @see https://radashi.js.org/reference/array/mapify\n * @example\n * ```ts\n * const array = [\n *   { id: 1, name: 'Fred' },\n *   { id: 2, name: 'Annie' },\n * ]\n *\n * mapify(\n *   array,\n *   item => item.id,\n *   item => item.name,\n * )\n * // Map(2) { 1 => 'Fred', 2 => 'Annie' }\n * ```\n * @version 12.2.0\n */\ndeclare function mapify<T, Key, Value = T>(array: readonly T[], getKey: (item: T, index: number) => Key, getValue?: (item: T, index: number) => Value): Map<Key, Value>;\n\n/**\n * Given two arrays of the same type, iterate the first list and\n * replace items matched by the `matcher` function in the first place.\n * The given arrays are never modified.\n *\n * @see https://radashi.js.org/reference/array/merge\n * @example\n * ```ts\n * merge(\n *   [{id: 1}, {id: 2}],\n *   [{id: 3}, {id: 1, name: 'John'}],\n *   (obj) => obj.id\n * )\n * // [{id: 1, name: 'John'}, {id: 2}]\n * ```\n * @version 12.1.0\n */\ndeclare function merge<T>(prev: readonly T[], array: readonly T[], toKey: (item: T) => any): T[];\n\n/**\n * Convert an array to a dictionary by mapping each item into a\n * dictionary key & value.\n *\n * @see https://radashi.js.org/reference/array/objectify\n * @example\n * ```ts\n * objectify([1, 2, 3], (n) => '#' + n)\n * // { '#1': 1, '#2': 2, '#3': 3 }\n *\n * objectify(\n *   [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}],\n *   (obj) => obj.id,\n *   (obj) => obj.name\n * )\n * // { 1: 'John', 2: 'Jane' }\n * ```\n * @version 12.1.0\n */\ndeclare function objectify<T, Key extends string | number | symbol, Value = T>(array: readonly T[], getKey: (item: T, index: number) => Key, getValue?: (item: T, index: number) => Value): Record<Key, Value>;\n\n/**\n * Extracts values from an array of objects based on specified\n * mappings. Useful for extracting multiple properties from an array\n * of objects (e.g. for tabular data). Also supports “computed\n * properties” via mapping functions, which can combine and transform\n * values on-the-fly.\n *\n * - If mappings are provided, returns an array of arrays where each\n *   inner array contains the values extracted by applying each\n *   mapping to the corresponding object.\n * - If no mappings are provided, returns an array of arrays\n *   containing all values of each object.\n *\n * @see https://radashi.js.org/reference/array/pluck\n * @example\n * ```ts\n * interface God {\n *   name: string;\n *   power: number;\n *   domain: string;\n * }\n *\n * const gods: God[] = [\n *   { name: 'Ra', power: 100, domain: 'Sun' },\n *   { name: 'Zeus', power: 98, domain: 'Lightning' },\n *   { name: 'Loki', power: 72, domain: 'Tricks' }\n * ];\n *\n * // Extract a set of properties\n * pluck(gods, ['power', 'domain']);\n * // [[100, 'Sun'], [98, 'Lightning'], [72, 'Tricks']]\n *\n * // Extract all properties\n * pluck(gods);\n * // [['Ra', 100, 'Sun'], ['Zeus', 98, 'Lightning'], ['Loki', 72, 'Tricks']]\n * ```\n * @version 12.5.0\n */\ndeclare function pluck<T extends object, TMapping extends Mapping<T>>(array: readonly T[], mappings: readonly TMapping[]): MappedOutput<TMapping, T>[];\ndeclare function pluck<T extends object>(array: readonly T[], mappings?: readonly Mapping<T>[]): unknown[];\n\n/**\n * Removes elements from an array based on the specified predicate\n * function.\n *\n * @see https://radashi.js.org/reference/array/remove\n * @example\n * ```ts\n * // Example 1: Remove even numbers from an array\n * const numbers = [1, 2, 3, 4, 5];\n * const result = remove(numbers, value => value % 2 === 0);\n * console.log(result); // Output: [1, 3, 5]\n *\n * // Example 2: Remove objects with a specific property value\n * const items = [\n *   { id: 1, active: true },\n *   { id: 2, active: false },\n *   { id: 3, active: true }\n * ];\n * const result = remove(items, item => item.active);\n * console.log(result); // Output: [{ id: 2, active: false }]\n * ```\n * @version 12.4.0\n */\ndeclare function remove<T>(array: readonly T[], predicate: (value: T) => boolean): T[];\n\n/**\n * Replace an element in an array with a new item without modifying\n * the array and return the new value.\n *\n * @see https://radashi.js.org/reference/array/replace\n * @example\n * ```ts\n * replace([1, 2, 3], 4, (n) => n === 2)\n * // [1, 4, 3]\n * ```\n * @version 12.1.0\n */\ndeclare function replace<T>(array: readonly T[], newItem: T, match: (item: T, idx: number) => boolean): T[];\n\n/**\n * Replace the first occurrence of an item in an array where the\n * `match` function returns true. If no items match, append the new\n * item to the end of the list.\n *\n * @see https://radashi.js.org/reference/array/replaceOrAppend\n * @example\n * ```ts\n * replaceOrAppend([1, 2, 3], 4, (n) => n > 1)\n * // [1, 4, 3]\n *\n * replaceOrAppend([1, 2, 3], 4, (n) => n > 100)\n * // [1, 2, 3, 4]\n * ```\n * @version 12.1.0\n */\ndeclare function replaceOrAppend<T>(array: readonly T[], newItem: T, match: (a: T, idx: number) => boolean): T[];\n\n/**\n * Select performs a filter and a mapper inside of a reduce, only\n * iterating the list one time. If condition is omitted, will\n * select all mapped values that are non-nullish.\n *\n * @see https://radashi.js.org/reference/array/select\n * @example\n * ```ts\n * select(\n *   [1, 2, 3, 4],\n *   x => x * x,\n *   x => x > 2\n * )\n * // => [9, 16]\n * ```\n * @version 12.1.0\n */\ndeclare function select<T, U>(array: readonly T[], mapper: (item: T, index: number) => U, condition: ((item: T, index: number) => boolean) | null | undefined): U[];\ndeclare function select<T, U>(array: readonly T[], mapper: (item: T, index: number) => U | null | undefined): U[];\n\n/**\n * Select performs a find + map operation, short-circuiting on the first\n * element that satisfies the prescribed condition. If condition is omitted,\n * will select the first mapped value which is non-nullish.\n *\n * @see https://radashi.js.org/reference/array/selectFirst\n * @example\n * ```ts\n * selectFirst(\n *   [1, 2, 3, 4],\n *   x => x * x,\n *   x => x > 2\n * )\n * // => 9\n * ```\n * @version 12.2.0\n */\ndeclare function selectFirst<T, U>(array: readonly T[], mapper: (item: T, index: number) => U, condition: (item: T, index: number) => boolean): U | undefined;\ndeclare function selectFirst<T, U>(array: readonly T[], mapper: (item: T, index: number) => U | null | undefined): U | undefined;\n\n/**\n * Shifts array items by `n` steps. If `n` is greater than 0, items\n * will shift `n` steps to the right. If `n` is less than 0, items\n * will shift `n` steps to the left.\n *\n * @see https://radashi.js.org/reference/array/shift\n * @example\n * ```ts\n * shift([1, 2, 3], 1) // [3, 1, 2]\n * shift([1, 2, 3], -1) // [2, 3, 1]\n * ```\n * @version 12.1.0\n */\ndeclare function shift<T>(arr: readonly T[], n: number): T[];\n\n/**\n * Given a list returns a new list with only truthy values.\n *\n * @see https://radashi.js.org/reference/array/sift\n * @example\n * ```ts\n * sift([0, 1, undefined, null, 2, false, 3, ''])\n * // => [1, 2, 3]\n * ```\n * @version 12.1.0\n */\ndeclare function sift<T>(array: readonly (T | Falsy)[]): T[];\n\n/**\n * Sort an array without modifying it and return the newly sorted\n * value.\n *\n * @see https://radashi.js.org/reference/array/sort\n * @example\n * ```ts\n * const fish = [\n *   { name: 'Marlin', weight: 105 },\n *   { name: 'Bass', weight: 8 },\n *   { name: 'Trout', weight: 13 }\n * ]\n *\n * sort(fish, f => f.weight) // => [Bass, Trout, Marlin]\n * sort(fish, f => f.weight, true) // => [Marlin, Trout, Bass]\n * ```\n * @version 12.1.0\n */\ndeclare function sort<T>(array: readonly T[], getter?: (item: T) => number, desc?: boolean): T[];\n\n/**\n * Either adds or removes an item from an array, based on whether it\n * already exists in the array. If multiple items match the given\n * `item`, all matching items will be removed.\n *\n * Note that the given `array` is *not mutated*. A copy of the array\n * is returned with the given item either added or removed.\n *\n * - **\"toKey\" parameter**\n *   - You may define a `toKey` callback, which is a function that\n *   converts an item into a value that can be checked for equality.\n *   When called with the given `item`, an index of -1 will be passed.\n *\n * - **\"strategy\" option**\n *   - You may define a `strategy` option, which determines where the\n *   item should be added in the array.\n *\n * @see https://radashi.js.org/reference/array/toggle\n * @example\n * ```ts\n * toggle([1, 2, 3], 4) // => [1, 2, 3, 4]\n * toggle([1, 2, 3], 2) // => [1, 3]\n *\n * toggle(\n *   [\n *     { id: 1 },\n *     { id: 2 },\n *   ],\n *   { id: 3 },\n *   (obj) => obj.id,\n *   { strategy: 'prepend' }\n * )\n * // => [{ id: 3 }, { id: 1 }, { id: 2 }]\n * ```\n * @version 12.1.0\n */\ndeclare function toggle<T>(array: readonly T[], item: T, toKey?: ((item: T, idx: number) => number | string | symbol) | null, options?: {\n    strategy?: 'prepend' | 'append';\n}): T[];\n\n/**\n * Given a list of items returns a new list with only unique items.\n * Accepts an optional identity function to convert each item in the\n * list to a comparable identity value.\n *\n * @see https://radashi.js.org/reference/array/unique\n * @example\n * ```ts\n * unique([1, 1, 2, 2]) // => [1, 2]\n * unique([1, 2, 3], (n) => n % 2) // => [1, 2]\n * ```\n * @version 12.1.0\n */\ndeclare function unique<T, K = T>(array: readonly T[], toKey?: (item: T) => K): T[];\n\n/**\n * Creates an array of ungrouped elements, where each resulting array\n * contains all elements at a specific index from the input arrays.\n * The first array contains all first elements, the second array\n * contains all second elements, and so on.\n *\n * @see https://radashi.js.org/reference/array/unzip\n * @example\n * ```ts\n * unzip([['a', 1, true], ['b', 2, false]])\n * // [['a', 'b'], [1, 2], [true, false]]\n * ```\n * @version 12.2.0\n */\ndeclare function unzip<T>(arrays: readonly (readonly T[])[]): T[][];\n\n/**\n * Creates an array of grouped elements, the first of which contains\n * the first elements of the given arrays, the second of which\n * contains the second elements of the given arrays, and so on.\n *\n * @see https://radashi.js.org/reference/array/zip\n * @example\n * ```ts\n * zip(['a', 'b'], [1, 2], [true, false])\n * // [['a', 1, true], ['b', 2, false]]\n * ```\n * @version 12.1.0\n */\ndeclare function zip<T1, T2, T3, T4, T5>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[], array5: readonly T5[]): [T1, T2, T3, T4, T5][];\ndeclare function zip<T1, T2, T3, T4>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[]): [T1, T2, T3, T4][];\ndeclare function zip<T1, T2, T3>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[]): [T1, T2, T3][];\ndeclare function zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): [T1, T2][];\n\n/**\n * Creates an object mapping the specified keys to their corresponding\n * values.\n *\n * @see https://radashi.js.org/reference/array/zipToObject\n * @example\n * ```ts\n * zipToObject(['a', 'b'], [1, 2])\n * // { a: 1, b: 2 }\n *\n * zipToObject(['a', 'b'], (k, i) => k + i)\n * // { a: 'a0', b: 'b1' }\n *\n * zipToObject(['a', 'b'], 1)\n * // { a: 1, b: 1 }\n * ```\n * @version 12.1.0\n */\ndeclare function zipToObject<K extends string | number | symbol, V>(keys: readonly K[], values: V | ((key: K, idx: number) => V) | readonly V[]): Record<K, V>;\n\n/**\n * Wait for all promises to resolve. Errors from rejected promises are\n * collected into an `AggregateError`.\n *\n * @see https://radashi.js.org/reference/async/all\n * @example\n * ```ts\n * const [user] = await all([\n *   api.users.create(...),\n *   s3.buckets.create(...),\n *   slack.customerSuccessChannel.sendMessage(...)\n * ])\n * ```\n * @version 12.1.0\n */\ndeclare function all<T extends readonly [unknown, ...unknown[]]>(input: T): Promise<{\n    -readonly [I in keyof T]: Awaited<T[I]>;\n}>;\ndeclare function all<T extends readonly unknown[]>(input: T): Promise<{\n    -readonly [I in keyof T]: Awaited<T[I]>;\n}>;\n/**\n * Check each property in the given object for a promise value. Wait\n * for all promises to resolve. Errors from rejected promises are\n * collected into an `AggregateError`.\n *\n * The returned promise will resolve with an object whose keys are\n * identical to the keys of the input object. The values are the\n * resolved values of the promises.\n *\n * @see https://radashi.js.org/reference/async/all\n * @example\n * ```ts\n * const { user } = await all({\n *   user: api.users.create(...),\n *   bucket: s3.buckets.create(...),\n *   message: slack.customerSuccessChannel.sendMessage(...)\n * })\n * ```\n */\ndeclare function all<T extends Record<string, unknown>>(input: T): Promise<{\n    -readonly [K in keyof T]: Awaited<T[K]>;\n}>;\n\n/**\n * Useful when for script like things where cleanup should be done on\n * fail or success no matter.\n *\n * You can call defer many times to register many deferred functions\n * that will all be called when the function exits in any state.\n *\n * @see https://radashi.js.org/reference/async/defer\n * @example\n * ```ts\n * const result = await defer(async (defer) => {\n *   const fileHandle = await openFile('path/to/file')\n *   defer(() => fileHandle.close())\n *\n *   // Perform operations on the file\n *   return processFile(fileHandle)\n * })\n * ```\n * @version 12.1.0\n */\ndeclare function defer<TResponse>(func: (register: (fn: (error?: any) => any, options?: {\n    rethrow?: boolean;\n}) => void) => Promise<TResponse>): Promise<TResponse>;\n\n/**\n * A helper to try an async function that returns undefined if it\n * fails.\n *\n * @see https://radashi.js.org/reference/async/guard\n * @example\n * ```ts\n * const result = await guard(fetchUsers)() ?? [];\n * ```\n * @version 12.1.0\n */\ndeclare function guard<TFunction extends () => any>(func: TFunction, shouldGuard?: (err: any) => boolean): GuardReturnType<TFunction>;\ntype GuardReturnType<TFunction extends () => any> = TFunction extends () => Promise<infer TResolved> ? Promise<TResolved | undefined> : ReturnType<TFunction> | undefined;\n\n/**\n * An async map function. Works like the built-in Array.map function\n * but handles an async mapper function.\n *\n * @see https://radashi.js.org/reference/async/map\n * @example\n * ```ts\n * const urls = ['/data1', '/data2', '/data3']\n * const responses = await map(urls, async (url) => {\n *   const response = await fetch('https://api.example.com' + url)\n *   return response.json()\n * })\n * ```\n * @version 12.1.0\n */\ndeclare function map<T, K>(array: readonly T[], asyncMapFunc: (item: T, index: number) => PromiseLike<K>): Promise<K[]>;\n\ntype AbortSignal$2 = {\n    readonly aborted: boolean;\n    readonly reason: any;\n    addEventListener(type: 'abort', listener: () => void): void;\n    removeEventListener(type: 'abort', listener: () => void): void;\n    throwIfAborted(): void;\n};\ntype ParallelOptions = {\n    /**\n     * The maximum number of functions to run concurrently. If a\n     * negative number is passed, only one function will run at a time.\n     * If a number bigger than the array `length` is passed, the array\n     * length will be used.\n     */\n    limit: number;\n    signal?: AbortSignal$2;\n};\n/**\n * Executes many async functions in parallel. Returns the results from\n * all functions as an array. After all functions have resolved, if\n * any errors were thrown, they are rethrown in an instance of\n * AggregateError. The operation can be aborted by passing optional AbortSignal,\n * which will throw an Error if aborted.\n *\n * @see https://radashi.js.org/reference/async/parallel\n * @example\n * ```ts\n * // Process images concurrently, resizing each image to a standard size.\n * const abortController = new AbortController();\n * const images = await parallel(\n * {\n *  limit: 2,\n *  signal: abortController.signal,\n * },\n *  imageFiles,\n *  async file => {\n *   return await resizeImage(file)\n * })\n *\n * // To abort the operation:\n * // abortController.abort()\n * ```\n * @version 12.1.0\n */\ndeclare function parallel<T, K>(options: ParallelOptions | number, array: readonly T[], func: (item: T) => Promise<K>): Promise<K[]>;\n\n/**\n * Queues async function calls by key to ensure sequential execution per key.\n * Calls with the same key are executed sequentially, while calls with different\n * keys can run in parallel.\n *\n * @see https://radashi.js.org/reference/async/queueByKey\n * @example\n * ```ts\n * const updateUser = async (userId: string, data: object) => {\n *   // API call that should not overlap for the same user\n *   return fetch(`/api/users/${userId}`, { method: 'POST', body: JSON.stringify(data) })\n * }\n *\n * const queuedUpdate = queueByKey(updateUser, (userId) => userId)\n *\n * // These will run sequentially for user123\n * queuedUpdate('user123', { name: 'Alice' })\n * queuedUpdate('user123', { age: 30 })\n *\n * // This runs in parallel with user123's queue\n * queuedUpdate('user456', { name: 'Bob' })\n * ```\n * @version 12.6.0\n */\ndeclare function queueByKey<TArgs extends any[], TResult>(asyncFn: (...args: TArgs) => TResult | PromiseLike<TResult>, keyFn: (...args: TArgs) => string | number): (...args: TArgs) => Promise<TResult>;\n\n/**\n * An async reduce function. Works like the built-in Array.reduce\n * function but handles an async reducer function.\n *\n * @see https://radashi.js.org/reference/async/reduce\n * @example\n * ```ts\n * const result = await reduce([1, 2, 3], async (acc, item, index) => {\n *   return acc + (await computeOnGPU(item))\n * }, 0)\n * ```\n * @version 12.1.0\n */\ndeclare function reduce<T, K>(array: readonly T[], reducer: (acc: K, item: T, index: number) => Promise<K>, initialValue: K): Promise<K>;\ndeclare function reduce<T, K>(array: readonly T[], reducer: (acc: T | K, item: T, index: number) => Promise<K>): Promise<K>;\n\ntype AbortSignal$1 = {\n    throwIfAborted(): void;\n};\ntype RetryOptions = {\n    times?: number;\n    delay?: number | null;\n    backoff?: (count: number) => number;\n    signal?: AbortSignal$1;\n};\n/**\n * Retries the given function the specified number of times.\n *\n * @see https://radashi.js.org/reference/async/retry\n * @example\n * ```ts\n * const abortController = new AbortController();\n * const result = await retry({ times: 3, delay: 1000, signal: abortController.signal }, async () => {\n *   return await fetch('https://example.com')\n * })\n * // To abort the operation:\n * // abortController.abort()\n * ```\n * @version 12.1.0\n */\ndeclare function retry<TResponse>(options: RetryOptions, func: (exit: (err: any) => void) => Promise<TResponse>): Promise<TResponse>;\n\n/**\n * Create a promise that resolves after a given amount of time.\n *\n * @see https://radashi.js.org/reference/async/sleep\n * @example\n * ```ts\n * await sleep(1000)\n * ```\n * @version 12.1.0\n */\ndeclare function sleep(milliseconds: number): Promise<void>;\n\n/**\n * The `timeout` function creates a promise that rejects after a\n * specified delay, with an optional custom error message or error\n * function.\n *\n * @see https://radashi.js.org/reference/async/timeout\n * @example\n * ```ts\n * // Reject after 1000 milliseconds with default message \"timeout\"\n * await timeout(1000)\n *\n * // Reject after 1000 milliseconds with a custom message\n * await timeout(1000, \"Optional message\")\n *\n * // Reject after 1000 milliseconds with a custom error\n * await timeout(1000, () => new Error(\"Custom error\"))\n *\n * // Example usage with Promise.race to set a timeout for an asynchronous task\n * await Promise.race([\n *  someAsyncTask(),\n *  timeout(1000, \"Optional message\"),\n * ])\n * ```\n * @version 12.3.0\n */\ndeclare function timeout<TError extends Error>(\n/**\n * The number of milliseconds to wait before rejecting.\n */\nms: number, \n/**\n * An error message or a function that returns an error. By default,\n * a `TimeoutError` is thrown with the message \"Operation timed\n * out\".\n */\nerror?: string | (() => TError)): Promise<never>;\n\ninterface BigInt {\n    /**\n     * Returns a string representation of an object.\n     * @param radix Specifies a radix for converting numeric values to strings.\n     */\n    toString(radix?: number): string;\n    /** Returns a string representation appropriate to the host environment's current locale. */\n    toLocaleString(locales?: any, options?: BigIntToLocaleStringOptions): string;\n    /** Returns the primitive value of the specified object. */\n    valueOf(): bigint;\n    readonly [Symbol.toStringTag]: \"BigInt\";\n}\n/**\n * A typed array of 64-bit signed integer values. The contents are initialized to 0. If the\n * requested number of bytes could not be allocated, an exception is raised.\n */\ninterface BigInt64Array {\n    /** The size in bytes of each element in the array. */\n    readonly BYTES_PER_ELEMENT: number;\n    /** The ArrayBuffer instance referenced by the array. */\n    readonly buffer: ArrayBufferLike;\n    /** The length in bytes of the array. */\n    readonly byteLength: number;\n    /** The offset in bytes of the array. */\n    readonly byteOffset: number;\n    /**\n     * Returns the this object after copying a section of the array identified by start and end\n     * to the same array starting at position target\n     * @param target If target is negative, it is treated as length+target where length is the\n     * length of the array.\n     * @param start If start is negative, it is treated as length+start. If end is negative, it\n     * is treated as length+end.\n     * @param end If not specified, length of the this object is used as its default value.\n     */\n    copyWithin(target: number, start: number, end?: number): this;\n    /** Yields index, value pairs for every entry in the array. */\n    entries(): IterableIterator<[number, bigint]>;\n    /**\n     * Determines whether all the members of an array satisfy the specified test.\n     * @param predicate A function that accepts up to three arguments. The every method calls\n     * the predicate function for each element in the array until the predicate returns false,\n     * or until the end of the array.\n     * @param thisArg An object to which the this keyword can refer in the predicate function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    every(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;\n    /**\n     * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array\n     * @param value value to fill array section with\n     * @param start index to start filling the array at. If start is negative, it is treated as\n     * length+start where length is the length of the array.\n     * @param end index to stop filling the array at. If end is negative, it is treated as\n     * length+end.\n     */\n    fill(value: bigint, start?: number, end?: number): this;\n    /**\n     * Returns the elements of an array that meet the condition specified in a callback function.\n     * @param predicate A function that accepts up to three arguments. The filter method calls\n     * the predicate function one time for each element in the array.\n     * @param thisArg An object to which the this keyword can refer in the predicate function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    filter(predicate: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array;\n    /**\n     * Returns the value of the first element in the array where predicate is true, and undefined\n     * otherwise.\n     * @param predicate find calls predicate once for each element of the array, in ascending\n     * order, until it finds one where predicate returns true. If such an element is found, find\n     * immediately returns that element value. Otherwise, find returns undefined.\n     * @param thisArg If provided, it will be used as the this value for each invocation of\n     * predicate. If it is not provided, undefined is used instead.\n     */\n    find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined;\n    /**\n     * Returns the index of the first element in the array where predicate is true, and -1\n     * otherwise.\n     * @param predicate find calls predicate once for each element of the array, in ascending\n     * order, until it finds one where predicate returns true. If such an element is found,\n     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.\n     * @param thisArg If provided, it will be used as the this value for each invocation of\n     * predicate. If it is not provided, undefined is used instead.\n     */\n    findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number;\n    /**\n     * Performs the specified action for each element in an array.\n     * @param callbackfn A function that accepts up to three arguments. forEach calls the\n     * callbackfn function one time for each element in the array.\n     * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void;\n    /**\n     * Determines whether an array includes a certain element, returning true or false as appropriate.\n     * @param searchElement The element to search for.\n     * @param fromIndex The position in this array at which to begin searching for searchElement.\n     */\n    includes(searchElement: bigint, fromIndex?: number): boolean;\n    /**\n     * Returns the index of the first occurrence of a value in an array.\n     * @param searchElement The value to locate in the array.\n     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\n     * search starts at index 0.\n     */\n    indexOf(searchElement: bigint, fromIndex?: number): number;\n    /**\n     * Adds all the elements of an array separated by the specified separator string.\n     * @param separator A string used to separate one element of an array from the next in the\n     * resulting String. If omitted, the array elements are separated with a comma.\n     */\n    join(separator?: string): string;\n    /** Yields each index in the array. */\n    keys(): IterableIterator<number>;\n    /**\n     * Returns the index of the last occurrence of a value in an array.\n     * @param searchElement The value to locate in the array.\n     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\n     * search starts at index 0.\n     */\n    lastIndexOf(searchElement: bigint, fromIndex?: number): number;\n    /** The length of the array. */\n    readonly length: number;\n    /**\n     * Calls a defined callback function on each element of an array, and returns an array that\n     * contains the results.\n     * @param callbackfn A function that accepts up to three arguments. The map method calls the\n     * callbackfn function one time for each element in the array.\n     * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array;\n    /**\n     * Calls the specified callback function for all the elements in an array. The return value of\n     * the callback function is the accumulated result, and is provided as an argument in the next\n     * call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\n     * callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an argument\n     * instead of an array value.\n     */\n    reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;\n    /**\n     * Calls the specified callback function for all the elements in an array. The return value of\n     * the callback function is the accumulated result, and is provided as an argument in the next\n     * call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\n     * callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an argument\n     * instead of an array value.\n     */\n    reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;\n    /**\n     * Calls the specified callback function for all the elements in an array, in descending order.\n     * The return value of the callback function is the accumulated result, and is provided as an\n     * argument in the next call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\n     * the callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an\n     * argument instead of an array value.\n     */\n    reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;\n    /**\n     * Calls the specified callback function for all the elements in an array, in descending order.\n     * The return value of the callback function is the accumulated result, and is provided as an\n     * argument in the next call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\n     * the callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an argument\n     * instead of an array value.\n     */\n    reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;\n    /** Reverses the elements in the array. */\n    reverse(): this;\n    /**\n     * Sets a value or an array of values.\n     * @param array A typed or untyped array of values to set.\n     * @param offset The index in the current array at which the values are to be written.\n     */\n    set(array: ArrayLike<bigint>, offset?: number): void;\n    /**\n     * Returns a section of an array.\n     * @param start The beginning of the specified portion of the array.\n     * @param end The end of the specified portion of the array.\n     */\n    slice(start?: number, end?: number): BigInt64Array;\n    /**\n     * Determines whether the specified callback function returns true for any element of an array.\n     * @param predicate A function that accepts up to three arguments. The some method calls the\n     * predicate function for each element in the array until the predicate returns true, or until\n     * the end of the array.\n     * @param thisArg An object to which the this keyword can refer in the predicate function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    some(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;\n    /**\n     * Sorts the array.\n     * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order.\n     */\n    sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this;\n    /**\n     * Gets a new BigInt64Array view of the ArrayBuffer store for this array, referencing the elements\n     * at begin, inclusive, up to end, exclusive.\n     * @param begin The index of the beginning of the array.\n     * @param end The index of the end of the array.\n     */\n    subarray(begin?: number, end?: number): BigInt64Array;\n    /** Converts the array to a string by using the current locale. */\n    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string;\n    /** Returns a string representation of the array. */\n    toString(): string;\n    /** Returns the primitive value of the specified object. */\n    valueOf(): BigInt64Array;\n    /** Yields each value in the array. */\n    values(): IterableIterator<bigint>;\n    [Symbol.iterator](): IterableIterator<bigint>;\n    readonly [Symbol.toStringTag]: \"BigInt64Array\";\n    [index: number]: bigint;\n}\n/**\n * A typed array of 64-bit unsigned integer values. The contents are initialized to 0. If the\n * requested number of bytes could not be allocated, an exception is raised.\n */\ninterface BigUint64Array {\n    /** The size in bytes of each element in the array. */\n    readonly BYTES_PER_ELEMENT: number;\n    /** The ArrayBuffer instance referenced by the array. */\n    readonly buffer: ArrayBufferLike;\n    /** The length in bytes of the array. */\n    readonly byteLength: number;\n    /** The offset in bytes of the array. */\n    readonly byteOffset: number;\n    /**\n     * Returns the this object after copying a section of the array identified by start and end\n     * to the same array starting at position target\n     * @param target If target is negative, it is treated as length+target where length is the\n     * length of the array.\n     * @param start If start is negative, it is treated as length+start. If end is negative, it\n     * is treated as length+end.\n     * @param end If not specified, length of the this object is used as its default value.\n     */\n    copyWithin(target: number, start: number, end?: number): this;\n    /** Yields index, value pairs for every entry in the array. */\n    entries(): IterableIterator<[number, bigint]>;\n    /**\n     * Determines whether all the members of an array satisfy the specified test.\n     * @param predicate A function that accepts up to three arguments. The every method calls\n     * the predicate function for each element in the array until the predicate returns false,\n     * or until the end of the array.\n     * @param thisArg An object to which the this keyword can refer in the predicate function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    every(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;\n    /**\n     * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array\n     * @param value value to fill array section with\n     * @param start index to start filling the array at. If start is negative, it is treated as\n     * length+start where length is the length of the array.\n     * @param end index to stop filling the array at. If end is negative, it is treated as\n     * length+end.\n     */\n    fill(value: bigint, start?: number, end?: number): this;\n    /**\n     * Returns the elements of an array that meet the condition specified in a callback function.\n     * @param predicate A function that accepts up to three arguments. The filter method calls\n     * the predicate function one time for each element in the array.\n     * @param thisArg An object to which the this keyword can refer in the predicate function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    filter(predicate: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array;\n    /**\n     * Returns the value of the first element in the array where predicate is true, and undefined\n     * otherwise.\n     * @param predicate find calls predicate once for each element of the array, in ascending\n     * order, until it finds one where predicate returns true. If such an element is found, find\n     * immediately returns that element value. Otherwise, find returns undefined.\n     * @param thisArg If provided, it will be used as the this value for each invocation of\n     * predicate. If it is not provided, undefined is used instead.\n     */\n    find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined;\n    /**\n     * Returns the index of the first element in the array where predicate is true, and -1\n     * otherwise.\n     * @param predicate find calls predicate once for each element of the array, in ascending\n     * order, until it finds one where predicate returns true. If such an element is found,\n     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.\n     * @param thisArg If provided, it will be used as the this value for each invocation of\n     * predicate. If it is not provided, undefined is used instead.\n     */\n    findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number;\n    /**\n     * Performs the specified action for each element in an array.\n     * @param callbackfn A function that accepts up to three arguments. forEach calls the\n     * callbackfn function one time for each element in the array.\n     * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void;\n    /**\n     * Determines whether an array includes a certain element, returning true or false as appropriate.\n     * @param searchElement The element to search for.\n     * @param fromIndex The position in this array at which to begin searching for searchElement.\n     */\n    includes(searchElement: bigint, fromIndex?: number): boolean;\n    /**\n     * Returns the index of the first occurrence of a value in an array.\n     * @param searchElement The value to locate in the array.\n     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\n     * search starts at index 0.\n     */\n    indexOf(searchElement: bigint, fromIndex?: number): number;\n    /**\n     * Adds all the elements of an array separated by the specified separator string.\n     * @param separator A string used to separate one element of an array from the next in the\n     * resulting String. If omitted, the array elements are separated with a comma.\n     */\n    join(separator?: string): string;\n    /** Yields each index in the array. */\n    keys(): IterableIterator<number>;\n    /**\n     * Returns the index of the last occurrence of a value in an array.\n     * @param searchElement The value to locate in the array.\n     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\n     * search starts at index 0.\n     */\n    lastIndexOf(searchElement: bigint, fromIndex?: number): number;\n    /** The length of the array. */\n    readonly length: number;\n    /**\n     * Calls a defined callback function on each element of an array, and returns an array that\n     * contains the results.\n     * @param callbackfn A function that accepts up to three arguments. The map method calls the\n     * callbackfn function one time for each element in the array.\n     * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array;\n    /**\n     * Calls the specified callback function for all the elements in an array. The return value of\n     * the callback function is the accumulated result, and is provided as an argument in the next\n     * call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\n     * callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an argument\n     * instead of an array value.\n     */\n    reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;\n    /**\n     * Calls the specified callback function for all the elements in an array. The return value of\n     * the callback function is the accumulated result, and is provided as an argument in the next\n     * call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\n     * callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an argument\n     * instead of an array value.\n     */\n    reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;\n    /**\n     * Calls the specified callback function for all the elements in an array, in descending order.\n     * The return value of the callback function is the accumulated result, and is provided as an\n     * argument in the next call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\n     * the callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an\n     * argument instead of an array value.\n     */\n    reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;\n    /**\n     * Calls the specified callback function for all the elements in an array, in descending order.\n     * The return value of the callback function is the accumulated result, and is provided as an\n     * argument in the next call to the callback function.\n     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\n     * the callbackfn function one time for each element in the array.\n     * @param initialValue If initialValue is specified, it is used as the initial value to start\n     * the accumulation. The first call to the callbackfn function provides this value as an argument\n     * instead of an array value.\n     */\n    reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;\n    /** Reverses the elements in the array. */\n    reverse(): this;\n    /**\n     * Sets a value or an array of values.\n     * @param array A typed or untyped array of values to set.\n     * @param offset The index in the current array at which the values are to be written.\n     */\n    set(array: ArrayLike<bigint>, offset?: number): void;\n    /**\n     * Returns a section of an array.\n     * @param start The beginning of the specified portion of the array.\n     * @param end The end of the specified portion of the array.\n     */\n    slice(start?: number, end?: number): BigUint64Array;\n    /**\n     * Determines whether the specified callback function returns true for any element of an array.\n     * @param predicate A function that accepts up to three arguments. The some method calls the\n     * predicate function for each element in the array until the predicate returns true, or until\n     * the end of the array.\n     * @param thisArg An object to which the this keyword can refer in the predicate function.\n     * If thisArg is omitted, undefined is used as the this value.\n     */\n    some(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;\n    /**\n     * Sorts the array.\n     * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order.\n     */\n    sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this;\n    /**\n     * Gets a new BigUint64Array view of the ArrayBuffer store for this array, referencing the elements\n     * at begin, inclusive, up to end, exclusive.\n     * @param begin The index of the beginning of the array.\n     * @param end The index of the end of the array.\n     */\n    subarray(begin?: number, end?: number): BigUint64Array;\n    /** Converts the array to a string by using the current locale. */\n    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string;\n    /** Returns a string representation of the array. */\n    toString(): string;\n    /** Returns the primitive value of the specified object. */\n    valueOf(): BigUint64Array;\n    /** Yields each value in the array. */\n    values(): IterableIterator<bigint>;\n    [Symbol.iterator](): IterableIterator<bigint>;\n    readonly [Symbol.toStringTag]: \"BigUint64Array\";\n    [index: number]: bigint;\n}\ninterface BigIntToLocaleStringOptions {\n    /**\n     * The locale matching algorithm to use.The default is \"best fit\". For information about this option, see the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation Intl page}.\n     */\n    localeMatcher?: string;\n    /**\n     * The formatting style to use , the default is \"decimal\".\n     */\n    style?: string;\n    numberingSystem?: string;\n    /**\n     * The unit to use in unit formatting, Possible values are core unit identifiers, defined in UTS #35, Part 2, Section 6. A subset of units from the full list was selected for use in ECMAScript. Pairs of simple units can be concatenated with \"-per-\" to make a compound unit. There is no default value; if the style is \"unit\", the unit property must be provided.\n     */\n    unit?: string;\n    /**\n     * The unit formatting style to use in unit formatting, the defaults is \"short\".\n     */\n    unitDisplay?: string;\n    /**\n     * The currency to use in currency formatting. Possible values are the ISO 4217 currency codes, such as \"USD\" for the US dollar, \"EUR\" for the euro, or \"CNY\" for the Chinese RMB — see the Current currency & funds code list. There is no default value; if the style is \"currency\", the currency property must be provided. It is only used when [[Style]] has the value \"currency\".\n     */\n    currency?: string;\n    /**\n     * How to display the currency in currency formatting. It is only used when [[Style]] has the value \"currency\". The default is \"symbol\".\n     *\n     * \"symbol\" to use a localized currency symbol such as €,\n     *\n     * \"code\" to use the ISO currency code,\n     *\n     * \"name\" to use a localized currency name such as \"dollar\"\n     */\n    currencyDisplay?: string;\n    /**\n     * Whether to use grouping separators, such as thousands separators or thousand/lakh/crore separators. The default is true.\n     */\n    useGrouping?: boolean;\n    /**\n     * The minimum number of integer digits to use. Possible values are from 1 to 21; the default is 1.\n     */\n    minimumIntegerDigits?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21;\n    /**\n     * The minimum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number and percent formatting is 0; the default for currency formatting is the number of minor unit digits provided by the {@link http://www.currency-iso.org/en/home/tables/table-a1.html ISO 4217 currency codes list} (2 if the list doesn't provide that information).\n     */\n    minimumFractionDigits?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;\n    /**\n     * The maximum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number formatting is the larger of minimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits and the number of minor unit digits provided by the {@link http://www.currency-iso.org/en/home/tables/table-a1.html ISO 4217 currency codes list} (2 if the list doesn't provide that information); the default for percent formatting is the larger of minimumFractionDigits and 0.\n     */\n    maximumFractionDigits?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;\n    /**\n     * The minimum number of significant digits to use. Possible values are from 1 to 21; the default is 1.\n     */\n    minimumSignificantDigits?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21;\n    /**\n     * The maximum number of significant digits to use. Possible values are from 1 to 21; the default is 21.\n     */\n    maximumSignificantDigits?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21;\n    /**\n     * The formatting that should be displayed for the number, the defaults is \"standard\"\n     *\n     *     \"standard\" plain number formatting\n     *\n     *     \"scientific\" return the order-of-magnitude for formatted number.\n     *\n     *     \"engineering\" return the exponent of ten when divisible by three\n     *\n     *     \"compact\" string representing exponent, defaults is using the \"short\" form\n     */\n    notation?: string;\n    /**\n     * used only when notation is \"compact\"\n     */\n    compactDisplay?: string;\n}\n\ntype Awaitable<T> = T | PromiseLike<T>;\n/**\n * Represents values that are considered \"falsy\" in JavaScript. These\n * values cause the condition in an `if` statement or ternary\n * expression to be false, leading to the execution of the `else`\n * branch.\n */\ntype Falsy = null | undefined | false | '' | 0 | 0n;\n/**\n * The `Any` class does not exist at runtime. It's used in type\n * definitions to detect an `any` type.\n *\n * ```ts\n * type IsAny<T> = [T] extends [Any] ? 'is any' : 'is not any'\n * ```\n */\ndeclare class Any {\n    private any;\n}\n/**\n * Represents a class constructor.\n */\ntype Class<TArgs extends any[] = any[], TReturn = any> = new (...args: TArgs) => TReturn;\n/**\n * Extracts `T` if `T` is not `any`, otherwise `never`.\n *\n * ```ts\n * type A = ExtractNotAny<any, string>\n * //   ^? never\n * type B = ExtractNotAny<string | number, string>\n * //   ^? string\n * ```\n */\ntype ExtractNotAny<T, U> = Extract<[T] extends [Any] ? never : T, U>;\ntype SwitchAny<T, U> = [T] extends [Any] ? U : T;\ntype SwitchNever<T, U> = [T] extends [never] ? U : T;\n/**\n * Prevent type inference on type `T`.\n *\n * @see https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546\n */\ntype NoInfer$1<T> = [T][T extends any ? 0 : never];\n/**\n * Extract types in `T` that are assignable to `U`. Coerce `any` and\n * `never` types to unknown.\n */\ntype StrictExtract<T, U> = SwitchNever<Extract<SwitchAny<T, unknown>, U>, unknown>;\n/**\n * Resolve a type union of property name literals within type `T`\n * whose property values are assignable to type `TConstraint`. If `T`\n * is a primitive, it's first transformed into its boxed equivalent\n * (e.g. `string` becomes `String`, `number` becomes `Number`, and so\n * on).\n *\n * Use case: “I want to know which properties of `T` are compatible\n * with `TConstraint`.”\n */\ntype CompatibleProperty<T, TConstraint> = [T] extends [Any] ? keyof any : T extends null | undefined ? never : (T extends object ? T : BoxedPrimitive<T>) extends infer TObject ? {\n    [P in keyof TObject]: TObject[P] extends TConstraint ? P : never;\n}[keyof TObject] : never;\n/**\n * A value that can be reliably compared with JavaScript comparison\n * operators (e.g. `>`, `>=`, etc).\n */\ntype Comparable = number | string | bigint | {\n    valueOf: () => number | string | bigint;\n} | {\n    [Symbol.toPrimitive](hint: 'number'): number;\n} | {\n    [Symbol.toPrimitive](hint: 'string'): string;\n};\n/**\n * Extract a string union of property names from type `T` whose value\n * can be compared with `>`, `>=`, etc.\n */\ntype ComparableProperty<T> = CompatibleProperty<T, Comparable>;\n/**\n * A comparator function. It can be passed to the `sort` method of\n * arrays to sort the elements.\n *\n * Return a negative number to sort the “left” value before the “right”\n * value, a positive number to sort the “right” value before the “left”\n * value, and 0 to keep the order of the values.\n */\ntype Comparator<T> = (left: T, right: T) => number;\n/** Convert a union to an intersection */\ntype Intersect<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;\n/**\n * Useful to flatten the type output to improve type hints shown in\n * editors. And also to transform an interface into a type to aide\n * with assignability.\n *\n * @see https://github.com/microsoft/TypeScript/issues/15300\n */\ntype Simplify<T> = {} & {\n    [P in keyof T]: T[P];\n};\n/**\n * A result tuple where the error is `undefined`.\n *\n * @example\n * ```ts\n * type GoodResult = Ok<string>\n * //   ^? [undefined, string]\n * ```\n */\ntype Ok<TResult> = [err: undefined, result: TResult];\n/**\n * A result tuple where an error is included.\n *\n * Note that `TError` is non-nullable, which means that\n * `Err<undefined>` and `Err<null>` are not valid.\n *\n * @example\n * ```ts\n * type BadResult = Err\n * //   ^? [Error, undefined]\n *\n * type BadResult2 = Err<TypeError | MyCoolCustomError>\n * //   ^? [TypeError | MyCoolCustomError, undefined]\n * ```\n */\ntype Err<TError extends Error = Error> = [err: TError, result: undefined];\n/**\n * A result tuple.\n *\n * First index is the error, second index is the result.\n *\n * @example\n * ```ts\n * type MyResult = Result<string>\n * //   ^? Ok<string> | Err<Error>\n *\n * type MyResult2 = Result<string, TypeError>\n * //   ^? Ok<string> | Err<TypeError>\n * ```\n */\ntype Result<TResult, TError extends Error = Error> = Ok<TResult> | Err<TError>;\n/**\n * A promise that resolves to a result tuple.\n *\n * @example\n * ```ts\n * type MyResult = ResultPromise<string>\n * //   ^? Promise<Ok<string> | Err<Error>>\n *\n * type MyResult2 = ResultPromise<string, TypeError>\n * //   ^? Promise<Ok<string> | Err<TypeError>>\n * ```\n */\ntype ResultPromise<TResult, TError extends Error = Error> = Promise<[\n    TError\n] extends [never] ? Ok<TResult> : [TResult] extends [never] ? Err<TError> : Result<TResult, TError>>;\n/**\n * Get all properties **not using** the `?:` type operator.\n */\ntype RequiredKeys<T> = T extends any ? keyof T extends infer K ? K extends keyof T ? Omit<T, K> extends T ? never : K : never : never : never;\n/**\n * Get all properties using the `?:` type operator.\n */\ntype OptionalKeys<T> = T extends any ? keyof T extends infer K ? K extends keyof T ? Omit<T, K> extends T ? K : never : never : never : never;\n/**\n * Resolves to `true` if `Left` and `Right` are exactly the same type.\n *\n * Otherwise false.\n */\ntype IsExactType<Left, Right> = [Left] extends [Any] ? [Right] extends [Any] ? true : false : (<U>() => U extends Left ? 1 : 0) extends <U>() => U extends Right ? 1 : 0 ? true : false;\ntype Primitive = number | string | boolean | symbol | bigint | null | undefined | void;\n/**\n * Coerce a primitive type to its boxed equivalent.\n *\n * @example\n * ```ts\n * type A = BoxedPrimitive<string>\n * //   ^? String\n * type B = BoxedPrimitive<number>\n * //   ^? Number\n * ```\n */\ntype BoxedPrimitive<T = any> = T extends string ? String : T extends number ? Number : T extends boolean ? Boolean : T extends bigint ? BigInt : T extends symbol ? Symbol : never;\ntype TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | DataView | ArrayBuffer | SharedArrayBuffer;\n/**\n * Add your own classes to this registry by extending its interface\n * with what's called “declaration merging” in TypeScript.\n *\n * All property types in this registry type may be treated specially\n * by any of Radashi's complex types. For example, `assign` will avoid\n * merging with types in this registry.\n */\ninterface CustomClassRegistry {\n}\n/**\n * This type represents any custom class that was \"registered\" through\n * the `CustomClassRegistry` type.\n */\ntype CustomClass = CustomClassRegistry[keyof CustomClassRegistry];\n/**\n * These types are implemented natively.\n *\n * Note that boxed primitives like `Boolean` (different from\n * `boolean`) are not included, because `boolean extends Boolean ? 1 :\n * 0` resolves to 1.\n */\ntype BuiltInType = ES2021.BuiltInType | WebAPI.BuiltInType | NodeJS.BuiltInType;\ndeclare namespace ES2020 {\n    type BuiltInType = Primitive | Promise<any> | Date | RegExp | Error | readonly any[] | ReadonlyMap<any, any> | ReadonlySet<any> | WeakMap<WeakKey, any> | WeakSet<WeakKey> | TypedArray | Function;\n}\ndeclare namespace ES2021 {\n    type BuiltInType = ES2020.BuiltInType | GlobalObjectType<'FinalizationRegistry'> | GlobalObjectType<'WeakRef'>;\n}\ndeclare namespace NodeJS {\n    type BuiltInType = GlobalObjectType<'Buffer'>;\n}\ndeclare namespace WebAPI {\n    type BuiltInType = GlobalObjectType<'AbortController'> | GlobalObjectType<'AbortSignal'> | GlobalObjectType<'Blob'> | GlobalObjectType<'Body'> | GlobalObjectType<'CompressionStream'> | GlobalObjectType<'Crypto'> | GlobalObjectType<'CustomEvent'> | GlobalObjectType<'DecompressionStream'> | GlobalObjectType<'Event'> | GlobalObjectType<'EventTarget'> | GlobalObjectType<'FormData'> | GlobalObjectType<'Headers'> | GlobalObjectType<'MessageChannel'> | GlobalObjectType<'Navigator'> | GlobalObjectType<'ReadableStream'> | GlobalObjectType<'ReadableStreamBYOBReader'> | GlobalObjectType<'ReadableStreamDefaultController'> | GlobalObjectType<'ReadableStreamDefaultReader'> | GlobalObjectType<'SubtleCrypto'> | GlobalObjectType<'TextDecoder'> | GlobalObjectType<'TextDecoderStream'> | GlobalObjectType<'TextEncoder'> | GlobalObjectType<'TextEncoderStream'> | GlobalObjectType<'TransformStream'> | GlobalObjectType<'TransformStreamDefaultController'> | GlobalObjectType<'URL'> | GlobalObjectType<'URLSearchParams'> | GlobalObjectType<'WebSocket'> | GlobalObjectType<'WritableStream'> | GlobalObjectType<'WritableStreamDefaultController'> | GlobalObjectType<'WritableStreamDefaultWriter'> | WebDocumentAPI.BuiltInType;\n}\ndeclare namespace WebDocumentAPI {\n    type BuiltInType = GlobalObjectType<'Node'> | GlobalObjectType<'NodeList'> | GlobalObjectType<'NodeIterator'> | GlobalObjectType<'HTMLCollection'> | GlobalObjectType<'CSSStyleDeclaration'> | GlobalObjectType<'DOMStringList'> | GlobalObjectType<'DOMTokenList'>;\n}\ntype GlobalObjectType<Identifier extends string> = [Identifier] extends [Any] ? never : keyof Identifier extends never ? never : typeof globalThis extends {\n    [P in Identifier]: any;\n} ? InstanceType<(typeof globalThis)[Identifier]> : never;\n\n/**\n * Converts a `PromiseLike` to a `Promise<Result>`.\n *\n * Note: If the given promise throws a non-Error value, it will be\n * rethrown.\n *\n * @see https://radashi.js.org/reference/async/toResult\n * @example\n * ```ts\n * import { toResult, Result } from 'radashi'\n *\n * const good = async (): Promise<number> => 1\n * const bad = async (): Promise<number> => { throw new Error('bad') }\n *\n * const goodResult = await toResult(good())\n * // => [undefined, 1]\n *\n * const badResult = await toResult(bad())\n * // => [Error('bad'), undefined]\n * ```\n * @version 12.4.0\n */\ndeclare function toResult<T>(promise: PromiseLike<T>): Promise<Result<T>>;\n\n/**\n * The result of a `tryit` function.\n *\n * If the function returns a promise, the result is a promise that\n * resolves to an error-first callback-_like_ array response as\n * `[Error, result]`.\n *\n * If the function returns a non-promise, the result is an error-first\n * callback-_like_ array response as `[Error, result]`.\n *\n * @see https://radashi.js.org/reference/async/tryit\n * @example\n * ```ts\n * const [err, result] = await tryit(async () => {\n *   return await fetch('https://example.com')\n * })\n * ```\n * @version 12.1.0\n */\ntype TryitResult<TReturn, TError extends Error = Error> = TReturn extends PromiseLike<infer TResult> ? ResultPromise<TResult, TError> : Result<TReturn, TError>;\n/**\n * A helper to try an async function without forking the control flow.\n * Returns an error-first callback-_like_ array response as `[Error,\n * result]`\n */\ndeclare function tryit<TArgs extends any[], TReturn, TError extends Error = Error>(func: (...args: TArgs) => TReturn): (...args: TArgs) => TryitResult<TReturn, TError>;\n\ninterface PromiseWithResolvers<T> {\n    promise: Promise<T>;\n    resolve: (value: T | PromiseLike<T>) => void;\n    reject: (reason?: any) => void;\n}\n/**\n * Creates a new promise and returns the resolve and reject functions along with the promise itself.\n *\n * The ponyfill for https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers\n *\n * @see https://radashi.js.org/reference/async/withResolvers\n * @example\n * ```ts\n * const {resolve, reject, promise} = withResolvers()\n *\n * resolve(42)\n * ```\n * @version 12.2.0\n */\ndeclare function withResolvers<T>(): PromiseWithResolvers<T>;\n\n/**\n * Make an object callable. Given an object and a function the\n * returned object will be a function with all the objects properties.\n *\n * @see https://radashi.js.org/reference/curry/callable\n * @example\n * ```ts\n * const car = callable({\n *   wheels: 2\n * }, self => () => {\n *   return 'driving'\n * })\n *\n * car.wheels // => 2\n * car() // => 'driving'\n * ```\n * @version 12.1.0\n */\ndeclare function callable<TValue, TObj extends Record<string | number | symbol, TValue>, TFunc extends (...args: any) => any>(obj: TObj, fn: (self: TObj) => TFunc): TObj & TFunc;\n\n/**\n * Create a function that chains multiple functions together. The\n * functions are called in order. Each function takes the result of\n * the previous function as its first argument.\n *\n * @see https://radashi.js.org/reference/curry/chain\n * @example\n * ```ts\n * const myChainedFunc = chain(\n *   (x) => x + 5,\n *   (x) => x * 2,\n * )\n *\n * myChainedFunc(0)\n * // => 10\n * ```\n * @version 12.1.0\n */\ndeclare function chain<T1 extends any[], T2, T3>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3): (...arg: T1) => T3;\ndeclare function chain<T1 extends any[], T2, T3, T4>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4): (...arg: T1) => T4;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5): (...arg: T1) => T5;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5, T6>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6): (...arg: T1) => T6;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7): (...arg: T1) => T7;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8): (...arg: T1) => T8;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9): (...arg: T1) => T9;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9, f9: (arg: T3) => T10): (...arg: T1) => T10;\ndeclare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9, f9: (arg: T3) => T10, f10: (arg: T3) => T11): (...arg: T1) => T11;\n\n/**\n * Create a function that composes multiple functions together. In a\n * composition of functions, each function is given the next function\n * as an argument and must call it to continue executing.\n *\n * @see https://radashi.js.org/reference/curry/compose\n * @example\n * ```ts\n * const myComposedFunc = compose(\n *   (x) => x + 5,\n *   (x) => x * 2,\n * )\n *\n * myComposedFunc(0)\n * // => 5\n * ```\n * @version 12.1.0\n */\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], LastResult>(f1: (next: (...args: F1NextArgs) => LastResult) => (...args: F1Args) => F1Result, last: (...args: F1NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2Result, F2NextArgs extends any[], LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => LastResult) => (...args: F1NextArgs) => F2Result, last: (...args: F2NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => LastResult) => (...args: F2NextArgs) => F3Result, last: (...args: F3NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => LastResult) => (...args: F3NextArgs) => F4Result, last: (...args: F4NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => LastResult) => (...args: F4NextArgs) => F5Result, last: (...args: F5NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => LastResult) => (...args: F5NextArgs) => F6Result, last: (...args: F6NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, last: (...args: F7NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, F8NextArgs extends any[], F8Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, f8: (next: (...args: F8NextArgs) => LastResult) => (...args: F7NextArgs) => F8Result, last: (...args: F8NextArgs) => LastResult): (...args: F1Args) => F1Result;\ndeclare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, F8NextArgs extends any[], F8Result, F9NextArgs extends any[], F9Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, f8: (next: (...args: F8NextArgs) => LastResult) => (...args: F7NextArgs) => F8Result, f9: (next: (...args: F9NextArgs) => LastResult) => (...args: F8NextArgs) => F9Result, last: (...args: F9NextArgs) => LastResult): (...args: F1Args) => F1Result;\n\ntype DebounceFunction<TArgs extends any[]> = {\n    (...args: TArgs): void;\n    /**\n     * When called, future invocations of the debounced function are\n     * no longer delayed and are instead executed immediately.\n     */\n    cancel(): void;\n    /**\n     * Returns `true` if the underlying function is scheduled to be\n     * called once the delay has passed.\n     */\n    isPending(): boolean;\n    /**\n     * Invoke the underlying function immediately.\n     */\n    flush(...args: TArgs): void;\n};\ninterface DebounceOptions {\n    delay: number;\n    /**\n     * When true, your callback is invoked immediately the very first\n     * time the debounced function is called. After that, the debounced\n     * function works as if `leading` was `false`.\n     *\n     * @default false\n     */\n    leading?: boolean;\n}\n/**\n * Returns a new function that will only call your callback after\n * `delay` milliseconds have passed without any invocations.\n *\n * The debounced function has a few methods, such as `cancel`,\n * `isPending`, and `flush`.\n *\n * @see https://radashi.js.org/reference/curry/debounce\n * @example\n * ```ts\n * const myDebouncedFunc = debounce({ delay: 1000 }, (x) => {\n *   console.log(x)\n * })\n *\n * myDebouncedFunc(0) // Nothing happens\n * myDebouncedFunc(1) // Nothing happens\n * // Logs \"1\" about 1 second after the last invocation\n * ```\n * @version 12.1.0\n */\ndeclare function debounce<TArgs extends any[]>({ delay, leading }: DebounceOptions, func: (...args: TArgs) => any): DebounceFunction<TArgs>;\n\n/**\n * Flip the first two arguments of a function.\n *\n * @see https://radashi.js.org/reference/curry/flip\n * @example\n * ```ts\n * const subtract = (x: number, y: number) => x - y\n *\n * // Equivalent to “y - x”\n * const flippedSubtract = flip(subtract)\n *\n * flippedSubtract(3, 4)\n * // => 1\n * ```\n * @version 12.2.0\n */\ndeclare function flip<Args extends any[], Result>(fn: (...args: Args) => Result): (...args: Flip<Args>) => Result;\ntype Flip<T extends any[]> = T extends [infer A, infer B, ...infer R] ? [B, A, ...R] : never;\n\ninterface MemoOptions<TArgs extends any[]> {\n    key?: (...args: TArgs) => string;\n    ttl?: number;\n}\n/**\n * Creates a memoized function. The returned function will only\n * execute the source function when no value has previously been\n * computed. If a ttl (milliseconds) is given previously computed\n * values will be checked for expiration before being returned.\n *\n * @see https://radashi.js.org/reference/curry/memo\n * @example\n * ```ts\n * const calls: number[] = []\n * const fib = memo((x: number) => {\n *   calls.push(x)\n *   return x < 2 ? x : fib(x - 1) + fib(x - 2)\n * })\n *\n * fib(10) // 55\n * fib(10) // 55\n * // calls === [10]\n *\n * fib(11) // 89\n * // calls === [10, 11]\n * ```\n * @version 12.1.0\n */\ndeclare function memo<TArgs extends any[], TResult>(func: (...args: TArgs) => TResult, options?: MemoOptions<NoInfer$1<TArgs>>): (...args: TArgs) => TResult;\n\n/**\n * Creates a memoized version of a function that caches only its most\n * recent call.\n *\n * When the function is called with the same arguments as the previous\n * call, it returns the cached result instead of recalculating. This\n * is useful for optimizing expensive calculations when only the\n * latest result needs to be cached, making it more memory-efficient\n * than traditional memoization.\n *\n * @see https://radashi.js.org/reference/curry/memoLastCall\n * @example\n * ```ts\n * const expensiveCalculation = (x: number, y: number): number => {\n *   console.log('Calculating...');\n *   return x + y;\n * };\n *\n * const memoizedCalc = memoLastCall(expensiveCalculation);\n *\n * console.log(memoizedCalc(2, 3));  // Outputs: \"Calculating...\" then 5\n * console.log(memoizedCalc(2, 3));  // Outputs: 5 (uses cached result)\n * console.log(memoizedCalc(3, 4));  // Outputs: \"Calculating...\" then 7\n * console.log(memoizedCalc(2, 3));  // Outputs: \"Calculating...\" then 5 (previous cache was overwritten)\n * ```\n * @version 12.4.0\n */\ndeclare function memoLastCall<Args extends any[], Result>(fn: (...args: Args) => Result): (...args: Args) => Result;\n\n/**\n * The type of a function wrapped with `once`.\n * @version 12.2.0\n */\ntype OnceFunction<Args extends unknown[] = unknown[], Return = unknown, This = unknown> = (this: This, ...args: Args) => Return;\n/**\n * Create a function that runs at most once, no matter how many times\n * it's called. If it was already called before, returns the result\n * from the first call. This is a lighter version of `memo()`.\n *\n * To allow your `once`-wrapped function to be called again, see the\n * `once.reset` function.\n *\n * @see https://radashi.js.org/reference/curry/once\n * @example\n * ```ts\n * const fn = once(() => Math.random())\n * fn() // 0.5\n * fn() // 0.5\n * ```\n */\ndeclare const once: Once;\ntype Once = {\n    <Args extends unknown[], Return, This = unknown>(fn: (this: This, ...args: Args) => Return): (this: This, ...args: Args) => Return;\n    /**\n     * Reset the result of a function that was created with `once`,\n     * allowing it to be called again.\n     *\n     * ```ts\n     * const fn = once(() => Math.random())\n     * fn() // 0.5\n     * fn() // 0.5\n     * once.reset(fn)\n     * fn() // 0.3\n     * fn() // 0.3\n     * ```\n     */\n    reset(fn: OnceFunction): void;\n};\n\n/**\n * This type produces the type array of `TItems` with all the type items\n * in `TItemsToRemove` removed from the start of the array type.\n *\n * ```ts\n * type T = RemoveItemsInFront<[number, number], [number]>\n * // [number]\n *\n * type T = RemoveItemsInFront<[File, number, string], [File, number]>\n * // [string]\n * ```\n * @version 12.1.0\n */\ntype RemoveItemsInFront<TItems extends any[], TItemsToRemove extends any[]> = TItems extends [...TItemsToRemove, ...infer TRest] ? TRest : TItems;\n/**\n * Create a partial function by providing some (or all) of the\n * arguments the given function needs.\n *\n * @see https://radashi.js.org/reference/curry/partial\n * @example\n * ```ts\n * const add = (a: number, b: number) => a + b\n *\n * const addFive = partial(add, 5)\n *\n * addFive(2) // => 7\n * ```\n */\ndeclare function partial<T extends any[], TA extends Partial<T>, R>(fn: (...args: T) => R, ...args: TA): (...rest: RemoveItemsInFront<T, TA>) => R;\n\n/**\n * Like partial but for unary functions that accept a single object\n * argument\n *\n * @see https://radashi.js.org/reference/curry/partob\n * @example\n * ```ts\n * const add = (\n *   {a = 0, b = 0, c = 0}: {\n *     a?: number,\n *     b?: number,\n *     c?: number\n *   }\n * ) => a + b + c\n *\n * const addPartial = partob(add, { a: 1 })\n * addPartial({ b: 2 }) // 3\n * addPartial({ b: 1, c: 5 }) // 7\n * ```\n * @version 12.1.0\n */\ndeclare function partob<T, K, PartialArgs extends Partial<T>>(fn: (args: T) => K, argObj: PartialArgs): (restObj: Omit<T, keyof PartialArgs>) => K;\n\n/**\n * Creates a function that executes multiple functions in the same\n * order as they are passed in arguments. Each function may be\n * synchronous or asynchronous. The result of each function is passed\n * to the next function. The final result is returned as a `Promise`.\n *\n * @see https://radashi.js.org/reference/curry/promiseChain\n * @example\n * ```ts\n * const chained = promiseChain(\n *   (x: number, y: number) => x + y\n *   async (n: number) => n * 2\n *   async (n: number) => `Your Value is ${n}`\n * )\n *\n * await chained(2, 3) // \"Your Value is 10\"\n * ```\n * @version 12.6.0\n */\ndeclare function promiseChain<T1 extends any[], T2, T3>(f1: (...args: T1) => Awaitable<T2>, f2: (arg: T2) => Awaitable<T3>): (...arg: T1) => Promise<T3>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4>(f1: (...args: T1) => Awaitable<T2>, f2: (arg: T2) => Awaitable<T3>, f3: (arg: T3) => Awaitable<T4>): (...args: T1) => Promise<T4>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>): (...args: T1) => Promise<T5>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5, T6>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>, f5: (args: T5) => Awaitable<T6>): (...args: T1) => Promise<T6>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5, T6, T7>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>, f5: (args: T5) => Awaitable<T6>, f6: (args: T6) => Awaitable<T7>): (...args: T1) => Promise<T7>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>, f5: (args: T5) => Awaitable<T6>, f6: (args: T6) => Awaitable<T7>, f7: (args: T7) => Awaitable<T8>): (...args: T1) => Promise<T8>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>, f5: (args: T5) => Awaitable<T6>, f6: (args: T6) => Awaitable<T7>, f7: (args: T7) => Awaitable<T8>, f8: (args: T8) => Awaitable<T9>): (...args: T1) => Promise<T9>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>, f5: (args: T5) => Awaitable<T6>, f6: (args: T6) => Awaitable<T7>, f7: (args: T7) => Awaitable<T8>, f8: (args: T8) => Awaitable<T9>, f9: (args: T9) => Awaitable<T10>): (...args: T1) => Promise<T10>;\ndeclare function promiseChain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(f1: (...args: T1) => Awaitable<T2>, f2: (args: T2) => Awaitable<T3>, f3: (args: T3) => Awaitable<T4>, f4: (args: T4) => Awaitable<T5>, f5: (args: T5) => Awaitable<T6>, f6: (args: T6) => Awaitable<T7>, f7: (args: T7) => Awaitable<T8>, f8: (args: T8) => Awaitable<T9>, f9: (args: T9) => Awaitable<T10>, f10: (args: T10) => Awaitable<T11>): (...args: T1) => Promise<T11>;\n\n/**\n * Creates a Proxy object that will dynamically call the handler\n * argument when attributes are accessed.\n *\n * @see https://radashi.js.org/reference/curry/proxied\n * @example\n * ```ts\n * const proxy = proxied(propertyName => propertyName.toUpperCase())\n * proxy.foo // => \"FOO\"\n * ```\n * @version 12.1.0\n */\ndeclare function proxied<T, K>(handler: (propertyName: T) => K): Record<string, K>;\n\ntype ThrottledFunction<TArgs extends any[]> = {\n    (...args: TArgs): void;\n    /**\n     * Checks if there is any invocation throttled\n     */\n    isThrottled(): boolean;\n    /**\n     * Call the throttled function immediately, ignoring any throttling\n     * that may be in effect. After, a new throttled call will be allowed\n     * after the interval has passed.\n     *\n     * @example\n     * ```ts\n     * const logMessage = (message: string) => {\n     *   console.log(`Message: ${message}`)\n     * }\n     * const throttledLog = throttle({ interval: 1000 }, logMessage)\n     *\n     * throttledLog('First call')  // Logs immediately\n     * throttledLog('Throttled')   // Doesn't log (throttled)\n     *\n     * // Force a log, bypassing the throttle\n     * throttledLog.trigger('Forced log')  // Logs immediately\n     *\n     * // Check if it's still throttled\n     * throttledLog.isThrottled()  // => true\n     * ```\n     */\n    trigger(...args: TArgs): void;\n};\n/**\n * Given an interval and a function returns a new function that will\n * only call the source function if interval milliseconds have passed\n * since the last invocation.\n *\n * @see https://radashi.js.org/reference/curry/throttle\n * @example\n * ```ts\n * const sup = throttle({ interval: 1000 }, () => {\n *   console.log(\"sup\")\n * })\n * sup() // => logs \"sup\"\n * sup() // => no logs\n * setTimeout(() => sup(), 500) // => no logs\n * setTimeout(() => sup(), 1000) // => logs \"sup\"\n * ```\n * @version 12.1.0\n */\ndeclare function throttle<TArgs extends any[]>({ interval, trailing }: {\n    interval: number;\n    trailing?: boolean;\n}, func: (...args: TArgs) => any): ThrottledFunction<TArgs>;\n\n/**\n * Create a function that always returns the same value.\n *\n * @example\n * ```ts\n * const alwaysTrue = always(true)\n * alwaysTrue() // true\n * alwaysTrue() // true\n * alwaysTrue() // true\n * ```\n * @version 12.2.0\n */\ndeclare function always<T>(value: T): () => T;\n\n/**\n * Cast a value into a comparator function.\n *\n * - **Function**: If `mapping` is a function, it maps the input\n *   values to a comparable value.\n * - **Property Name**: If `mapping` is a property name, it maps the\n *   input values to a property of the input values with a comparable\n *   value.\n *\n * Optionally, you can pass a custom `compare` function that receives\n * the mapped values and returns a number. If not provided, values are\n * compared with the `<` and `>` built-in operators. A positive number\n * means the “right value” is greater than the “left value”, a\n * negative number means the “left value” is greater than the “right\n * value”, and 0 means both values are equal.\n *\n * @see https://radashi.js.org/reference/function/castComparator\n * @example\n * ```ts\n * const compareUserNames = castComparator(\n *   (user) => user.name,\n *   (a, b) => b.localeCompare(a),\n * )\n *\n * const users = [\n *   { name: 'John', age: 20 },\n *   { name: 'Jane', age: 25 },\n *   { name: 'Doe', age: 22 },\n * ]\n *\n * users.sort(compareUserNames)\n * // => [Doe, Jane, John]\n * ```\n * @version 12.2.0\n */\ndeclare function castComparator<TMapping extends keyof any>(mapping: TMapping, compare?: null | undefined, reverse?: boolean): Comparator<MappedInput<TMapping, Comparable>>;\ndeclare function castComparator<T, TMapping extends Mapping<any, T>>(mapping: TMapping, compare: Comparator<T>, reverse?: boolean): Comparator<MappedInput<TMapping, T>>;\ndeclare function castComparator<TInput, TOutput = Comparable>(mapping: (data: TInput) => TOutput, compare?: Comparator<TOutput> | null, reverse?: boolean): Comparator<TInput>;\ndeclare function castComparator<TInput>(mapping: ComparatorMapping<TInput>, compare?: null | undefined, reverse?: boolean): Comparator<TInput>;\ndeclare function castComparator<TMapping extends ComparatorMapping>(mapping: TMapping, compare?: Comparator<MappedOutput<TMapping>> | null, reverse?: boolean): Comparator<MappedInput<TMapping>>;\n/**\n * A value that describes how a comparator maps the input values to a\n * comparable value.\n *\n * @see https://radashi.js.org/reference/function/castComparator\n */\ntype ComparatorMapping<T = any, Compared extends Comparable = Comparable> = Mapping<T, Compared>;\n\n/**\n * Cast the `mapping` value into a mapping function.\n *\n * - If `mapping` is a function, it's returned as is.\n * - If `mapping` is a property name, the mapping uses it to retrieve\n *   the property value from a given object.\n * - If `mapping` is nullish, the mapping is `(input: T) => input`.\n *\n * @see https://radashi.js.org/reference/function/castMapping\n * @example\n * ```ts\n * const getName = castMapping('name')\n * const getFullName = castMapping(person => {\n *   return `${person.firstName} ${person.lastName}`\n * })\n *\n * getName({ name: 'John' }) // => 'John'\n * getFullName({ firstName: 'John', lastName: 'Doe' }) // => 'John Doe'\n * ```\n * @version 12.2.0\n */\ndeclare function castMapping<TMapping extends Mapping | null | undefined>(mapping: TMapping): MappingFunction<TMapping>;\n/**\n * A value that can be casted with `castMapping`.\n *\n * @see https://radashi.js.org/reference/function/castMapping\n */\ntype Mapping<T = any, U = any> = ((arg: T) => U) | CompatibleProperty<T, U>;\n/**\n * A value that can be casted with `castMapping`.\n *\n * @see https://radashi.js.org/reference/function/castMapping\n */\ntype OptionalMapping<T = any, U = any> = Mapping<T, U> | null | undefined;\n/**\n * The input type of a mapping function created with `castMapping`.\n *\n * @see https://radashi.js.org/reference/function/castMapping\n */\ntype MappedInput<TMapping, TPropertyValue = any> = TMapping extends (arg: infer Arg) => any ? [Arg] extends [Any] ? unknown : Arg : TMapping extends keyof any ? {\n    [P in TMapping]: TPropertyValue;\n} | (TMapping extends number ? readonly TPropertyValue[] : never) : unknown;\n/**\n * The return type of a mapping function created with `castMapping`.\n *\n * @see https://radashi.js.org/reference/function/castMapping\n */\ntype MappedOutput<TMapping, TInput = any> = TMapping extends (data: TInput) => infer Result ? [Result] extends [Any] ? unknown : Result : [TInput] extends [Any] ? unknown : TMapping extends null | undefined ? TInput : TMapping extends keyof TInput ? TInput[TMapping] : never;\n/**\n * A mapping function created with `castMapping`.\n *\n * @see https://radashi.js.org/reference/function/castMapping\n */\ntype MappingFunction<TMapping extends Mapping | null | undefined> = <TInput extends MappedInput<TMapping>>(input: TInput) => MappedOutput<TMapping, TInput>;\n\n/**\n * A function that returns the value passed to it.\n *\n * @see https://radashi.js.org/reference/function/identity\n * @example\n * ```ts\n * identity() // => undefined\n * identity(1) // => 1\n * identity(\"a\") // => \"a\"\n * ```\n * @version 12.7.0\n */\ndeclare function identity(): undefined;\ndeclare function identity<T>(value: T): T;\n\n/**\n * A callback that does nothing and returns undefined.\n *\n * @example\n * ```ts\n * noop() // => undefined\n * noop(1) // => undefined\n * noop(1, 2, 3) // => undefined\n * ```\n * @version 12.2.0\n */\ndeclare function noop(): undefined;\n\n/**\n * The `clamp` function restricts a number to be within a specified\n * range.\n *\n * - It takes three arguments: the number to clamp, the minimum value,\n *   and the maximum value.\n * - If the number is less than the minimum, it returns the minimum.\n * - If the number is greater than the maximum, it returns the\n *   maximum.\n * - Otherwise, it returns the number itself.\n *\n * @see https://radashi.js.org/reference/number/clamp\n * @example\n * ```ts\n * clamp(5, 1, 10) // returns 5\n * clamp(0, 1, 10) // returns 1\n * clamp(15, 1, 10) // returns 10\n * ```\n * @version 12.2.0\n */\ndeclare function clamp(n: number, min: number | null | undefined, max: number | null | undefined): number;\n\n/**\n * Checks if the given number is between zero (0) and the ending\n * number. 0 is inclusive.\n *\n * * Numbers can be negative or positive.\n * * Ending number is exclusive.\n *\n * @see https://radashi.js.org/reference/number/inRange\n * @example\n * ```ts\n * inRange(5, 10) // => true\n * inRange(-1, 10) // => false\n * inRange(10, 10) // => false\n * ```\n * @version 12.1.0\n */\ndeclare function inRange(number: number, end: number): boolean;\n/**\n * Checks if the given number is between two numbers.\n *\n * * Numbers can be negative or positive.\n * * Starting number is inclusive.\n * * Ending number is exclusive.\n * * The start and the end of the range can be ascending OR descending\n *   order.\n *\n * @see https://radashi.js.org/reference/number/inRange\n * @example\n * ```ts\n * inRange(5, 0, 10) // => true\n * inRange(-1, 0, 10) // => false\n * inRange(10, 0, 10) // => false\n * ```\n */\ndeclare function inRange(number: number, start: number, end: number): boolean;\n\n/**\n * Linearly interpolates between two numbers.\n *\n * @see https://radashi.js.org/reference/number/lerp\n * @example\n * ```\n * lerp(0, 10, 0.5) // => 5\n * lerp(5, 15, 0.2) // => 7\n * lerp(-10, 10, 0.75) // => 5\n * ```\n * @version 12.2.0\n */\ndeclare function lerp(from: number, to: number, amount: number): number;\n\n/**\n * Max gets the greatest value from a list.\n *\n * @see https://radashi.js.org/reference/array/max\n * @example\n * ```ts\n * max([2, 3, 5]) // => 5\n * max([{ num: 1 }, { num: 2 }], x => x.num) // => { num: 2 }\n * ```\n * @version 12.1.0\n */\ndeclare function max(array: readonly [number, ...number[]]): number;\ndeclare function max(array: readonly number[]): number | null;\ndeclare function max<T>(array: readonly [T, ...T[]], getter: (item: T) => number): T;\ndeclare function max<T>(array: readonly T[], getter: (item: T) => number): T | null;\n\n/**\n * Min gets the smallest value from a list.\n *\n * @see https://radashi.js.org/reference/array/min\n * @example\n * ```ts\n * min([1, 2, 3, 4]) // => 1\n * min([{ num: 1 }, { num: 2 }], x => x.num) // => { num: 1 }\n * ```\n * @version 12.1.0\n */\ndeclare function min(array: readonly [number, ...number[]]): number;\ndeclare function min(array: readonly number[]): number | null;\ndeclare function min<T>(array: readonly [T, ...T[]], getter: (item: T) => number): T;\ndeclare function min<T>(array: readonly T[], getter: (item: T) => number): T | null;\n\n/**\n * Parse a duration string into a number.\n *\n * By default, the following units are supported:\n * - `week`\n * - `day`\n * - `hour`\n * - `minute`\n * - `second`\n * - `millisecond`\n *\n * By default, months and years are not supported, since these aren't\n * likely to be useful in the majority of cases and they introduce\n * ambiguity due to leap years and length differences between months.\n *\n * @see https://radashi.js.org/reference/number/parseDuration\n * @version 12.6.0\n */\ndeclare function parseDuration(duration: DurationString): number;\ndeclare function parseDuration<TUnit extends string = never, TShortUnit extends string = never>(duration: NoInfer<DurationString<TUnit, TShortUnit>>, options: DurationParser.Options<TUnit, TShortUnit>): number;\n\n/**\n * Parse a quantity string into its numeric value. You must provide a\n * unit conversion map.\n *\n * Note that {@link parseDuration `parseDuration`} also exists, which\n * can be used to parse duration strings (like `1d` or `1 day`).\n *\n * @see https://radashi.js.org/reference/number/parseQuantity\n * @version 12.6.0\n */\ndeclare function parseQuantity<TUnit extends string, TShortUnit extends string = never>(quantity: QuantityString<TUnit, TShortUnit>, options: QuantityParser.Options<TUnit, TShortUnit>): number;\n\n/**\n * Creates a generator that will produce an iteration through the\n * range of number as requested.\n *\n * @see https://radashi.js.org/reference/array/range\n * @example\n * ```ts\n * range(3)                  // yields 0, 1, 2, 3\n * range(0, 3)               // yields 0, 1, 2, 3\n * range(0, 3, 'y')          // yields y, y, y, y\n * range(0, 3, () => 'y')    // yields y, y, y, y\n * range(0, 3, i => i)       // yields 0, 1, 2, 3\n * range(0, 3, i => `y${i}`) // yields y0, y1, y2, y3\n * range(0, 3, obj)          // yields obj, obj, obj, obj\n * range(0, 6, i => i, 2)    // yields 0, 2, 4, 6\n * ```\n * @version 12.1.0\n */\ndeclare function range<T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number): Generator<T>;\n\n/**\n * Rounds a number to the given precision. The default `precision` is\n * zero. An optional rounding function (e.g. `Math.floor` or\n * `Math.ceil`) can be provided.\n *\n * The `precision` argument is limited to be within the range of -323\n * to +292. Without this limit, precision values outside this range\n * can result in NaN.\n *\n * @see https://radashi.js.org/reference/number/round\n * @example\n * ```ts\n * round(123.456)\n * // => 123\n *\n * round(1234.56, -2)\n * // => 1200\n *\n * round(1234.56, 1, Math.floor)\n * // => 1234.5\n *\n * round(1234.54, 1, Math.ceil)\n * // => 1234.6\n * ```\n * @version 12.2.0\n */\ndeclare function round(value: number, precision?: number, toInteger?: (value: number) => number): number;\n\n/**\n * Add up numbers related to an array in 1 of 2 ways:\n * 1. Sum all numbers in an array of numbers\n * 2. Sum all numbers returned by a callback function that maps\n *    each item in an array to a number.\n *\n * @see https://radashi.js.org/reference/array/sum\n * @example\n * ```ts\n * sum([1, 2, 3])\n * // => 6\n *\n * sum([\n *   {value: 1},\n *   {value: 2},\n *   {value: 3}\n * ], (item) => item.value)\n * // => 6\n *\n * sum([true, false, true], (item) => item ? 1 : 0)\n * // => 2\n * ```\n * @version 12.1.0\n */\ndeclare function sum(array: readonly number[]): number;\ndeclare function sum<T>(array: readonly T[], fn: (item: T) => number): number;\n\n/**\n * Combines `Number.parseFloat` with NaN handling. By default, a zero\n * (0) is returned in place of NaN.\n *\n * @see https://radashi.js.org/reference/number/toFloat\n * @example\n * ```ts\n * toFloat(\"1.23\") // => 1.23\n * toFloat(\"foo\") // => 0\n * toFloat(\"1.23px\", 1) // => 1.23\n * toFloat(\"foo\", 1) // => 1\n * ```\n * @version 12.1.0\n */\ndeclare function toFloat(value: unknown): number;\ndeclare function toFloat<T>(value: unknown, defaultValue: T | undefined): number | T;\n\n/**\n * Combines `Number.parseInt` with NaN handling. By default, a zero\n * (0) is returned in place of NaN.\n *\n * @see https://radashi.js.org/reference/number/toInt\n * @example\n * ```ts\n * toInt(\"1.23\") // => 1\n * toInt(\"foo\") // => 0\n * toInt(\"1.23px\", 1) // => 1\n * toInt(\"foo\", -1) // => -1\n * ```\n * @version 12.1.0\n */\ndeclare function toInt(value: unknown): number;\ndeclare function toInt<T>(value: unknown, defaultValue: T | undefined): number | T;\n\n/**\n * Create a copy of the first object, and then merge the second object\n * into it recursively. Only plain objects are recursively merged.\n *\n * @see https://radashi.js.org/reference/object/assign\n * @example\n * ```ts\n * const a = { a: 0, b: 2, p: { a: 4 } }\n * const b = { a: 1, c: 3, p: { b: 5 } }\n *\n * assign(a, b)\n * // => { a: 1, b: 2, c: 3, p: { a: 4, b: 5 } }\n * ```\n * @version 12.1.0\n */\ndeclare function assign<TInitial extends Record<keyof any, any>, TOverride extends Record<keyof any, any>>(initial: TInitial, override: TOverride): Assign<TInitial, TOverride>;\n/**\n * The return type for `assign`.\n *\n * It recursively merges object types that are not native objects. The\n * root objects are always merged.\n *\n * @see https://radashi.js.org/reference/object/assign\n */\ntype Assign<TInitial extends object, TOverride extends object> = TInitial extends any ? TOverride extends any ? SimplifyMutable<Omit<TInitial, keyof TOverride> & Omit<TOverride, keyof TInitial> & (Pick<TInitial, keyof TInitial & keyof TOverride> extends infer TConflictInitial ? Pick<TOverride, keyof TInitial & keyof TOverride> extends infer TConflictOverride ? {\n    [K in RequiredKeys<TConflictOverride>]: AssignDeep<TConflictInitial[K & keyof TConflictInitial], TConflictOverride[K]>;\n} & {\n    [K in RequiredKeys<TConflictInitial> & OptionalKeys<TConflictOverride>]: AssignDeep<TConflictInitial[K], TConflictOverride[K], true>;\n} & {\n    [K in OptionalKeys<TConflictInitial> & OptionalKeys<TConflictOverride>]?: AssignDeep<TConflictInitial[K], TConflictOverride[K], true>;\n} : unknown : unknown)> : never : never;\n/**\n * Mimic the `Simplify` type and also remove `readonly` modifiers.\n */\ntype SimplifyMutable<T> = {} & {\n    -readonly [P in keyof T]: T[P];\n};\n/**\n * This represents a value that should only be replaced if it exists\n * as an initial value; never deeply assigned into.\n */\ntype AtomicValue = BuiltInType | CustomClass | BoxedPrimitive;\n/**\n * Handle mixed types when merging nested plain objects.\n *\n * For example, if the type `TOverride` includes both `string` and `{ n:\n * number }` in a union, `AssignDeep` will treat `string` as\n * unmergeable and `{ n: number }` as mergeable.\n */\ntype AssignDeep<TInitial, TOverride, IsOptional = false> = never\n/**\n * When a native type is found in TInitial, it will only exist in\n * the result type if the override is optional.\n */\n | (TInitial extends AtomicValue ? IsOptional extends true ? TInitial : never : never)\n/**\n * When a native type is found in TOverride, it will always exists\n * in the result type.\n */\n | (TOverride extends AtomicValue ? TOverride : never)\n/**\n * Deep assignment is handled in this branch.\n *\n * 1. Exclude any native types from TInitial and TOverride\n * 2. If a non-native object type is not found in TInitial, simply\n *    replace TInitial (or use \"A | B\" if the override is optional)\n * 3. For each non-native object type in TOverride, deep assign to\n *    every non-native object in TInitial\n * 4. For each non-object type in TOverride, simply replace TInitial\n *    (or use \"A | B\" if the override is optional)\n */\n | (Exclude<TOverride, AtomicValue> extends infer TOverride ? Exclude<TInitial, Exclude<AtomicValue, void>> extends infer TInitial ? [Extract<TInitial, object>] extends [never] ? TOverride | (IsOptional extends true ? TInitial : never) : TInitial extends object ? TOverride extends object ? IsExactType<TOverride, TInitial> extends true ? TOverride : Assign<TInitial, TOverride> : // 4.\nTOverride | (IsOptional extends true ? TInitial : never) : Extract<TOverride, object> | (IsOptional extends true ? TInitial : never) : never : never);\n\n/**\n * Creates a shallow copy of the given object/value.\n *\n * @see https://radashi.js.org/reference/object/clone\n * @example\n * ```ts\n * const original = { a: 1, b: { c: 3 } }\n * const cloned = clone(original)\n * // => { a: 1, b: { c: 3 } }\n * original !== cloned\n * // => true\n * original.b === cloned.b\n * // => true\n * ```\n * @version 12.1.0\n */\ndeclare function clone<T>(obj: T): T;\n\n/**\n * A strategy for cloning objects with `cloneDeep`.\n *\n * Methods **must** call the `track` function with the new parent\n * object **before** looping over the input object's\n * properties/elements for cloning purposes. This protects against\n * circular references.\n *\n * Methods may return the input object to indicate that cloning should\n * be skipped.\n *\n * Methods may return null to indicate that the default cloning logic\n * should be used.\n * @version 12.2.0\n */\ninterface CloningStrategy {\n    cloneMap: <K, V>(parent: Map<K, V>, track: (newParent: Map<K, V>) => Map<K, V>, clone: <T>(value: T) => T) => Map<K, V> | null;\n    cloneSet: <T>(parent: Set<T>, track: (newParent: Set<T>) => Set<T>, clone: <T>(value: T) => T) => Set<T> | null;\n    cloneArray: <T>(parent: readonly T[], track: (newParent: T[]) => T[], clone: <T>(value: T) => T) => T[] | null;\n    cloneObject: <T extends object>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;\n    cloneOther: <T>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;\n}\ndeclare const DefaultCloningStrategy: CloningStrategy;\n/**\n * If you don't need support for non-enumerable properties or computed\n * properties, and you're not using custom classes, you can use this\n * strategy for better performance.\n */\ndeclare const FastCloningStrategy: {\n    cloneObject: <T extends object>(input: T, track: (newParent: T) => T, clone: <T_1>(value: T_1) => T_1) => T;\n};\n/**\n * Clone the given object and possibly other objects nested inside.\n *\n * By default, the only objects that get cloned are plain objects,\n * non-native class instances, arrays, `Set` instances, and `Map`\n * instances. If an object is not cloned, any objects nested inside\n * are also not cloned.\n *\n * You may define a custom cloning strategy by passing a partial\n * implementation of the `CloningStrategy` interface to the\n * `cloneDeep` function. Any undefined methods will fall back to the\n * default cloning logic. Your own methods may return null to indicate\n * that the default cloning logic should be used. They may also return\n * the input object to indicate that cloning should be skipped.\n *\n * ```ts\n * const obj = { a: 1, b: { c: 2 } }\n * const clone = cloneDeep(obj)\n *\n * assert(clone !== obj)\n * assert(clone.b !== obj.b)\n * assert(JSON.stringify(clone) === JSON.stringify(obj))\n * ```\n */\ndeclare function cloneDeep<T extends object>(root: T, customStrategy?: Partial<CloningStrategy>): T;\n\n/**\n * The opposite of crush, given an object that was crushed into key\n * paths and values will return the original object reconstructed.\n *\n * @see https://radashi.js.org/reference/object/construct\n * @example\n * ```ts\n * construct({ name: 'ra', 'children.0.name': 'hathor' })\n * // { name: 'ra', children: [{ name: 'hathor' }] }\n * ```\n * @version 12.1.0\n */\ndeclare function construct<TObject extends object>(obj: TObject): object;\n\n/**\n * Flattens a deep object to a single dimension, converting the keys\n * to dot notation.\n *\n * @see https://radashi.js.org/reference/object/crush\n * @example\n * ```ts\n * crush({ name: 'ra', children: [{ name: 'hathor' }] })\n * // { name: 'ra', 'children.0.name': 'hathor' }\n * ```\n * @version 12.1.0\n */\ndeclare function crush<T extends object>(value: T): Crush<T>;\n/**\n * The return type of the `crush` function.\n *\n * This type is limited by TypeScript's development. There's no\n * reliable way to detect if an object will pass `isObject` or not, so\n * we cannot infer the property types of nested objects that have been\n * crushed.\n *\n * @see https://radashi.js.org/reference/object/crush\n */\ntype Crush<T> = T extends readonly (infer U)[] ? Record<string, U extends object ? unknown : U> : Simplify<Intersect<keyof T extends infer Prop ? Prop extends keyof T ? T[Prop] extends infer Value ? ([Extract<Value, object>] extends [never] ? never : Record<string, unknown>) | ([Exclude<Value, object>] extends [never] ? never : [Extract<Value, object>] extends [never] ? {\n    [P in Prop]: Value;\n} : Record<string, unknown>) : never : never : never>>;\n\ntype KeyOf<T extends object> = object extends T ? keyof any : keyof T;\ntype ValueOf<T extends object> = object extends T ? unknown : T[keyof T];\ntype KeyFilterFunction<T extends object = object> = (value: ValueOf<T>, key: KeyOf<T>, obj: T) => boolean;\n/**\n * Functions can use this type to accept either an array of keys or a\n * filter function.\n * @version 12.2.0\n */\ntype KeyFilter<T extends object = object, Key extends keyof any = keyof any> = KeyFilterFunction<T> | readonly Key[];\n/**\n * Extract the keys of an object that pass a filter.\n */\ntype FilteredKeys<T extends object, F extends KeyFilter<T> | null | undefined> = Extract<keyof T, F extends readonly any[] ? F[number] : any>;\n/**\n * Returns true if the key is in the “keys array” or if the “filter\n * function” returns true. This function is useful when creating other\n * functions that need to enumerate an object or array and filter keys\n * in a flexible manner. Using it directly in everyday code is not\n * recommended.\n *\n * @see https://radashi.js.org/reference/object/filterKey\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * filterKey(a, 'a', ['a', 'b'])\n * // => true\n * filterKey(a, 'a', ['a', 'b'])\n * // => true\n * ```\n */\ndeclare function filterKey<T extends object>(obj: T, key: keyof T, filter: KeyFilter<T, keyof T> | null | undefined): boolean;\ndeclare function filterKey(obj: object, key: keyof any, filter: KeyFilter | null | undefined): boolean;\n\n/**\n * Dynamically get a nested value from an array or object with a\n * string.\n *\n * @see https://radashi.js.org/reference/object/get\n * @example\n * ```ts\n * const person = {\n *   name: 'John',\n *   friends: [{ name: 'Jane' }]\n * }\n *\n * get(person, 'friends[0].name')\n * // => 'Jane'\n * ```\n * @version 12.1.0\n */\ndeclare function get<TDefault = unknown>(value: any, path: string, defaultValue?: TDefault): TDefault;\n\n/**\n * Returns a map entry or stores and returns the provided value when missing.\n *\n * @see https://radashi.js.org/reference/object/getOrInsert\n * @example\n * ```ts\n * const counts = new Map<string, number>()\n *\n * getOrInsert(counts, 'clicks', 1)\n * getOrInsert(counts, 'clicks', 5)\n * // => 1\n * ```\n * @version 12.7.0\n */\ndeclare function getOrInsert<K, V>(map: Map<K, V>, key: K, value: V): V;\ndeclare function getOrInsert<K extends object, V>(map: Map<K, V> | WeakMap<K, V>, key: K, value: V): V;\n\n/**\n * Returns a map entry or stores the computed value when the key is missing.\n *\n * @see https://radashi.js.org/reference/object/getOrInsertComputed\n * @example\n * ```ts\n * const counts = new Map<string, number>()\n *\n * getOrInsertComputed(counts, 'clicks', () => 1)\n * getOrInsertComputed(counts, 'clicks', () => 5)\n * // => 1\n * ```\n * @version 12.7.0\n */\ndeclare function getOrInsertComputed<K, V>(map: Map<K, V>, key: K, factory: () => V): V;\ndeclare function getOrInsertComputed<K extends object, V>(map: Map<K, V> | WeakMap<K, V>, key: K, compute: () => V): V;\n\n/**\n * Returns a new object whose keys are the values of the given object\n * and its values are the keys of the given object.\n *\n * @see https://radashi.js.org/reference/object/invert\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * invert(a)\n * // => { 1: 'a', 2: 'b', 3: 'c' }\n * ```\n * @version 12.1.0\n */\ndeclare function invert<TKey extends string | number | symbol, TValue extends string | number | symbol>(obj: Record<TKey, TValue>): Record<TValue, TKey>;\n\n/**\n * Check if a property key is “dangerous” in the sense that it could\n * be used to modify built-in objects, possibly leading to prototype\n * pollution or other unintended side effects.\n *\n * If you pass an object, it will be checked for a `null` prototype,\n * in which case, the key will be considered safe.\n *\n * @see https://radashi.js.org/reference/object/isDangerousKey\n * @version 12.5.1\n */\ndeclare function isDangerousKey(key: PropertyKey, object?: object): boolean;\n\n/**\n * Get a string list of all key names that exist in an object (deep).\n *\n * @see https://radashi.js.org/reference/object/keys\n * @example\n * ```ts\n * keys({ name: 'ra' }) // ['name']\n *\n * keys({ name: 'ra', children: [{ name: 'hathor' }] })\n * // ['name', 'children.0.name']\n * ```\n * @version 12.1.0\n */\ndeclare function keys(value: object): string[];\n\n/**\n * Convert an object to a list, mapping each entry into a list item.\n *\n * @see https://radashi.js.org/reference/object/listify\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * listify(a, (key, value) => ({ key, value }))\n * // => [\n * //   { key: 'a', value: 1 },\n * //   { key: 'b', value: 2 },\n * //   { key: 'c', value: 3 }\n * // ]\n * ```\n * @version 12.1.0\n */\ndeclare function listify<Value, Key extends string | number | symbol, Item>(obj: Record<Key, Value>, toItem: (key: Key, value: Value) => Item): Item[];\n\ntype LowercaseKeys<T extends Record<string, any>> = {\n    [P in keyof T & string as Lowercase<P>]: T[P];\n};\n/**\n * Convert all keys in an object to lower case.\n *\n * @see https://radashi.js.org/reference/object/lowerize\n * @example\n * ```ts\n * const a = { A: 1, B: 2, C: 3 }\n * lowerize(a)\n * // => { a: 1, b: 2, c: 3 }\n * ```\n * @version 12.1.0\n */\ndeclare function lowerize<T extends Record<string, any>>(obj: T): LowercaseKeys<T>;\n\n/**\n * Map over all the keys to create a new object.\n *\n * @see https://radashi.js.org/reference/object/mapEntries\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * mapEntries(a, (key, value) => [value, key])\n * // => { 1: 'a', 2: 'b', 3: 'c' }\n * ```\n * @version 12.1.0\n */\ndeclare function mapEntries<TKey extends string | number | symbol, TValue, TNewKey extends string | number | symbol, TNewValue>(obj: Record<TKey, TValue>, toEntry: (key: TKey, value: TValue) => [TNewKey, TNewValue]): Record<TNewKey, TNewValue>;\n\n/**\n * Map over all the keys of an object to return a new object.\n *\n * @see https://radashi.js.org/reference/object/mapKeys\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * mapKeys(a, (key, value) => key + value)\n * // => { a1: 1, b2: 2, c3: 3 }\n * ```\n * @version 12.1.0\n */\ndeclare function mapKeys<TValue, TKey extends string | number | symbol, TNewKey extends string | number | symbol>(obj: Record<TKey, TValue>, mapFunc: (key: TKey, value: TValue) => TNewKey): Record<TNewKey, TValue>;\n\n/**\n * Map over all the keys to create a new object.\n *\n * @see https://radashi.js.org/reference/object/mapValues\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * mapValues(a, (value, key) => value * 2)\n * // => { a: 2, b: 4, c: 6 }\n * ```\n * @version 12.1.0\n */\ndeclare function mapValues<T extends object, U>(obj: T, mapFunc: (value: Required<T>[keyof T], key: keyof T) => U): {\n    [K in keyof T]: U;\n};\n\n/**\n * Omit a list of properties from an object returning a new object\n * with the properties that remain.\n *\n * @see https://radashi.js.org/reference/object/omit\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * omit(a, ['b'])\n * // => { a: 1, c: 3 }\n * ```\n * @version 12.1.0\n */\ndeclare function omit<T, TKeys extends keyof T>(obj: T, keys: readonly TKeys[]): Omit<T, TKeys>;\n\n/**\n * Pick a list of properties from an object into a new object.\n *\n * ⚠️ When used with a predicate function, `pick` is potentially\n * unsafe, because of partial type matching performed by TypeScript.\n * If you pass an object with more properties than its TypeScript type\n * has listed, the `value` and `key` parameter types of your callback\n * will be inaccurate.\n *\n * @see https://radashi.js.org/reference/object/pick\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n *\n * pick(a, ['a', 'c'])\n * // => { a: 1, c: 3 }\n *\n * pick(a, (value, key) => value > 1)\n * // => { b: 2, c: 3 }\n * ```\n * @version 12.1.0\n */\ndeclare function pick<T extends object, F extends KeyFilter<T, keyof T>>(obj: T, filter: F): Pick<T, FilteredKeys<T, F>>;\n\n/**\n * Opposite of get, dynamically set a nested value into an object\n * using a key path. Does not modify the given initial object.\n *\n * @see https://radashi.js.org/reference/object/set\n * @example\n * ```ts\n * set({}, 'name', 'ra') // => { name: 'ra' }\n * set({}, 'cards[0].value', 2) // => { cards: [{ value: 2 }] }\n * ```\n * @version 12.1.0\n */\ndeclare function set<T extends object, K>(initial: T, path: string, value: K): T;\n\n/**\n * Removes (shakes out) undefined entries from an object. Optional\n * second argument shakes out values by custom evaluation.\n *\n * Note that non-enumerable keys are never shaken out.\n *\n * @see https://radashi.js.org/reference/object/shake\n * @example\n * ```ts\n * const a = { a: 1, b: undefined, c: 3 }\n * shake(a)\n * // => { a: 1, c: 3 }\n * ```\n * @version 12.1.0\n */\ndeclare function shake<T extends object>(obj: T): {\n    [K in keyof T]: Exclude<T[K], undefined>;\n};\ndeclare function shake<T extends object>(obj: T, filter: ((value: unknown) => boolean) | undefined): T;\n\ninterface TraverseOptions<Key = string | number | symbol> {\n    /**\n     * A function that returns the keys of the object to be traversed.\n     *\n     * @default Object.keys\n     */\n    ownKeys?: ((parent: object) => Iterable<Key>) | null;\n    /**\n     * When true, the visitor callback will be invoked for the root object.\n     *\n     * @default false\n     */\n    rootNeedsVisit?: boolean | null;\n}\n/**\n * Recursively visit each property of an object (or each element of an\n * array) and its nested objects or arrays. By default, the only\n * nested objects to be traversed are plain objects and arrays.\n *\n * @see https://radashi.js.org/reference/object/traverse\n * @example\n * ```ts\n * import { traverse } from 'radashi'\n *\n * const root = { a: 1, b: { c: { d: [2] }, e: 3 } }\n *\n * traverse(root, (value, key, parent, context) => {\n *   console.log(key, '=>', value)\n * })\n * // Logs the following:\n * //   a => 1\n * //   b => { … }\n * //   c => { … }\n * //   d => [ 2 ]\n * //   0 => 2\n * //   e => 3\n * ```\n * @version 12.2.0\n */\ndeclare function traverse(root: object, visitor: TraverseVisitor, options?: (TraverseOptions & {\n    rootNeedsVisit?: null;\n}) | null, outerContext?: TraverseContext): boolean;\ndeclare function traverse(root: object, visitor: TraverseVisitor<keyof any | null>, options?: TraverseOptions<keyof any | null> | null, outerContext?: TraverseContext<keyof any | null>): boolean;\n/**\n * The visitor callback for the `traverse` function.\n */\ntype TraverseVisitor<Key = keyof any> = (value: unknown, key: Key, parent: object, context: TraverseContext<Key>, options: TraverseOptions<Key> & {\n    rootNeedsVisit?: null;\n}) => (() => boolean | void) | boolean | void;\n/**\n * The context object for the `traverse` function.\n */\ninterface TraverseContext<Key = keyof any> {\n    /**\n     * The current value being traversed.\n     */\n    readonly value: unknown;\n    /**\n     * The property key or index with which the current value was found.\n     */\n    readonly key: Key;\n    /**\n     * The parent object of the current value.\n     */\n    readonly parent: object;\n    /**\n     * The stack of parent objects. The last object is the current\n     * parent.\n     *\n     * ⚠️ This array must not be mutated directly or referenced outside\n     * the `visitor` callback. If that's necessary, you'll want to clone\n     * it first.\n     */\n    readonly parents: readonly object[];\n    /**\n     * The path to the `parent` object. The last key is the current key.\n     *\n     * ⚠️ This array must not be mutated directly or referenced outside\n     * the `visitor` callback. If that's necessary, you'll want to clone\n     * it first.\n     */\n    readonly path: readonly (keyof any)[];\n    /**\n     * When the current value is a traversable object/iterable, this\n     * function can be used to skip traversing it altogether.\n     *\n     * If the `obj` argument is provided, it marks the given object as\n     * skipped (instead of the current value), preventing it from being\n     * traversed.\n     */\n    readonly skip: (obj?: object) => void;\n    readonly skipped: ReadonlySet<unknown>;\n}\n\ntype UppercaseKeys<T extends Record<string, any>> = {\n    [P in keyof T & string as Uppercase<P>]: T[P];\n};\n/**\n * Convert all keys in an object to upper case.\n *\n * @see https://radashi.js.org/reference/object/upperize\n * @example\n * ```ts\n * const a = { a: 1, b: 2, c: 3 }\n * upperize(a)\n * // => { A: 1, B: 2, C: 3 }\n * ```\n * @version 12.1.0\n */\ndeclare function upperize<T extends Record<string, any>>(obj: T): UppercaseKeys<T>;\n\ninterface AggregateError extends Error {\n    errors: any[];\n}\ninterface AggregateErrorConstructor {\n    new (errors: Iterable<any>, message?: string): AggregateError;\n    (errors: Iterable<any>, message?: string): AggregateError;\n    readonly prototype: AggregateError;\n}\n/**\n * The `AggregateError` object represents an error when several errors\n * need to be wrapped in a single error.\n *\n * As this error type is relatively new, it's not available in every\n * environment supported by Radashi (last checked on July 20, 2024).\n * When it's not globally defined, Radashi provides a polyfill.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n * @version 12.2.0\n */\ndeclare const AggregateErrorOrPolyfill: AggregateErrorConstructor;\n\n/**\n * A human-readable quantity string.\n */\ntype QuantityString<Unit extends string, ShortUnit extends string = never> = `1 ${Unit}` | `${number} ${Unit}s` | `${number}${ShortUnit}`;\n/**\n * Parses a quantity string into its numeric value.\n *\n * You can use `parseQuantity` instead for a light wrapper that\n * doesn't require the `new` keyword.\n *\n * See {@link parseQuantity `parseQuantity`} for more information.\n *\n * @version 12.6.0\n */\ndeclare class QuantityParser<Unit extends string, ShortUnit extends string = never> {\n    private units;\n    private short?;\n    constructor({ units, short }: QuantityParser.Options<Unit, ShortUnit>);\n    /**\n     * Parse a quantity string into its numeric value\n     *\n     * @throws {Error} If the quantity string is invalid or contains an unknown unit\n     */\n    parse(quantity: QuantityString<Unit, ShortUnit>): number;\n}\ndeclare namespace QuantityParser {\n    /**\n     * The options for a `QuantityParser` instance.\n     */\n    type Options<Unit extends string, ShortUnit extends string = never> = {\n        units: Record<Unit, number>;\n        short?: Record<ShortUnit, Unit>;\n    };\n    /**\n     * Convert a `QuantityParser` instance to a human-readable quantity string.\n     */\n    type ToString<T extends QuantityParser<string, string>> = T extends QuantityParser<infer Unit, infer ShortUnit> ? QuantityString<Unit, ShortUnit> : never;\n}\n\n/**\n * The default duration units supported by `DurationParser`.\n */\ntype DurationUnit = keyof typeof DurationParser.units;\n/**\n * The default aliases for `DurationUnit`.\n */\ntype DurationShortUnit = keyof typeof DurationParser.shortUnits;\n/**\n * A human-readable duration string.\n */\ntype DurationString<TUnit extends string = never, TShortUnit extends string = never> = QuantityString<DurationUnit | TUnit, DurationShortUnit | TShortUnit>;\ndeclare const DURATION_UNITS: {\n    readonly week: 604800000;\n    readonly day: 86400000;\n    readonly hour: 3600000;\n    readonly minute: 60000;\n    readonly second: 1000;\n    readonly millisecond: 1;\n};\ndeclare const DURATION_SHORT_UNITS: {\n    readonly w: \"week\";\n    readonly d: \"day\";\n    readonly h: \"hour\";\n    readonly m: \"minute\";\n    readonly s: \"second\";\n    readonly ms: \"millisecond\";\n};\n/**\n * Parses a duration string into its numeric value.\n *\n * You can use `parseDuration` instead for a light wrapper that\n * doesn't require the `new` keyword.\n *\n * See {@link parseDuration `parseDuration`} for more information.\n *\n * @version 12.6.0\n */\ndeclare class DurationParser<TUnit extends string = never, TShortUnit extends string = never> extends QuantityParser<DurationUnit | TUnit, DurationShortUnit | TShortUnit> {\n    constructor(options?: DurationParser.Options<TUnit, TShortUnit>);\n    static get units(): typeof DURATION_UNITS;\n    static get shortUnits(): typeof DURATION_SHORT_UNITS;\n}\ndeclare namespace DurationParser {\n    /**\n     * The options for a `DurationParser` instance.\n     */\n    type Options<TUnit extends string, TShortUnit extends string> = {\n        units?: Record<TUnit, number>;\n        short?: Record<TShortUnit, TUnit | DurationUnit>;\n    };\n}\n\ninterface AbortSignal {\n    reason?: unknown;\n    addEventListener(type: 'abort', listener: () => void): void;\n    removeEventListener(type: 'abort', listener: () => void): void;\n}\n/**\n * A permit that can be acquired from a {@link Semaphore}.\n */\ndeclare class SemaphorePermit {\n    readonly semaphore: Semaphore;\n    readonly request: PromiseWithResolvers<void>;\n    readonly weight: number;\n    constructor(semaphore: Semaphore, request: PromiseWithResolvers<void>, weight: number);\n    /**\n     * Releases this permit back to the semaphore, allowing another\n     * operation to acquire it.\n     */\n    release(): void;\n}\n/**\n * Options for acquiring a permit from a semaphore.\n */\ntype SemaphoreAcquireOptions = {\n    signal?: AbortSignal;\n    weight?: number;\n};\n/**\n * Implements a counting semaphore that controls access to a limited\n * resource. Useful for limiting concurrent operations or access to\n * constrained resources.\n *\n * @see https://radashi.js.org/reference/oop/Semaphore\n * @version 12.6.0\n */\ndeclare class Semaphore {\n    readonly maxCapacity: number;\n    protected queue: SemaphorePermit[];\n    /**\n     * Current number of permits available to be acquired\n     */\n    readonly capacity: number;\n    /**\n     * Number of pending acquisition requests.\n     */\n    get queueLength(): number;\n    /**\n     * Creates a new semaphore with the specified capacity.\n     * @param maxCapacity Maximum number of permits that can be issued simultaneously\n     */\n    constructor(maxCapacity: number);\n    /**\n     * Acquires a permit from this semaphore, waiting if necessary until\n     * one becomes available.\n     * @param options.signal - The signal to abort the acquisition\n     * @param options.weight - The weight of the permit to acquire\n     * @returns A promise that resolves to a permit when one is\n     * available\n     */\n    acquire({ signal, weight, }?: SemaphoreAcquireOptions): Promise<SemaphorePermit>;\n    /**\n     * Rejects all pending acquisition requests.\n     */\n    reject(error: Error): void;\n    /**\n     * Releases a permit back to the semaphore, increasing capacity and\n     * potentially fulfilling a pending acquisition request.\n     */\n    protected release(permit: SemaphorePermit): void;\n}\n\ndeclare class TimeoutError extends Error {\n    name: string;\n    constructor(message?: string);\n}\n\n/**\n * Returns a value randomly jittered by an absolute offset.\n *\n * @see https://radashi.js.org/reference/random/absoluteJitter\n * @example\n * ```ts\n * const result = absoluteJitter(100, 5)\n * result >= 95 && result <= 105\n * // => true\n * ```\n * @version 12.7.0\n */\ndeclare function absoluteJitter(base: number, offset: number): number;\n\n/**\n * “Draw” a random item from an array. The item is not removed from\n * the array. Returns `null` if the array is empty.\n *\n * @see https://radashi.js.org/reference/random/draw\n * @example\n * ```ts\n * const numbers = [1, 2, 3]\n *\n * draw(numbers)\n * // => 2\n * numbers\n * // => [1, 2, 3]\n * ```\n * @version 12.1.0\n */\ndeclare function draw<const T extends readonly any[]>(array: T): T extends readonly [any, ...any[]] ? T[number] : T[number] | null;\n\n/**\n * Returns a value randomly jittered by a proportion of the base value.\n *\n * @see https://radashi.js.org/reference/random/proportionalJitter\n * @example\n * ```ts\n * const result = proportionalJitter(100, 0.25)\n * result >= 75 && result <= 125\n * // => true\n * ```\n * @version 12.7.0\n */\ndeclare function proportionalJitter(base: number, factor: number): number;\n\n/**\n * Generates a random integer between min and max. Both min and max\n * are inclusive.\n *\n * @see https://radashi.js.org/reference/random/random\n * @example\n * ```ts\n * random(1, 10)\n * // => 5\n * ```\n * @version 12.1.0\n */\ndeclare function random(min: number, max: number): number;\n\n/**\n * Create a new array with the items of the given array but in a random order.\n * The randomization is done using the [Fisher-Yates algorithm](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle),\n * which is mathematically proven to be unbiased (i.e. all permutations are equally likely).\n *\n * @see https://radashi.js.org/reference/random/shuffle\n * @example\n * ```ts\n * const numbers = [1, 2, 3, 4, 5]\n * const shuffled = shuffle(numbers)\n * // => [2, 1, 4, 5, 3]\n * shuffled !== numbers\n * // => true\n * ```\n * @version 12.1.0\n */\ndeclare function shuffle<T>(\n/**\n * The array to shuffle.\n */\narray: readonly T[], \n/**\n * You can provide a custom random function to make the shuffle more or less\n * random. The custom random function takes minimum and maximum values and\n * returns a random number between them.\n *\n * @default _.random\n * @example\n *\n * ```ts\n * const array = [1, 2, 3, 4, 5]\n * const customRandom = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min\n * _.shuffle(array, customRandom)\n * ```\n */\nrandom?: (min: number, max: number) => number): T[];\n\n/**\n * Generate a random string of a given length.\n *\n * @see https://radashi.js.org/reference/random/uid\n * @example\n * ```ts\n * uid(8)\n * // => \"a3fSDf32\"\n * ```\n * @version 12.1.0\n */\ndeclare function uid(length: number, specials?: string): string;\n\ninterface Series<T> {\n    min: (a: T, b: T) => T;\n    max: (a: T, b: T) => T;\n    first: () => T;\n    last: () => T;\n    next: (current: T, defaultValue?: T) => T;\n    previous: (current: T, defaultValue?: T) => T;\n    spin: (current: T, num: number) => T;\n}\n/**\n * Creates a series object around a list of values that should be\n * treated with order.\n *\n * @see https://radashi.js.org/reference/series/series\n * @example\n * ```ts\n * const numbers = series([1, 2, 3])\n *\n * numbers.first() // => 1\n * numbers.last() // => 3\n * numbers.next(2) // => 3\n * numbers.previous(2) // => 1\n * numbers.spin(2, 1) // => 3\n * numbers.spin(2, -1) // => 1\n * ```\n * @version 12.1.0\n */\ndeclare const series: <T>(items: readonly T[], toKey?: (item: T) => string | symbol) => Series<T>;\n\n/**\n * Formats the given string in camel case fashion.\n *\n * @see https://radashi.js.org/reference/string/camel\n * @example\n * ```ts\n * camel('hello world') // => 'helloWorld'\n * camel('one two-THREE') // => 'oneTwoThree'\n * camel('helloWorld') // => 'helloWorld'\n * ```\n * @version 12.1.0\n */\ndeclare function camel(str: string): string;\n\n/**\n * Capitalize the first word of the string.\n *\n * @see https://radashi.js.org/reference/string/capitalize\n * @example\n * ```ts\n * capitalize('hello') // => 'Hello'\n * capitalize('one two three') // => 'One two three'\n * ```\n * @version 12.1.0\n */\ndeclare function capitalize(str: string): string;\n\n/**\n * Formats the given string in dash case fashion.\n *\n * @see https://radashi.js.org/reference/string/dash\n * @example\n * ```ts\n * dash('hello world') // => 'hello-world'\n * dash('one two_THREE') // => 'one-two-three'\n * dash('helloWord') // => 'hello-word'\n * ```\n * @version 12.1.0\n */\ndeclare function dash(str: string): string;\n\n/**\n * Remove indentation from a string. The given string is expected to\n * be consistently indented (i.e. the leading whitespace of the first\n * non-empty line is the minimum required for all non-empty lines).\n *\n * If the `indent` argument is nullish, the indentation is detected\n * from the first non-empty line. Detection is cheap and robust for\n * most use cases, so you should only set an explicit `indent` if\n * necessary.\n *\n * @see https://radashi.js.org/reference/string/dedent\n * @example\n * ```ts\n * // This is indented with 4 spaces.\n * const input = `\n *     Hello\n *     World\n * `\n *\n * // Explicit indentation\n * dedent(input, '  ')\n * // => '  Hello\\n  World\\n'\n *\n * // Detected indentation\n * dedent(input)\n * // => 'Hello\\nWorld\\n'\n *\n * // Tagged template strings\n * const str = dedent`\n *   Foo ${1 + 1}\n *   Bar ${2 * 2}\n * `\n * // => 'Foo 2\\nBar 4'\n * ```\n * @version 12.3.0\n */\ndeclare function dedent(template: TemplateStringsArray, ...values: unknown[]): string;\ndeclare function dedent(text: string, indent?: string | null): string;\n\n/**\n * Escape HTML characters in a string.\n *\n * @see https://radashi.js.org/reference/string/escapeHTML\n * @example\n * ```ts\n * escapeHTML('<div>Hello, world!</div>')\n * // => '&lt;div&gt;Hello, world!&lt;/div&gt;'\n * ```\n * @version 12.6.0\n */\ndeclare function escapeHTML(input: string): string;\n\n/**\n * Formats the given string in pascal case fashion.\n *\n * @see https://radashi.js.org/reference/string/pascal\n * @example\n * ```ts\n * pascal('hello world') // => 'HelloWorld'\n * pascal('va va boom') // => 'VaVaBoom'\n * pascal('helloWorld') // => 'HelloWorld'\n * ```\n * @version 12.1.0\n */\ndeclare function pascal(str: string): string;\n\n/**\n * Calculate the similarity between two strings using the Levenshtein\n * distance algorithm.\n *\n * One thing to note is that the argument order is unimportant. The\n * algorithm will always return the same result regardless of the\n * order of the arguments.\n *\n * Adapted from\n * [@fabiospampinato/tiny-levenshtein](https://github.com/fabiospampinato/tiny-levenshtein)\n * with ❤️.\n *\n * @see https://radashi.js.org/reference/string/similarity\n * @example\n * ```ts\n * similarity('abc', 'abc') // 0\n * similarity('a', 'b') // 1\n * similarity('ab', 'ac') // 1\n * similarity('ac', 'bc') // 1\n * similarity('abc', 'axc') // 1\n * similarity('kitten', 'sitting') // 3\n * ```\n * @version 12.2.0\n */\ndeclare function similarity(str1: string, str2: string): number;\n\n/**\n * Formats the given string in snake case fashion.\n *\n * @see https://radashi.js.org/reference/string/snake\n * @example\n * ```ts\n * snake('hello world') // => 'hello_world'\n * snake('one two-THREE') // => 'one_two_three'\n * snake('helloWorld') // => 'hello_world'\n * ```\n * @version 12.1.0\n */\ndeclare function snake(str: string, options?: {\n    splitOnNumber?: boolean;\n}): string;\n\n/**\n * Replace data by name in template strings. The default expression\n * looks for `{{name}}` to identify names.\n *\n * @see https://radashi.js.org/reference/string/template\n * @example\n * ```ts\n * template('Hello, {{name}}', { name: 'Radashi' })\n * // \"Hello, Radashi\"\n *\n * template('Hello, <name>', { name: 'Radashi' }, /<(.+?)>/g)\n * // \"Hello, Radashi\"\n * ```\n * @version 12.1.0\n */\ndeclare function template(str: string, data: Record<string, any>, regex?: RegExp): string;\n\n/**\n * Formats the given string in title case fashion.\n *\n * @see https://radashi.js.org/reference/string/title\n * @example\n * ```ts\n * title('hello world') // => 'Hello World'\n * title('va_va_boom') // => 'Va Va Boom'\n * title('root-hook') // => 'Root Hook'\n * title('queryItems') // => 'Query Items'\n * ```\n * @version 12.1.0\n */\ndeclare function title(str: string | null | undefined): string;\n\n/**\n * Trims all prefix and suffix characters from the given string. Like\n * the builtin trim function but accepts other characters you would\n * like to trim and trims multiple characters.\n *\n * @see https://radashi.js.org/reference/string/trim\n * @example\n * ```ts\n * trim('  hello ') // => 'hello'\n * trim('__hello__', '_') // => 'hello'\n * trim('/repos/:owner/:repo/', '/') // => 'repos/:owner/:repo'\n * trim('222222__hello__1111111', '12_') // => 'hello'\n * ```\n * @version 12.1.0\n */\ndeclare function trim(str: string | null | undefined, charsToTrim?: string): string;\n\n/**\n * Asserts that a condition is true. If the condition is false, an\n * error is thrown. This function uses TypeScript's `asserts` keyword\n * to narrow the type of the value being asserted.\n *\n * @see https://radashi.js.org/reference/typed/assert\n * @example\n * ```ts\n * function processValue(value: string | null) {\n *   assert(value, 'Value cannot be null or an empty string')\n *   // value is now narrowed to string\n *   console.log(value.toUpperCase())\n * }\n *\n * processValue('hello') // logs \"HELLO\"\n * processValue(null) // throws Error: Value cannot be null or an empty string\n * processValue('') // throws Error: Value cannot be null or an empty string\n * ```\n * @example\n * ```ts\n * // Example with false literal, return type is never\n * const result =\n *   status === 'success'\n *     ? 1\n *     : status === 'pending'\n *       ? 2\n *       : assert(false, 'Unexpected status')\n *\n * typeof result\n * //     ^? 1 | 2\n * ```\n * @version 12.6.0\n */\ndeclare function assert(condition: false, error?: string | Error): never;\ndeclare function assert(condition: unknown, error?: string | Error): asserts condition;\n\n/**\n * Literally just `Array.isArray` but with better type inference.\n *\n * @see https://radashi.js.org/reference/typed/isArray\n * @example\n * ```ts\n * isArray([]) // => true\n * isArray('hello') // => false\n * ```\n * @version 12.1.0\n */\ndeclare const isArray: <Input>(value: Input) => value is ExtractArray<Input>;\n/**\n * An absurdly complicated but accurate type for extracting Array types.\n *\n * It's like `Extract<T, any[]>` but better with edge cases.\n */\ntype ExtractArray<T> = T extends any ? [StrictExtract<T, readonly any[]>] extends [readonly any[]] ? Extract<T, readonly any[]> : [StrictExtract<T, any[]>] extends [any[]] ? Extract<T, any[]> : unknown[] extends T ? unknown[] : never : never;\n\ntype AsyncIterable = globalThis.AsyncIterable<unknown>;\n/**\n * Checks if a value is an async iterable.\n *\n * @see https://radashi.js.org/reference/typed/isAsyncIterable\n * @example\n * ```ts\n * isAsyncIterable((async function* () { yield 1 })())\n * // => true\n *\n * isAsyncIterable([1, 2, 3])\n * // => false\n * ```\n * @version 12.4.0\n */\ndeclare function isAsyncIterable(value: unknown): value is AsyncIterable;\n\n/**\n * Return true if the give value is a BigInt.\n *\n * @see https://radashi.js.org/reference/typed/isBigInt\n * @example\n * ```ts\n * _.isBigInt(0n) // => true\n * _.isBigInt(BigInt(0)) // => true\n * _.isBigInt(12) // => false\n * _.isBigInt('0n') // => false\n * ```\n * @version 12.4.0\n */\ndeclare function isBigInt(value: unknown): value is bigint;\n\ndeclare function isBoolean(value: unknown): value is boolean;\n\n/**\n * Checks if the given value is a class. This function verifies\n * if the value was defined using the `class` syntax. Old school\n * classes (defined with constructor functions) will return false.\n * \"Native classes\" like `Error` will also return false.\n *\n * @see https://radashi.js.org/reference/typed/isClass\n * @example\n * ```ts\n * isClass(class CustomClass {}) // => true\n * isClass('abc') // => false\n * isClass({}) // => false\n * ```\n * @version 12.3.0\n */\ndeclare function isClass<T>(value: T): value is ExtractClass<T>;\n/**\n * Used by the `isClass` type guard. It handles type narrowing for\n * class constructors and even narrows `any` types.\n */\ntype ExtractClass<T> = [StrictExtract<T, Class>] extends [Class] ? Extract<T, Class> : T extends any ? Class<unknown[], unknown> extends T ? Class<unknown[], unknown> : never : never;\n\n/**\n * Return true if the given value is a Date object.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isDate\n * @example\n * ```ts\n * isDate(new Date()) // => true\n * isDate('hello') // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isDate(value: unknown): value is Date;\n\n/**\n * Return true if the given value is empty.\n * This function also uses [Type Guards](https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards) to ensure type safety\n *\n * Empty values include:\n * - `null`\n * - `undefined`\n * - `0`\n * - `0n` or `BigInt(0)`\n * - any boolean\n * - empty string\n * - empty array\n * - invalid `Date` time\n * - object with `length` property of `0`\n * - object with `size` property of `0`\n * - object with no enumerable keys\n *\n * @see https://radashi.js.org/reference/typed/isEmpty\n * @example\n * ```ts\n * isEmpty(0) // => true\n * isEmpty(null) // => true\n * isEmpty(undefined) // => true\n * isEmpty([]) // => true\n * isEmpty({}) // => true\n * ```\n * @version 12.1.0\n */\ndeclare function isEmpty<T extends ToEmptyAble>(value: T): value is ToEmpty<T>;\ndeclare function isEmpty(value: unknown): boolean;\ntype NeverEmpty = symbol | Function;\n/**\n * A type that can be narrowed by `isEmpty`.\n */\ntype ToEmptyAble = NeverEmpty | boolean | number | string | readonly any[] | null | undefined;\n/**\n * Narrow a type to an empty value.\n *\n * Due to TypeScript limitations, object types cannot be narrowed,\n * except for arrays and functions.\n */\ntype ToEmpty<T extends ToEmptyAble> = (T extends any[] ? never[] : Extract<false | 0 | '' | readonly never[] | null | undefined, T>) extends infer U ? Extract<U, T> : never;\n\n/**\n * Return true if the given values are equal.\n *\n * To determine equality, `Object.is()` is used first. If it returns\n * false, we do the following special checks:\n * - `Date` and `Date` with the same time\n * - `RegExp` and `RegExp` with the same pattern/flags\n * - object with the same keys and values (recursive)\n *\n * @see https://radashi.js.org/reference/typed/isEqual\n * @example\n * ```ts\n * isEqual(0, 0) // => true\n * isEqual(0, 1) // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isEqual<TType>(x: TType, y: TType): boolean;\n\n/**\n * Return true if the given value is an Error object.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isError\n * @example\n * ```ts\n * isError(new Error()) // => true\n * isError('hello') // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isError(value: unknown): value is Error;\n\n/**\n * Return true if the given value is a number that is not an integer.\n *\n * @see https://radashi.js.org/reference/typed/isFloat\n * @example\n * ```ts\n * isFloat(0) // => false\n * isFloat(0.1) // => true\n * ```\n * @version 12.1.0\n */\ndeclare function isFloat(value: any): value is number;\n\n/**\n * Return true if the given value is a function.\n *\n * @see https://radashi.js.org/reference/typed/isFunction\n * @example\n * ```ts\n * isFunction(0) // => false\n * isFunction(() => {}) // => true\n * isFunction(function() {}) // => true\n * isFunction(async function() {}) // => true\n * isFunction(class {}) // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isFunction(value: any): value is Function;\n\n/**\n * Literally just `Number.isInteger` with a better type.\n *\n * @see https://radashi.js.org/reference/typed/isInt\n * @example\n * ```ts\n * isInt(0) // => true\n * isInt(0.1) // => false\n * ```\n * @version 12.1.0\n */\ndeclare const isInt: (value: unknown) => value is number;\n\n/**\n * Return true if the given value is a string that can be parsed as an\n * integer.\n *\n * @see https://radashi.js.org/reference/typed/isIntString\n * @example\n * ```ts\n * isIntString('0') // => true\n * isIntString('0.1') // => false\n * isIntString('+1') // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isIntString(value: any): value is `${number}`;\n\ndeclare function isIterable(value: unknown): value is Iterable<unknown>;\n\n/**\n * Return true if the given value is a Map.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isMap\n * @example\n * ```ts\n * isMap(new Map()) // => true\n * isMap(new Set()) // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isMap<Input>(value: Input): value is ExtractMap<Input>;\n/**\n * An absurdly complicated but accurate type for extracting Map types.\n *\n * It's like `Extract<T, Map<any, any>>` but better with edge cases.\n */\ntype ExtractMap<T> = T extends any ? [StrictExtract<T, ReadonlyMap<unknown, unknown>>] extends [\n    ReadonlyMap<unknown, unknown>\n] ? Extract<T, ReadonlyMap<unknown, unknown>> : [StrictExtract<T, Map<unknown, unknown>>] extends [Map<unknown, unknown>] ? Extract<T, Map<unknown, unknown>> : Map<unknown, unknown> extends T ? Map<unknown, unknown> : never : never;\n\n/**\n * Check if two maps are equal. Items are checked for deep equality\n * using the `isEqual` function.\n *\n * @see https://radashi.js.org/reference/typed/isMapEqual\n * @version 12.7.0\n */\ndeclare function isMapEqual(x: Map<any, any>, y: Map<any, any>): boolean;\n\n/**\n * Return true if the given value is null or undefined.\n *\n * @see https://radashi.js.org/reference/typed/isNullish\n * @example\n * ```ts\n * isNullish(null) // => true\n * isNullish(undefined) // => true\n * isNullish('') // => false\n * isNullish(0) // => false\n * ```\n * @version 12.3.0\n */\ndeclare function isNullish(value: unknown): value is null | undefined;\n\n/**\n * Return true if the given value is a number.\n *\n * @see https://radashi.js.org/reference/typed/isNumber\n * @example\n * ```ts\n * isNumber(0) // => true\n * isNumber('0') // => false\n * isNumber(NaN) // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isNumber(value: unknown): value is number;\n\n/**\n * Returns true if `value` is a plain object, a class instance\n * (excluding built-in classes like Date/RegExp), or an\n * `Object.create(null)` result. Objects from [other realms][1] are\n * also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isObject\n * @example\n * ```ts\n * isObject({}) // true\n * isObject(new Object()) // true\n * isObject(Object.create(null)) // true\n * isObject(new class {}) // true\n *\n * isObject([]) // false\n * isObject(/.+/g) // false\n * isObject(new Date()) // false\n * isObject(new Map()) // false\n * isObject(new Set()) // false\n * ```\n * @version 12.1.0\n */\ndeclare function isObject(value: unknown): value is object;\n\n/**\n * Return true if the given value is a plain object.\n *\n * @see https://radashi.js.org/reference/typed/isPlainObject\n * @example\n * ```ts\n * isPlainObject({}) // => true\n * isPlainObject(new Map()) // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isPlainObject(value: any): value is object;\n\n/**\n * Checks if the given value is primitive.\n *\n * Primitive types include:\n * - number\n * - string\n * - boolean\n * - symbol\n * - bigint\n * - undefined\n * - null\n *\n * @see https://radashi.js.org/reference/typed/isPrimitive\n * @example\n * ```ts\n * isPrimitive(0) // => true\n * isPrimitive(null) // => true\n * isPrimitive(undefined) // => true\n * isPrimitive('0') // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isPrimitive(value: any): boolean;\n\n/**\n * Returns true if the value is a Promise or has a `then` method.\n *\n * @see https://radashi.js.org/reference/typed/isPromise\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // => true\n * isPromise({ then() {} }) // => true\n * isPromise(1) // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isPromise(value: any): value is PromiseLike<unknown>;\n\n/**\n * Checks if the given value is a RegExp.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isRegExp\n * @example\n * ```ts\n * isRegExp(/abc/) // => true\n * isRegExp('abc') // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isRegExp(value: unknown): value is RegExp;\n\n/**\n * Returns true if the value is a `Result` tuple.\n *\n * @see https://radashi.js.org/reference/typed/isResult\n * @example\n * ```ts\n * isResult([undefined, 42]) => true\n * isResult([new Error(), undefined]) => true\n *\n * // Tuple must be of length 2.\n * isResult([new Error()]) => false\n * isResult([undefined, true, undefined]) => false\n *\n * // Non-tuple values are false.\n * isResult([]) => false\n * isResult({}) => false\n * isResult(null) => false\n *\n * // Result tuples cannot have both a value and an error.\n * isResult([new Error(), true]) => false\n * ```\n * @version 12.2.0\n */\ndeclare function isResult(value: unknown): value is Result<unknown>;\n\n/**\n * Returns true if the value is an `Err` result.\n *\n * @see https://radashi.js.org/reference/typed/isResultErr\n * @example\n * ```ts\n * isResultErr([new Error(), undefined]) // true\n * isResultErr([undefined, \"hello\"]) // false\n * ```\n * @version 12.2.0\n */\ndeclare function isResultErr<TError extends Error = Error>(value: unknown): value is Err<TError>;\n\n/**\n * Returns true if the value is an `Ok` result.\n *\n * @see https://radashi.js.org/reference/typed/isResultOk\n * @example\n * ```ts\n * isResultOk([undefined, \"hello\"]) // true\n * isResultOk([new Error(), undefined]) // false\n * ```\n * @version 12.2.0\n */\ndeclare function isResultOk<TValue = unknown>(value: unknown): value is Ok<TValue>;\n\n/**\n * Checks if the given value is a Set.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isSet\n * @example\n * ```ts\n * isSet(new Set([1, 2, 3])) // => true\n * isSet(new Map([1, 2, 3])) // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isSet<Input>(value: Input): value is ExtractSet<Input>;\n/**\n * An absurdly complicated but accurate type for extracting Set types.\n *\n * It's like `Extract<T, Set<any>>` but better with edge cases.\n */\ntype ExtractSet<T> = T extends any ? [StrictExtract<T, ReadonlySet<unknown>>] extends [ReadonlySet<unknown>] ? Extract<T, ReadonlySet<unknown>> : [StrictExtract<T, Set<unknown>>] extends [Set<unknown>] ? Extract<T, Set<unknown>> : Set<unknown> extends T ? Set<unknown> : never : never;\n\n/**\n * Check if two sets are equal.\n *\n * Note: This does NOT check for deep equality of the items.\n *\n * @see https://radashi.js.org/reference/typed/isSetEqual\n * @version 12.7.0\n */\ndeclare function isSetEqual(x: Set<any>, y: Set<any>): boolean;\n\n/**\n * Checks if the given value is a string.\n *\n * @see https://radashi.js.org/reference/typed/isString\n * @example\n * ```ts\n * isString('abc') // => true\n * isString(123) // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isString(value: unknown): value is string;\n\n/**\n * Checks if the given value is a symbol.\n *\n * @see https://radashi.js.org/reference/typed/isSymbol\n * @example\n * ```ts\n * isSymbol(Symbol('abc')) // => true\n * isSymbol('abc') // => false\n * ```\n * @version 12.1.0\n */\ndeclare function isSymbol(value: unknown): value is symbol;\n\n/**\n * Compare the given tag to the result of `Object.prototype.toString`.\n *\n * ⚠️ You probably won't use this except when implementing another type guard.\n *\n * @internal\n * @example\n * ```ts\n * isTagged('foo', '[object String]') // true\n * ```\n * @version 12.2.0\n */\ndeclare function isTagged(value: unknown, tag: string): boolean;\n\n/**\n * Checks if the given value is undefined.\n *\n * @see https://radashi.js.org/reference/typed/isUndefined\n * @example\n * ```ts\n * isUndefined(undefined) // => true\n * isUndefined(null) // => false\n * ```\n * @version 12.3.0\n */\ndeclare function isUndefined(value: unknown): value is undefined;\n\n/**\n * Checks if the given value is a WeakMap.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isWeakMap\n * @example\n * ```ts\n * isWeakMap(new WeakMap()) // => true\n * isWeakMap(new Map()) // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isWeakMap<K extends WeakKey = WeakKey, V = unknown>(value: unknown): value is WeakMap<K, V>;\n\n/**\n * Checks if the given value is a WeakSet.\n *\n * Instances from [other realms][1] are also supported.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms\n *\n * @see https://radashi.js.org/reference/typed/isWeakSet\n * @example\n *\n * ```ts\n * isWeakSet(new WeakSet()) // => true\n * isWeakSet(new Set()) // => false\n * ```\n * @version 12.2.0\n */\ndeclare function isWeakSet<T extends WeakKey = WeakKey>(value: unknown): value is WeakSet<T>;\n\nexport { AggregateErrorOrPolyfill as AggregateError, Any, type Assign, type Awaitable, type BoxedPrimitive, type BuiltInType, type CastArray, type CastArrayIfExists, type Class, type CloningStrategy, type Comparable, type ComparableProperty, type Comparator, type ComparatorMapping, type CompatibleProperty, type Concat, type Crush, type CustomClass, type CustomClassRegistry, type DebounceFunction, type DebounceOptions, DefaultCloningStrategy, DurationParser, type DurationShortUnit, type DurationString, type DurationUnit, type Err, type ExtractArray, type ExtractClass, type ExtractMap, type ExtractNotAny, type ExtractSet, type Falsy, FastCloningStrategy, type FilteredKeys, type Flip, type GuardReturnType, type Intersect, type IsExactType, type KeyFilter, type KeyFilterFunction, type LowercaseKeys, type MappedInput, type MappedOutput, type Mapping, type MappingFunction, type MemoOptions, type NoInfer$1 as NoInfer, type Ok, type OnceFunction, type OptionalKeys, type OptionalMapping, type ParallelOptions, type Primitive, type PromiseWithResolvers, QuantityParser, type QuantityString, type RequiredKeys, type Result, type ResultPromise, type RetryOptions, Semaphore, type SemaphoreAcquireOptions, SemaphorePermit, type Series, type Simplify, type StrictExtract, type SwitchAny, type SwitchNever, type ThrottledFunction, TimeoutError, type ToEmpty, type ToEmptyAble, type TraverseContext, type TraverseOptions, type TraverseVisitor, type TryitResult, type TypedArray, type UppercaseKeys, absoluteJitter, all, alphabetical, always, assert, assign, boil, callable, camel, capitalize, cartesianProduct, castArray, castArrayIfExists, castComparator, castMapping, chain, clamp, clone, cloneDeep, cluster, compose, concat, construct, counting, crush, dash, debounce, dedent, defer, diff, draw, escapeHTML, filterKey, first, flat, flip, fork, get, getOrInsert, getOrInsertComputed, group, guard, identity, inRange, intersects, invert, isArray, isArrayEqual, isAsyncIterable, isBigInt, isBoolean, isClass, isDangerousKey, isDate, isEmpty, isEqual, isError, isFloat, isFunction, isInt, isIntString, isIterable, isMap, isMapEqual, isNullish, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isResult, isResultErr, isResultOk, isSet, isSetEqual, isString, isSymbol, isTagged, isUndefined, isWeakMap, isWeakSet, iterate, keys, last, lerp, list, listify, lowerize, map, mapEntries, mapKeys, mapValues, mapify, max, memo, memoLastCall, merge, min, noop, objectify, omit, once, parallel, parseDuration, parseQuantity, partial, partob, pascal, pick, pluck, promiseChain, proportionalJitter, proxied, queueByKey, random, range, reduce, remove, replace, replaceOrAppend, retry, round, select, selectFirst, series, set, shake, shift, shuffle, sift, similarity, sleep, snake, sort, sum, template, throttle, timeout, title, toFloat, toInt, toResult, toggle, traverse, trim, tryit as try, tryit, uid, unique, unzip, upperize, withResolvers, zip, zipToObject };\n"],"x_google_ignoreList":[17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,46],"mappings":"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D,mBfhCkB,CegCEE,UfhCF,SAAA,OAAA,GegC+BC,MfhC/B,CAAA,MegC4CD,UfhC5C,EAAA,KAAA,CAAA,GAAA,KAAA,CAAA;;;;;;AJF1B;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;KkBmBYE,yBAAyBE,QAAQD;;;;ApBrB7C;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;AAAoD,KiBiCxCG,ejBjCwC,CAAA,aAAA,MAAA,EAAA,cAAA,MiBiCeC,IjBjCf,CAAA,GiBkCnDF,KjBlCmE,CiBkC7DE,IjBlC6D,GiBkCtDC,KjBlCsD,CAAA,SAAA,IAAA,GAAA,KAAA,GiBmChEA,KjBnCoE,SAAA,MiBmClDD,IjBnCkD,GiBoCnEA,IjBpCoE,SiBoCvDE,MjBpCuD,CiBoChDD,KjBpCgD,EiBoC3CD,IjBpC2C,CiBoCtCC,KjBpCsC,CAAA,CAAA;;;;AJFzE;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;AAAoH,KmB0BxGG,cnB1BwG,CAAA,aAAA,MAAA,CAAA,GmB2BnHC,InB3BoH,SAAA,OAAA,CAAA;AAAA,yBmB4B3FA,QACvBF,gBAAgBE,MAAMC,6BAEnBA,GlBhCU,GACA,KAAA,EAAoC,CAAA,GAAA,MkBiCvCD,IlBjCuC,CAAA;AAAA,EAAgB,KAAA;;;;AJFpE;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;AAAyD,KoBuB7CG,cpBvB6C,CAAA,aAAA,MAAA,CAAA,GoBwBxDC,IpBxBgF,SAAA,OAAA,CAAA;AAAA,EoByB7EC,OpBzBgG,CAAA,MoByBlFD,IpBzBkF,EoByB5EF,cpBzB4E,CoByB7DE,IpBzB6D,CAAA,CAAA,GAAgB,KAAA;;;;AHFpH;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;;;;;;;ACAgB,KkBiDJG,elBjDqB,CAAA,iBAAA,MAAA,CAAA,GkBiDsBD,clBjDtB,CkBiDqCE,QlBjDrC,CAAA,SAAA,KAAA,GAAA,KAAA,GAAA,IAAA;;;;;;ANFjC;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;;AAA4F,KoB4ChFC,OpB5CgF,CAAA,CAAA,CAAA,GAAA,CoB4ClEC,CpB5CkE,CAAA,SAAA,CAAA,KAAA,CAAA,GAAA,IAAA,GAAA,KAAA;;;;ALF5F;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACCA;;;;;;;;;ACAA;;;;;;;;;KiBoFYE,iDACXD,QAAQE,qBACLE,aACAF,IhBvFY,SAAA,IAAY,GgBwFvBC,QhBxFiD,GgByFjDC,UhBzF+D;;;;;;;;;;;;;AAApE;;;;;;;;;ACDA;;;;ACLA;;;;;;;;;;;;;ACOA;;;;;;;;ACAgB,KawHJ4B,ebxHiB,CAAA,CAAA,EAAA,iBAAiB,EAAc,QAAA,GAAA,EAAA,UAAA,KAAA,CAAA,GayH3D3B,EbxHD,CawHIC,KbxHY,CawHNqB,CbxHM,CAAA,EawHFM,KbxHE,EawHK5B,EbxHQ,CawHLE,ObxHK,CawHGoB,CbxHc,CAAA,EawHVO,ObxHU,EawHDF,iBbxH6F,CAAA,CAAA;;;;;;AdL1I;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;;;;;;;ACAgB,KsBiDJK,QtBjDI,CAAA,CAAA,CAAA,GAAiB,cAAA,MsBiDYC,CtBjDZ,GsBiDgBA,CtBjDhB,CsBiDkBC,OtBjDlB,CAAA,EAAA,GAAA,CAAA,CAAA;;;;;ANFjC;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;AAAgH,K2BkBpGE,O3BlBoG,CAAA,GAAA,EAAA,GAAA,CAAA,I2BmB9GC,cAAYC,QACTA,cAAYD,OACZE,SAASF,KAAGC,O1BrBD,KAAA,GAAyC,KAAA;;K0B0BpDC,Q1B1B+G,CAAA,GAAA,EAAA,GAAA,CAAA,GAAC,CAAA,CAAA,CAAA,CAAA,GAAA,G0B2B1GC,C1B3B0G,S0B2BhGH,G1B3BgG,G0B2B5FG,C1B3B4F,G0B2BxFA,C1B3BwF,GAAA,CAAA,GAAA,CAAA,CAAA,mB0B4B1GA,UAAUF,MAAIE,IAAIA;;;;;;A7B9B7B;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACCA;;;;;;;;;ACAA;;AAA0D,KqB6E9CC,kBrB7E8C,CAAA,UAAA,CAAA,GAAA,cAAmB,MqB8E1DC,UrB9E0D,IAAA,CAAA,CAAA,SqB8EjCE,MrB9EiC,CqB8E1BD,OrB9E0B,EAAA,OAAA,CAAA,GAA8C,KAAA,GqBgFvHA,OrBhF4I,GqBgFlID,UrBhFkI,CqBgFvHC,OrBhFuH,CAAA,EAAc;;;;;;ATH9J;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;AAAyE,K2BoC7DE,kB3BpC6D,CAAA,UAAA,CAAA,GAAA,oB2BqCtDC,yBAAyBE,OAAOD,oBAC/CA,kBACQD,WAAWC,U1BvCvB;;;;K2BJKK,WhCEuC,CAAA,WAAA,EAAA,MAAA,CAAA,GAAA,UAAyB,MgCDtDC,WhCCsD,IgCDvCE,GhCCuC,SAAA,MgCDrBD,MhCCqB,GAAA,KAAA,GgCDJC,GhCCI,GgCDEF,WhCCF,CgCDcE,GhCCd,CAAA,EAAC,GgCAlED,MhCAkE;;;;ACEtE;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;AAAoE,K4BkCxDE,K5BlCwD,CAAA,WAAA,EAAA,MAAA,CAAA,G4BmCpEL,Q5BnCwE,C4BoCvEC,W5BpCwE,C4BoC5DF,kB5BpC4D,C4BoCzCG,W5BpCyC,CAAA,E4BoC3BH,kB5BpC2B,C4BoCRI,M5BpCQ,CAAA,CAAA,G4BqCtEF,YAAYH,mBAAmBI,cAAcJ,mBAAmBK;;;;;;;;AtBpCnE;;;;;;;;;ACDA;;;;ACLA;;;;;;;;;;;;;ACOA;;;;;;KoBsHY+B,gCAAgC1B,YAAYoB,oBAC3CA,KAAKS,QAAQD,GAAGD,QAAQP,EAAEQ,InBvHvC;;;;;;;;;;;;;;;;;;;;;;;AEiDA;;;;;;;;;;ACvDA;;;;;;;;;;ACYA;;;;;;;;;ACsBA;AAE4BnH,KcoLhBwH,mBdpLgBxH,CAA0CA,gBAAAA,MAAAA,EAAbC,iBcsLvCoF,QdtLuCpF,CcsL9B4H,IdtL8B5H,CcsLzB2H,QdtLyB3H,CcsLhBwH,OdtLgBxH,CAAAA,EcsLNuF,cdtLMvF,CcsLSwH,OdtLTxH,CAAAA,CAAAA,GcsLqB8H,OdtLrB9H,CcsL6B6H,MdtL7B7H,CcsLoCuF,cdtLpCvF,CcsLmDwH,OdtLnDxH,CAAAA,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAAjDH,yBcuLkB2H,OdvLlB3H,CAAmB,GcyL1B8F,GAAGD,MAAMgC,mBAAmBD,UAC3B9B,GAAGC,QAAQ8B,mBAAmBD,UAC7BrC,SAASI,MAAMiC,oBbxMD,MayMCC,gBbzMmBvH,Ia0M9BgG,YAAYV,eAAe+B,6BAA6BE,iBAAiBvB,eAAeA,MAAMA,MAC9FuB,iBAAiBvB,UAChBwB,SAASH;;;AjCjOjB;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;KgCqBKU,iCAA+BD,QAAQE,WAASC,qCAAqCD,kBAAgBC,sBAAsBD;A/BrBvE,K+BuB7CE,aAAAA,G/BvB6C;EAAwB;;;;;ECDjF,iBAA0B,CAAA,EAAA,OAAA;AAC1B,CAAA;K8BkCKC,oBAAAA,G9BlC+D;EAAI,iBAAA,EAAA,KAAA;CAAC;;;;ACAzE;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACCA;;;;;;;;;ACAA;;;;;;;;;;;;ACAA;;;;;AAAoH,KwB4FxGC,MxB5FwG,CAAA,UAAA,EAAA,iBAAA,MwB4F9DC,UxB5F8D,EAAA,gBwB4FlCH,axB5FkC,GAAA,CAAA,CAAA,CAAA,GwB6FnHM,QAAQH,YAAYC,UAAUT,oBAAoBK,eAAeC,sBAAsBI;KAEnFC,2CAA2CH,4BAA4BI,SAASP,gCvBhGrE,MuBiGGG,UvBjGO,IuBiGON,MvBjGqC,CuBiG9BC,OvBjG8B,EuBiGrBM,QvBjGqB,CAAA,GuBiGTD,UvBjGS,CuBiGEL,OvBjGF,CAAA,MuBkGjEO,4CACFI,QAAQD,OAAOJ;;;;;;;;AjCnGlB;;;;;;;;;;ACAA;;;;;;AAAgH,KiCkBpGW,iBjClBoG,oCiCoBxFC,mBAAmBA,cAE1CJ,ehCtBe,CgCsBCI,UhCtBc,EgCuB7BL,EhCvBuD,CgCuBpDG,OhCvBoD,CgCuB5CG,QhCvB4C,CAAA,EAAwB,KAAA,EgCyB9EC,kBhCzBiG,CgCyB9EF,UhCzB8E,EgCyBlEL,EhCzBkE,CgCyB/DE,KhCzB+D,CgCyBzDI,QhCzByD,CAAA,EAAA,MgCyBxCD,UhCzBwC,EgCyB5BC,QhCzB4B,CAAA,CAAA,CAAgB,CAAA;KgC4B/GC,sDAEmBF,W/B/BxB,GAAgB;EAChB;AAAA,Q+BiCSC,Q/BjC2C,K+BiC9BI,Q/BjC8B,C+BiCrBD,I/BjCqB,C+BiChBJ,U/BjCgB,E+BiCJG,G/BjCI,CAAA,CAAA;AAAA;AAAgB;A+BmClEI,O/BnCsE,C+BmC9DH,I/BnC8D,C+BmCzDJ,U/BnCyD,E+BmC7CM,O/BnC6C,C+BmCrCL,Q/BnCqC,E+BmC3BE,G/BnC2B,CAAA,CAAA,CAAA,EAAC,C+BoCvEF,Q/BpCuE,CAAA;;A+BsCzEP,OAAOM,YAAYC;;;AnCxCnB;;;;;;;;ACEA;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;AAAoH,KiC0BxGS,cjC1BwG,CAAA,UAAA,MAAA,CAAA,GiC0BrEF,ejC1BqE,CiC0BrDG,CjC1BqD,CAAA,SAAA,IAAA,GiC0BnCA,CjC1BmC,GiC0B/BF,iBjC1B+B,CiC0BbE,CjC1Ba,EAAA,MiC0BJA,CjC1BI,CAAA;;;AHFpH;;;;;;;;ACEA;KoCGKG,WpCHiD,CAAA,CAAA,CAAA,GoCItDD,mBpCJsE,CoCIlDE,CpCJkD,SAAA,GAAA,GAAA,GAAA,GoCI5BA,CpCJ4B,GAAA,KAAA,CAAA,UAAA,GAAA,GAAA,CAAA,KAAA,EAAA,CAAA,IAAM,CAAA,GAAM,KAAA;;;;;;ACAlF;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;AAAuF,KgC2C3EC,YhC3C2E,CAAA,CAAA,EAAA,IgC2CvDF,WhC3CuD,CgC2C3CC,ChC3C2C,CAAA,CAAA,GgC4CvFH,OhC5C4F,CgC4CpFG,ChC5CoF,CAAA,SAAA,KAAA,GAAC,CAAA,GgC6CtFC,YhC7CsF,CgC6CzEE,OhC7CyE,CgC6CjEH,ChC7CiE,EgC6C9DE,ChC7C8D,CAAA,CAAA,EgC6CzDA,ChC7CyD,CAAA;;;;;;;;;;AJA7F;;;;;;;;;;ACAA;;;;;;;;KoCoBYK,yCAAyCC,aACnDA,mDnCrBc,CAAA,GAAA,UAAA,EmCsBIE,UnCtBW,CmCsBAF,QnCtBA,CAAA,EAAA,GmCsBcG,UnCtBd,CmCsByBH,QnCtBzB,CAAA,GAA0B,OAAA,CAAA,GmCwBtDI,YnCxB8E,CmCwBjEJ,QnCxBiE,EmCwBvDC,InCxBuD,CAAA;KmC0B5EG,YnC1B+G,CAAA,QAAA,EAAA,aAAA,MmC0BrEJ,QnC1BqE,CAAA,GmC2BnHA,QnC3BoH,SAAA,OAAA,CAAA;AAAA,EmC4BjHF;;AAEDF,OAAOI,UAAUC;AlC/BpB;AkCiCGI,OlChCa,CkCgCLR,elChCe,CkCgCCG,QlChCD,EkCgCWC,IlChCX,CAAA,CAAA,CAA0B,GAAgB,KAAA;;;;;;AJFpE;;;;;;;;ACEA;;;;;;;;;;ACAgB,KqCYJK,OrCZI,CAAa,UAAA,EAAA,kBAAA,MqCY2BC,UrCZ3B,GAAA,MqCY8CA,UrCZ9C,CAAA,GqCY4DA,UrCZ5D,CqCYuEC,SrCZvE,CAAA;;;KsCPjBE,cAAAA;ExCKZ,GAAgB,CAAA,EAAA,OAAA;CAAwB;KwCDnCC,qBAAAA,GxCCgE;EAAC,GAAA,EAAA,KAAA;;;;ACEtE;;;;;;;;;;ACAA;;;;;;;;;;ACAA;;;;;;;;;ACDA;AACA;;;;;;;;ACAA;;;;;;;;;ACAA;;;;;AAAuH,KkCsD3GC,OlCtD2G,0ECDvH,gBiC2DiBF,cjC3DkC,GAAO,CAAA,CAAA,CAC1D,GiC2DIO,QjC3DY,CiC2DHJ,KjC3DY,EiC2DLC,MjC3DK,EiC2DGC,WjC3DH,EiC2DgBN,mBjC3DhB,CiC2DoCC,cjC3DpC,EiC2DoDC,qBjC3DpD,EiC2D2EK,OjC3D3E,CAAA,CAAA;KiC6DpBC,QjC7D8D,CAAI,cAAA,MAAA,EAAC,eAAA,MAAA,8CiCiEvDE,SAAST,iDhChE1B,GgCkEII,MhClEY,SAAU,MAAA,CAAA;AAAA,EgCmEvBC,WhCnEiD,SAAA,MAAA,CAAA;AAAA,EgCoEhDF,KhCpEyE,S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hExGzF,CgEwG2G,ChExG3G,EgEwG8G,EhExG9G,CAAA,CAAA,EgEwGoH,ChExGpH;;;KiEJhC,0BAA0B,+BAA+B,eAAe,YAAY,GAAG;AjEInF,KiEFJ,gBjEEa,CAAA,UiEFc,SjEEd,CAAA,GAAA,CAAA,GAAA,EiEFiC,CjEEjC,EAAA,IAAA,EiEF0C,gBjEE1C,CiEF2D,CjEE3D,CAAA,EAAA,GAAA,OAAA;;;;AAA6C,iBiE8EtD,QjE9EsD,CAAA,UiE8EnC,SjE9EmC,EAAA,WAAA,MAAA,GiE8EJ,WjE9EI,CAAA,CAAA,IAAA,EiE8Ee,CjE9Ef,GiE8EmB,CjE9EnB,EAAA,EAAA,QAAA,EiE8EkC,gBjE9ElC,CiE8EmD,CjE9EnD,CAAA,EAAA,OAAA,CAAA,EiE8EgE,ejE9EhE,CiE8EgF,CjE9EhF,EiE8EmF,EjE9EnF,CAAA,CAAA,EiE8E8F,CjE9E9F,GAAA,SAAA;;;KkEJ1D,6BAA6B,+BAA+B,eAAe,YAAY,GAAG;AlEItF,KkEFJ,mBlEEa,CAAA,UkEFiB,SlEEjB,CAAA,GAAA,CAAA,GAAA,EkEFoC,ClEEpC,EAAA,IAAA,EkEF6C,gBlEE7C,CkEF8D,ClEE9D,CAAA,EAAA,GAAA,IAAA;AAAe,iBkEsDxB,WlEtDwB,CAAA,UkEsDF,SlEtDE,EAAA,WAAA,MAAA,GkEsD6B,WlEtD7B,CAAA,CAAA,IAAA,EkEsDgD,ClEtDhD,GkEsDoD,ClEtDpD,EAAA,EAAA,QAAA,EkEsDmE,mBlEtDnE,CkEsDuF,ClEtDvF,CAAA,EAAA,OAAA,CAAA,EkEsDoG,kBlEtDpG,CkEsDuH,ClEtDvH,EkEsD0H,ElEtD1H,CAAA,CAAA,EAAA,IAAA;;;KmEF5B,yBAAyB,gCAAgC,YAAY,GAAG;AnEEpE,KmEAJ,enEAa,CAAA,YmEAa,SnEAb,EAAA,UmEAkC,SnEAlC,CAAA,GAAA,CAAA,GAAA,EmEAqD,CnEArD,EAAA,IAAA,EmEA8D,gBnEA9D,CmEA+E,CnEA/E,CAAA,EAAA,GmEAsF,GnEAtF;AAAe,iBmEmFxB,OnEnFwB,CAAA,YmEmFN,SnEnFM,EAAA,UmEmFe,SnEnFf,EAAA,WAAA,MAAA,GmEmF8C,WnEnF9C,CAAA,CAAA,IAAA,EmEmFiE,CnEnFjE,EAAA,EAAA,QAAA,EmEmFgF,enEnFhF,CmEmFgG,GnEnFhG,EmEmFmG,CnEnFnG,CAAA,EAAA,OAAA,CAAA,EmEmFiH,cnEnFjH,CmEmFgI,CnEnFhI,EmEmFmI,EnEnFnI,CAAA,CAAA,EmEmFyI,QnEnFzI,CmEmFkJ,GnEnFlJ,EmEmFqJ,EnEnFrJ,CAAA,EAAA;AAAI,iBmEoF5B,OnEpF4B,CAAA,YmEoFV,SnEpFU,EAAA,UmEoFW,SnEpFX,EAAA,WAAA,MAAA,GmEoF0C,WnEpF1C,CAAA,CAAA,IAAA,EmEoF6D,CnEpF7D,EAAA,QAAA,EmEoF0E,enEpF1E,CmEoF0F,GnEpF1F,EmEoF6F,CnEpF7F,CAAA,EAAA,OAAA,CAAA,EmEoF2G,cnEpF3G,CmEoF0H,CnEpF1H,EmEoF6H,EnEpF7H,CAAA,CAAA,EmEoFmI,QnEpFnI,CmEoF4I,GnEpF5I,EmEoF+I,EnEpF/I,CAAA;;;UoEJ3B,sCACK,4BACA,iCACA;WAEX;EpEDK,WAAA,CAAS,EoEET,EpEFS;EAAe,WAAA,CAAA,EoEGxB,EpEHwB;;;;;iBoESxB,qBACJ,YAAY,+BACF,mBAChB,SAAS,GAAG,yBACI,4BACA,mBACd,eAAe,kBAAkB,IAAI,IAAI,kBAAkB;;;ApEfnE,KqEHK,iBrEGoB,CAAA,UqEHQ,SrEGR,EAAA,WAAA,MAAA,GqEHuC,WrEGvC,CAAA,GqEHsD,kBrEGtD,CqEHyE,CrEGzE,EqEH4E,ErEG5E,CAAA;;;;AAA6C,iBqEEtD,UrEFsD,CAAA,UqEG1D,SrEH0D,EAAA,WAAA,MAAA,GqEIhD,WrEJgD,EAAA,YqEK1D,SrEL0D,GqEK9C,WrEL8C,CqEKlC,CrELkC,EqEK/B,ErEL+B,CAAA,CAAA,CAAA,IAAA,EqEM9D,CrEN8D,GqEM1D,CrEN0D,EAAA,EAAA,OAAA,CAAA,EqEM5C,iBrEN4C,CqEM1B,CrEN0B,EqEMvB,ErENuB,CAAA,CAAA,EqEMZ,GrENY,EAAA;;;iBsELtD,aAAA,2BAAwC;;;KCAnD,UAAA,GAAe,YAAY,aAAa,oBAAoB,aAAa,cAAc,aAAa,cAAc,eAAe,eAAe,gBAAgB;iBAErJ,OAAA;iBAIA,YAAA,2BAAuC;;;iBCRvC,QAAA;;;iBCEA,MAAA,2BAAiC;;;iBCFjC,SAAA;;;iBCcA,OAAA,2BAAkC,MAAM;;;iBCXxC,MAAA,2BAAiC;;;;;;A5EIjD;;;;AAAsE,iB6EEtD,O7EFsD,CAAA,CAAA,CAAA,CAAA,CAAA,E6EExC,C7EFwC,EAAA,CAAA,E6EElC,C7EFkC,CAAA,EAAA,OAAA;;;iB8ELtD,OAAA,2BAAkC;;;iBCAlC,OAAA;iBAQA,WAAA;;;iBCRA,MAAA,2BAAiC;;;iBCAjC,UAAA,2BAAqC;iBAIrC,eAAA,2BAA0C;iBAI1C,mBAAA,2BAA8C;AjFH9C,iBiFOA,wBAAA,CjFPS,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IiFO0C,yBjFP1C;;;iBkFLT,UAAA;GAAwC,MAAA,CAAO,QAAA,SAAiB;;;;iBCAhE,KAAA,2BAAgC;iBAIhC,SAAA,2BAAoC,QAAQ;;;iBCN5C,MAAA;;;;;;ApFOhB;;;AAAqE,iBqFDrD,QAAA,CrFCqD,KAAA,EAAA,OAAA,EAAA,QAAA,CAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAA,MAAA;;;;;ACErE;AAAsD,iBoFMtC,KAAA,CpFNsC,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAA,MAAA;;;;;;;iBoFgBtC,SAAA;;AnFhBhB;;;;;;AAAgH,iBmF6BhG,iBAAA,CnF7BgG,KAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAA,MAAA;;;;ACAhH;;;;AAAoH,iBkFwCpG,iBAAA,ClFxCoG,KAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAA,MAAA;;;;;ACDpH;AACA;AAAoD,iBiFkDpC,UAAA,CjFlDoC,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAA,MAAA;;;;;;;ACApC,iBgF4DA,cAAA,ChF5DS,KAAA,EAAA,OAAA,CAAA,EAAA,OAAA;;;;;;ALFzB;;;;AAAsE,iBsFEtD,QAAA,CtFFsD,KAAA,EAAA,OAAA,EAAA,cAAA,CAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IsFEI,MtFFJ,CsFEW,WtFFX,EAAA,OAAA,CAAA;;;iBuFHtD,SAAA,2BAAoC;iBAIpC,aAAA,2BAAwC;;;;;;AvFDxD;;;;;;iBwFKgB,gBAAA,2BAA2C;;;iBCT3C,QAAA,2BAAmC;;;iBCDnC,KAAA,2BAAgC;iBAIhC,SAAA,2BAAoC,QAAQ;;;;;;A1FC5D;;;AAAqE,iB2FDrD,QAAA,C3FCqD,KAAA,EAAA,OAAA,EAAA,UAAA,CAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAA,MAAA;;;iB4FPrD,QAAA;;;iBCAA,WAAA;;;iBCEA,iBAAA,2BAA4C;;;iBCA5C,WAAA,2BAAsC;;;iBCAtC,QAAA,2BAAmC"}