modern-ts 0.8.0

package/dist/types/Fit/tool.d.ts

@@ -0,0 +1,585 @@
+/**
+ * Type guard that checks if a value is a string.
+ * @param x - The value to check
+ * @returns True if the value is a string
+ */
+declare const _string: (x: unknown) => x is string;
+/**
+ * Type guard that checks if a value is a number.
+ * @param x - The value to check
+ * @returns True if the value is a number
+ */
+declare const _number: (x: unknown) => x is number;
+/**
+ * Type guard that checks if a value is a boolean.
+ * @param x - The value to check
+ * @returns True if the value is a boolean
+ */
+declare const _boolean: (x: unknown) => x is boolean;
+/**
+ * Type guard that checks if a value is a symbol.
+ * @param x - The value to check
+ * @returns True if the value is a symbol
+ */
+declare const _symbol: (x: unknown) => x is symbol;
+/**
+ * Type guard that checks if a value is a bigint.
+ * @param x - The value to check
+ * @returns True if the value is a bigint
+ */
+declare const _bigint: (x: unknown) => x is bigint;
+/**
+ * Type guard that checks if a value is a function.
+ * @param x - The value to check
+ * @returns True if the value is a function
+ */
+declare const _function: (x: unknown) => x is (...args: unknown[]) => unknown;
+/**
+ * Type guard that checks if a value is a non-null object.
+ * @param x - The value to check
+ * @returns True if the value is a non-null object
+ */
+declare const _object: (x: unknown) => x is Record<string, unknown>;
+/**
+ * Type guard that checks if a value is an array.
+ * @param x - The value to check
+ * @returns True if the value is an array
+ */
+declare const _array: (x: unknown) => x is unknown[];
+/**
+ * Type guard that checks if a value is undefined.
+ * @param x - The value to check
+ * @returns True if the value is undefined
+ */
+declare const _undefined: (x: unknown) => x is undefined;
+/**
+ * Type guard that checks if a value is null.
+ * @param x - The value to check
+ * @returns True if the value is null
+ */
+declare const _null: (x: unknown) => x is null;
+/**
+ * Type guard that checks if a value is null or undefined.
+ * @param x - The value to check
+ * @returns True if the value is null or undefined
+ */
+declare const _nullish: (x: unknown) => x is null | undefined;
+/**
+ * Type guard that checks if a value is a primitive type.
+ * @param x - The value to check
+ * @returns True if the value is string, number, boolean, null, undefined, symbol, or bigint
+ */
+declare const _primitive: (x: unknown) => x is string | number | boolean | null | undefined | symbol | bigint;
+/**
+ * Type guard that checks if a value is a Date object.
+ * @param x - The value to check
+ * @returns True if the value is a Date instance
+ */
+declare const _date: (x: unknown) => x is Date;
+/**
+ * Type guard that checks if a value is a RegExp object.
+ * @param x - The value to check
+ * @returns True if the value is a RegExp instance
+ */
+declare const _regexp: (x: unknown) => x is RegExp;
+/**
+ * Type guard that checks if a value is an Error object.
+ * @param x - The value to check
+ * @returns True if the value is an Error instance
+ */
+declare const _error: (x: unknown) => x is Error;
+/**
+ * Type guard that checks if a value is a Map object.
+ * @template K - The map key type (default: unknown)
+ * @template V - The map value type (default: unknown)
+ * @param x - The value to check
+ * @returns True if the value is a Map instance
+ */
+declare const _map: <K = unknown, V = unknown>(x: unknown) => x is Map<K, V>;
+/**
+ * Type guard that checks if a value is a Set object.
+ * @template T - The set element type (default: unknown)
+ * @param x - The value to check
+ * @returns True if the value is a Set instance
+ */
+declare const _set: <T = unknown>(x: unknown) => x is Set<T>;
+/**
+ * Type guard that checks if a value is a WeakMap object.
+ * @template K - The weak map key type (must extend object, default: object)
+ * @template V - The weak map value type (default: unknown)
+ * @param x - The value to check
+ * @returns True if the value is a WeakMap instance
+ */
+declare const _weakMap: <K extends object, V = unknown>(x: unknown) => x is WeakMap<K, V>;
+/**
+ * Type guard that checks if a value is a WeakSet object.
+ * @template T - The weak set element type (must extend object, default: object)
+ * @param x - The value to check
+ * @returns True if the value is a WeakSet instance
+ */
+declare const _weakSet: <T extends object>(x: unknown) => x is WeakSet<T>;
+/**
+ * Type guard that checks if a value is a plain object (non-null object that is not an array).
+ * @param x - The value to check
+ * @returns True if the value is a plain object
+ */
+declare const _plainObject: (x: unknown) => x is Record<string, unknown>;
+/**
+ * Type guard that checks if a value is iterable (has Symbol.iterator).
+ * @param x - The value to check
+ * @returns True if the value implements the Iterable protocol
+ */
+declare const _iterable: (x: unknown) => x is Iterable<unknown>;
+/**
+ * Type guard that checks if a value is async iterable (has Symbol.asyncIterator).
+ * @param x - The value to check
+ * @returns True if the value implements the AsyncIterable protocol
+ */
+declare const _asyncIterable: (x: unknown) => x is AsyncIterable<unknown>;
+/**
+ * Creates a type guard that checks if a value is a Record with specific key and value types.
+ * @template K - The record key type (must extend PropertyKey)
+ * @template V - The record value type
+ * @param key_guard - The type guard for keys
+ * @param value_guard - The type guard for values
+ * @returns A type guard that returns true if all enumerable own properties pass both guards
+ */
+declare const _record: <K extends PropertyKey, V>(key_guard: (k: unknown) => k is K, value_guard: (v: unknown) => v is V) => (x: unknown) => x is Record<K, V>;
+/**
+ * Type guard that checks if a value is truthy (coerces to true in boolean context).
+ * @template T - The expected truthy type
+ * @param x - The value to check
+ * @returns True if the value is truthy (excludes null, undefined, false, 0, '', 0n)
+ */
+declare const _truthy: <T>(x: T | null | undefined | false | 0 | "" | 0n) => x is T;
+/**
+ * Type guard that checks if a value is falsy (coerces to false in boolean context).
+ * @param x - The value to check
+ * @returns True if the value is null, undefined, false, 0, '', or 0n
+ */
+declare const _falsy: (x: unknown) => x is null | undefined | false | 0 | "" | 0n;
+/**
+ * Checks if a value is empty (nullish, empty string/array, empty Map/Set, or object with no keys).
+ * @param x - The value to check
+ * @returns True if the value is considered empty
+ */
+declare const _empty: (x: unknown) => boolean;
+/**
+ * Checks if a value is non-empty (not nullish, has content).
+ * @param x - The value to check
+ * @returns True if the value is considered non-empty
+ */
+declare const _nonEmpty: (x: unknown) => boolean;
+/**
+ * Creates a type guard that checks if a value equals a specific value (strict equality).
+ * @template T - The expected value type
+ * @param val - The value to compare against
+ * @returns A type guard that returns true if the value === val
+ */
+declare const _eq: <T>(val: T) => (x: unknown) => x is T;
+/**
+ * Creates a predicate that checks if a value does not equal a specific value.
+ * @template T - The comparison value type
+ * @param val - The value to compare against
+ * @returns A predicate that returns true if the value !== val
+ */
+declare const _neq: <T>(val: T) => (x: unknown) => boolean;
+/**
+ * Creates a predicate that checks if a number is greater than a value.
+ * @param val - The comparison value
+ * @returns A predicate that returns true if the number > val
+ */
+declare const _gt: (val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is greater than or equal to a value.
+ * @param val - The comparison value
+ * @returns A predicate that returns true if the number >= val
+ */
+declare const _gte: (val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is less than a value.
+ * @param val - The comparison value
+ * @returns A predicate that returns true if the number < val
+ */
+declare const _lt: (val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is less than or equal to a value.
+ * @param val - The comparison value
+ * @returns A predicate that returns true if the number <= val
+ */
+declare const _lte: (val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is strictly between two values (exclusive).
+ * @param min_val - The minimum value (exclusive)
+ * @param max_val - The maximum value (exclusive)
+ * @returns A predicate that returns true if min_val < number < max_val
+ */
+declare const _between: (min_val: number, max_val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is between two values (inclusive).
+ * @param min_val - The minimum value (inclusive)
+ * @param max_val - The maximum value (inclusive)
+ * @returns A predicate that returns true if min_val <= number <= max_val
+ */
+declare const _betweenInclusive: (min_val: number, max_val: number) => (x: number) => boolean;
+/**
+ * Creates a type guard that checks if a value is one of the specified values.
+ * @template T - The tuple of allowed values
+ * @param vals - The values to check against
+ * @returns A type guard that returns true if the value is in the list
+ */
+declare const _oneOf: <const T extends readonly [unknown, ...unknown[]]>(...vals: T) => (x: unknown) => x is T[number];
+/**
+ * Creates a predicate that checks if a value is not one of the specified values.
+ * @template T - The tuple of excluded values
+ * @param vals - The values to exclude
+ * @returns A predicate that returns true if the value is not in the list
+ */
+declare const _notOneOf: <const T extends readonly [unknown, ...unknown[]]>(...vals: T) => (x: unknown) => boolean;
+/**
+ * Creates a type guard that checks if a value is an instance of a class.
+ * @template T - The constructor type
+ * @param cls - The class constructor to check against
+ * @returns A type guard that returns true if the value is an instance of cls
+ */
+declare const _instanceOf: <T extends abstract new (...args: any[]) => unknown>(cls: T) => (x: unknown) => x is InstanceType<T>;
+/**
+ * Creates a predicate that checks if a string has at least the specified length.
+ * @param len - The minimum required length
+ * @returns A predicate function that returns true if the string length is >= len
+ */
+export declare const min_len: (len: number) => (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a string has at most the specified length.
+ * @param len - The maximum allowed length
+ * @returns A predicate function that returns true if the string length is <= len
+ */
+export declare const max_len: (len: number) => (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a string length falls within a specified range.
+ * @param min - The minimum required length (inclusive)
+ * @param max - The maximum allowed length (inclusive)
+ * @returns A predicate function that returns true if the string length is within [min, max]
+ */
+export declare const len_range: (min: number, max: number) => (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a string matches a regular expression.
+ * @param reg - The regular expression to test against
+ * @returns A predicate function that returns true if the string matches the regex
+ */
+export declare const matches: (reg: RegExp) => (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a string starts with the specified prefix.
+ * @param prefix - The prefix to check for
+ * @returns A predicate function that returns true if the string starts with the prefix
+ */
+export declare const starts_with: (prefix: string) => (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a string ends with the specified suffix.
+ * @param suffix - The suffix to check for
+ * @returns A predicate function that returns true if the string ends with the suffix
+ */
+export declare const ends_with: (suffix: string) => (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a string contains the specified substring.
+ * @param substr - The substring to search for
+ * @returns A predicate function that returns true if the string contains the substring
+ */
+export declare const includes: (substr: string) => (x: string) => boolean;
+/**
+ * Checks if a string is equal to its trimmed version (no leading/trailing whitespace).
+ * @param x - The string to check
+ * @returns True if the string has no leading or trailing whitespace
+ */
+export declare const trimmed: (x: string) => boolean;
+/**
+ * Checks if a string has at least one character.
+ * @param x - The string to check
+ * @returns True if the string length is greater than 0
+ */
+export declare const non_empty_string: (x: string) => boolean;
+/**
+ * Checks if a string consists only of numeric digits.
+ * @param x - The string to check
+ * @returns True if the string matches /^\d+$/
+ */
+export declare const numeric_string: (x: string) => boolean;
+/**
+ * Checks if a string consists only of alphabetic characters (a-z, A-Z).
+ * @param x - The string to check
+ * @returns True if the string matches /^[a-zA-Z]+$/
+ */
+export declare const alpha_string: (x: string) => boolean;
+/**
+ * Checks if a string consists only of alphanumeric characters (a-z, A-Z, 0-9).
+ * @param x - The string to check
+ * @returns True if the string matches /^[a-zA-Z0-9]+$/
+ */
+export declare const alphanumeric_string: (x: string) => boolean;
+/**
+ * Checks if a string matches ISO 8601 datetime format.
+ * @param x - The string to check
+ * @returns True if the string matches ISO datetime format (YYYY-MM-DDTHH:mm:ss)
+ */
+export declare const iso_datetime: (x: string) => boolean;
+/**
+ * Validates an email address according to RFC 5321.
+ * @param email_str - The email string to validate
+ * @returns True if the string is a valid email address (max 254 characters per RFC 5321)
+ */
+export declare const email: (email_str: string) => boolean;
+/**
+ * Checks if a string is a valid URL.
+ * @param x - The string to check
+ * @returns True if the string can be parsed as a valid URL
+ */
+export declare const url: (x: string) => boolean;
+/**
+ * Checks if a string is a valid UUID format.
+ * @param x - The string to check
+ * @returns True if the string matches UUID format (8-4-4-4-12 hexadecimal)
+ */
+export declare const uuid: (x: string) => boolean;
+/**
+ * Checks if a string is a valid hexadecimal color code.
+ * @param x - The string to check
+ * @returns True if the string matches #RGB, #RRGGBB, or #RRGGBBAA format
+ */
+export declare const hex_color: (x: string) => boolean;
+/**
+ * Creates a predicate that checks if a number is greater than or equal to a minimum value.
+ * @param val - The minimum value (inclusive)
+ * @returns A predicate function that returns true if the number >= val
+ */
+export declare const min: (val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is less than or equal to a maximum value.
+ * @param val - The maximum value (inclusive)
+ * @returns A predicate function that returns true if the number <= val
+ */
+export declare const max: (val: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number falls within a specified range.
+ * @param min_val - The minimum value (inclusive)
+ * @param max_val - The maximum value (inclusive)
+ * @returns A predicate function that returns true if the number is within [min_val, max_val]
+ */
+export declare const range: (min_val: number, max_val: number) => (x: number) => boolean;
+/**
+ * Checks if a number is an integer (no fractional part).
+ * @param x - The number to check
+ * @returns True if the number is an integer
+ */
+export declare const integer: (x: number) => boolean;
+/**
+ * Checks if a number is a safe integer (within IEEE-754 safe integer range).
+ * @param x - The number to check
+ * @returns True if the number is a safe integer (-(2^53 - 1) to 2^53 - 1)
+ */
+export declare const safe_integer: (x: number) => boolean;
+/**
+ * Checks if a number is positive (greater than 0).
+ * @param x - The number to check
+ * @returns True if the number > 0
+ */
+export declare const positive: (x: number) => boolean;
+/**
+ * Checks if a number is negative (less than 0).
+ * @param x - The number to check
+ * @returns True if the number < 0
+ */
+export declare const negative: (x: number) => boolean;
+/**
+ * Checks if a number is non-positive (less than or equal to 0).
+ * @param x - The number to check
+ * @returns True if the number <= 0
+ */
+export declare const non_positive: (x: number) => boolean;
+/**
+ * Checks if a number is non-negative (greater than or equal to 0).
+ * @param x - The number to check
+ * @returns True if the number >= 0
+ */
+export declare const non_negative: (x: number) => boolean;
+/**
+ * Checks if a number is finite (not Infinity or -Infinity).
+ * @param x - The number to check
+ * @returns True if the number is finite
+ */
+export declare const finite: (x: number) => boolean;
+/**
+ * Type guard that checks if a value is NaN (Not a Number).
+ * @param x - The value to check
+ * @returns True if the value is NaN
+ */
+export declare const nan: (x: unknown) => x is number;
+/**
+ * Checks if a number is even (divisible by 2).
+ * @param x - The number to check
+ * @returns True if the number is even
+ */
+export declare const even: (x: number) => boolean;
+/**
+ * Checks if a number is odd (not divisible by 2).
+ * @param x - The number to check
+ * @returns True if the number is odd
+ */
+export declare const odd: (x: number) => boolean;
+/**
+ * Creates a predicate that checks if a number is divisible by a given divisor.
+ * @param divisor - The divisor to check divisibility against
+ * @returns A predicate function that returns true if the number is divisible by divisor
+ */
+export declare const multiple_of: (divisor: number) => (x: number) => boolean;
+/**
+ * Creates a predicate that checks if an array has at least the specified length.
+ * @template T - The array element type
+ * @param len - The minimum required length
+ * @returns A predicate function that returns true if the array length >= len
+ */
+export declare const arr_min_len: <T>(len: number) => (x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if an array has at most the specified length.
+ * @template T - The array element type
+ * @param len - The maximum allowed length
+ * @returns A predicate function that returns true if the array length <= len
+ */
+export declare const arr_max_len: <T>(len: number) => (x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if an array length falls within a specified range.
+ * @template T - The array element type
+ * @param min - The minimum required length (inclusive)
+ * @param max - The maximum allowed length (inclusive)
+ * @returns A predicate function that returns true if the array length is within [min, max]
+ */
+export declare const arr_len_range: <T>(min: number, max: number) => (x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if an array has exactly the specified length.
+ * @template T - The array element type
+ * @param len - The exact required length
+ * @returns A predicate function that returns true if the array length === len
+ */
+export declare const arr_len: <T>(len: number) => (x: T[]) => boolean;
+/**
+ * Type guard that checks if an array is non-empty.
+ * @template T - The array element type
+ * @param x - The array to check
+ * @returns True if the array has at least one element, narrowing type to [T, ...T[]]
+ */
+export declare const non_empty_array: <T>(x: T[]) => x is [T, ...T[]];
+/**
+ * Checks if an array contains only unique elements (no duplicates).
+ * @template T - The array element type
+ * @param x - The array to check
+ * @returns True if all elements in the array are unique
+ */
+export declare const unique: <T>(x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if an array is sorted.
+ * @template T - The array element type
+ * @param compare - Optional comparison function for sorting
+ * @returns A predicate function that returns true if the array is sorted
+ */
+export declare const sorted: <T>(compare?: (a: T, b: T) => number) => (x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if all array elements satisfy a condition.
+ * @template T - The array element type
+ * @param pred - The predicate function to test each element
+ * @returns A predicate function that returns true if every element passes the predicate
+ */
+export declare const every: <T>(pred: (val: T) => boolean) => (x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if at least one array element satisfies a condition.
+ * @template T - The array element type
+ * @param pred - The predicate function to test each element
+ * @returns A predicate function that returns true if at least one element passes the predicate
+ */
+export declare const some: <T>(pred: (val: T) => boolean) => (x: T[]) => boolean;
+/**
+ * Creates a predicate that checks if an object has a specific key (own or inherited).
+ * @param key - The key to check for (string, number, or symbol)
+ * @returns A predicate function that returns true if the key exists in the object
+ */
+export declare const has_key: (key: string | number | symbol) => (x: object) => boolean;
+/**
+ * Creates a predicate that checks if an object has a specific own property.
+ * @param key - The property key to check for
+ * @returns A predicate function that returns true if the object has the own property
+ */
+export declare const has_own: (key: string | number | symbol) => (x: object) => boolean;
+/**
+ * Creates a type guard that checks if an object has all specified keys.
+ * @template T - The tuple of required key names
+ * @param keys - The keys that must be present in the object
+ * @returns A type guard function that narrows the type to include the specified keys
+ */
+export declare const keys: <const T extends readonly string[]>(...keys: T) => <U extends Record<string, unknown>>(x: U) => x is U & Record<T[number], unknown>;
+/**
+ * Creates a predicate that checks if an object has exactly the specified keys (no more, no less).
+ * @template T - The tuple of expected key names
+ * @param keys - The exact keys the object should have
+ * @returns A predicate function that returns true if the object has exactly these keys
+ */
+export declare const exact_keys: <const T extends readonly string[]>(...keys: T) => (x: object) => boolean;
+type Predicate = (v: unknown) => boolean;
+type TypeGuard<T> = (v: unknown) => v is T;
+type ExtractGuardUnion<T extends readonly unknown[]> = T extends readonly [
+    infer H,
+    ...infer R
+] ? (H extends (v: unknown) => v is infer U ? U : never) | ExtractGuardUnion<R> : never;
+type ExtractGuardIntersection<T extends readonly unknown[]> = T extends readonly [infer H, ...infer R] ? H extends (v: unknown) => v is infer U ? U & ExtractGuardIntersection<R> : ExtractGuardIntersection<R> : unknown;
+/**
+ * Creates a type guard that is the union of multiple type guards.
+ * The resulting guard returns true if any of the input guards return true.
+ * @template T - The tuple of predicates or type guards
+ * @param guards - The type guards to combine with OR logic
+ * @returns A type guard that returns true if any guard passes
+ */
+export declare function union<T extends readonly (Predicate | TypeGuard<unknown>)[]>(...guards: T): (v: unknown) => v is ExtractGuardUnion<T>;
+/**
+ * Creates a type guard that is the intersection of multiple type guards.
+ * The resulting guard returns true only if all of the input guards return true.
+ * @template T - The tuple of predicates or type guards
+ * @param guards - The type guards to combine with AND logic
+ * @returns A type guard that returns true only if all guards pass
+ */
+export declare function and<T extends readonly (Predicate | TypeGuard<unknown>)[]>(...guards: T): (v: unknown) => v is ExtractGuardIntersection<T>;
+type ExtractDiscriminated<_K extends PropertyKey, T extends Record<PropertyKey, (v: unknown) => v is unknown>> = T[keyof T] extends (v: unknown) => v is infer R ? R : never;
+/**
+ * Creates a type guard for a discriminated union based on a discriminator key.
+ * @template K - The discriminator key type
+ * @template T - The record mapping discriminator values to type guards
+ * @param key - The property key used as the discriminator
+ * @param guards - A record mapping discriminator values to their corresponding type guards
+ * @returns A type guard that checks the discriminator value and applies the appropriate guard
+ */
+export declare const discriminatedUnion: <K extends PropertyKey, T extends Record<PropertyKey, (v: unknown) => v is unknown>>(key: K, guards: T) => (v: unknown) => v is ExtractDiscriminated<K, T>;
+/**
+ * Creates a type guard that checks if a value is an array where all elements pass the element guard.
+ * @template T - The element type
+ * @param element_guard - The type guard to apply to each element
+ * @returns A type guard that returns true if the value is an array of T
+ */
+export declare const arrayOf: <T>(element_guard: (v: unknown) => v is T) => (v: unknown) => v is T[];
+/**
+ * Creates a type guard that checks if an object matches a specific shape.
+ * @template T - The expected object shape type
+ * @param shape - A record of type guards for each property
+ * @returns A type guard that returns true if the object matches the shape
+ */
+export declare const objectShape: <T extends Record<string, unknown>>(shape: { [K in keyof T]: (v: unknown) => v is T[K]; }) => (v: unknown) => v is T;
+/**
+ * Creates a type guard that checks if a value is a number within a specified range.
+ * @param min_val - The minimum value (inclusive)
+ * @param max_val - The maximum value (inclusive)
+ * @param int - Whether the number must be an integer (default: false)
+ * @returns A type guard that returns true if the value is a number within the range
+ */
+export declare const numRange: (min_val: number, max_val: number, int?: boolean) => (v: unknown) => v is number;
+/**
+ * Type guard that checks if a value is a non-negative integer (0, 1, 2, ...).
+ * @param v - The value to check
+ * @returns True if the value is an integer >= 0
+ */
+export declare const nonNegativeInt: (v: unknown) => v is number;
+export { _string as string, _number as number, _boolean as boolean, _symbol as symbol, _bigint as bigint, _function as function, _object as object, _array as array, _undefined as undefined, _null as null, _nullish as nullish, _primitive as primitive, _date as date, _regexp as regexp, _error as error, _map as map, _set as set, _weakMap as weakMap, _weakSet as weakSet, _plainObject as plainObject, _iterable as iterable, _asyncIterable as asyncIterable, _record as record, _truthy as truthy, _falsy as falsy, _empty as empty, _nonEmpty as nonEmpty, _eq as eq, _oneOf as oneOf, _neq as neq, _notOneOf as notOneOf, _gt as gt, _gte as gte, _lt as lt, _lte as lte, _between as between, _betweenInclusive as betweenInclusive, _instanceOf as instanceOf, };

package/dist/types/Fit.d.ts

@@ -0,0 +1,2 @@
+export * from './Fit/__export__'
+export {}

package/dist/types/Lazy.d.ts

@@ -0,0 +1,2 @@
+export * from './Other/lazy'
+export {}

package/dist/types/Maps.d.ts

@@ -0,0 +1,2 @@
+export * from './Utils/Map'
+export {}

package/dist/types/Maybe/__export__.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './base';
+export * from './consumers';
+export * from './consumers-async';
+export * from './operators';
+export * from './operators-async';

package/dist/types/Maybe/base.d.ts

@@ -0,0 +1,62 @@
+import { Result } from '../Result/types';
+import { AsyncMaybe, Maybe } from './types';
+/**
+ * Constructs a `Some` value containing a non-null, non-undefined value.
+ * @param value - The value to wrap in a Maybe.
+ * @returns A Maybe containing the value.
+ */
+export declare const Some: <T>(value: T) => Maybe<T>;
+/**
+ * Constructs a `None` value representing absence of a value.
+ * @returns An empty Maybe (undefined).
+ */
+export declare const None: () => Maybe<never>;
+/**
+ * Type guard checking if a Maybe contains a value (`Some`).
+ * @param m - The Maybe to inspect.
+ * @returns True if the Maybe contains a value.
+ */
+export declare const isSome: <T>(m: Maybe<T>) => m is T;
+/**
+ * Type guard checking if a Maybe is empty (`None`).
+ * @param m - The Maybe to inspect.
+ * @returns True if the Maybe is null or undefined.
+ */
+export declare const isNone: (m: Maybe<unknown>) => m is null | undefined;
+/**
+ * Converts nullable value to a Maybe.
+ * @param value - Possibly null/undefined value.
+ * @returns Some(value) if value exists, None otherwise.
+ */
+export declare const fromNullable: <T>(value: T | null | undefined) => Maybe<T>;
+/**
+ * Converts falsy value to a Maybe.
+ * @param value - Possibly falsy value.
+ * @returns Some(value) if truthy, None otherwise.
+ */
+export declare const fromFalsy: <T>(value: T | null | undefined | false | 0 | "") => Maybe<T>;
+/**
+ * Converts Maybe to nullable value.
+ * @param maybe - Maybe value.
+ * @returns The value if Some, null if None.
+ */
+export declare const toNullable: <T>(maybe: Maybe<T>) => T | null;
+/**
+ * Converts Maybe to Result type.
+ * @param maybe - Maybe value.
+ * @param errorFn - Error generator for None case.
+ * @returns Ok(value) if Some, Err(errorFn()) if None.
+ */
+export declare const toResult: <T, E>(maybe: Maybe<T>, errorFn: () => E) => Result<T, E>;
+/**
+ * Converts Maybe to array representation.
+ * @param val - Maybe value.
+ * @returns Singleton array if Some, empty array if None.
+ */
+export declare const toArray: <T>(val: Maybe<T>) => T[];
+/**
+ * Transposes a Maybe containing a Promise to an AsyncMaybe.
+ * @param val - Maybe wrapping a Promise.
+ * @returns Promise resolving to Some(value) if input was Some, None otherwise.
+ */
+export declare function transpose<T>(val: Maybe<Promise<T>>): AsyncMaybe<T>;