/** * ***Brief*** * Converts `unknown` to `string`. * * ***Warning*** * Does not support circular references and circular objects will result in `[object Object]`. * * ***Example*** * ```ts * console.log(toString(42)); /// 42 * console.log(toString(true)); /// true * console.log(toString(null)); /// null * console.log(toString(undefined)); /// undefined * * console.log(toString("example")); /// example * * let object: { * color: string; * speed: { * min: number, * max: number * } * } = { * color: "Blue", * speed: { * min: 0, * max: 500 * } * }; * console.log(object); /// {"color":"Blue","speed":{"min":0,"max":500}} * * function foo(): void { * let x: string = 500; * return x; * } * console.log(foo); /// function foo() { * /// x = 500; * /// return x; * /// } * ``` */ declare function toString(unknown: unknown): string; /** * ***Brief*** * Creates a deep clone of the provided value using the structuredClone API. * * ***Example*** * ```ts * clone() * .resolve(e => { * if (e.code === "DOM.ERR_DATA_CLONE") { * /// ... * } * }) * .unlock(); * ``` */ declare function clone(value: T1): Result; type Result$0 = Result; type Fpv = { /** * ***Brief*** * Unwraps the wrapped value of type `T1`. * * ***Requirement*** * Does not `panic`. * * ***Example*** * ```ts * let unsafe: Unsafe = Unsafe(500n); * unsafe.unwrap(); * ``` */ unwrap(): bigint; decimals(): T1; representation(): bigint; eq(x: bigint): boolean; eq(x: Fpv): boolean; eq(x: Fpv.Compatible): boolean; lt(x: bigint): boolean; lt(x: Fpv): boolean; lt(x: Fpv.Compatible): boolean; gt(x: bigint): boolean; gt(x: Fpv): boolean; gt(x: Fpv.Compatible): boolean; lteq(x: bigint): boolean; lteq(x: Fpv): boolean; lteq(x: Fpv.Compatible): boolean; gteq(x: bigint): boolean; gteq(x: Fpv): boolean; gteq(x: Fpv.Compatible): boolean; add(x: bigint): Fpv; add(x: Fpv): Fpv; add(x: Fpv.Compatible): Fpv; sub(x: bigint): Fpv; sub(x: Fpv): Fpv; sub(x: Fpv.Compatible): Fpv; mul(x: bigint): Fpv; mul(x: Fpv): Fpv; mul(x: Fpv.Compatible): Fpv; div(x: bigint): Fpv.Result>; div(x: Fpv): Fpv.Result>; div(x: Fpv.Compatible): Fpv.Result>; pow(x: bigint): Fpv.Result>; pow(x: Fpv): Fpv.Result>; pow(x: Fpv.Compatible): Fpv.Result>; sqrt(): Fpv.Result>; convert(decimals: T2): Fpv.Result>; percentageOf(x: bigint): Fpv.Result>; percentageOf(x: Fpv): Fpv.Result>; percentageOf(x: Fpv.Compatible): Fpv.Result>; percentageGain(newValue: bigint): Fpv.Result>; percentageGain(newValue: Fpv): Fpv.Result>; percentageGain(newValue: Fpv.Compatible): Fpv.Result>; percentageLoss(newValue: bigint): Fpv.Result>; percentageLoss(newValue: Fpv): Fpv.Result>; percentageLoss(newValue: Fpv.Compatible): Fpv.Result>; percentageChange(newValue: bigint): Fpv.Result>; percentageChange(newValue: Fpv): Fpv.Result>; percentageChange(newValue: Fpv.Compatible): Fpv.Result>; sliceOf(percentage: bigint): Fpv.Result>; sliceOf(percentage: Fpv): Fpv.Result>; sliceOf(percentage: Fpv.Compatible): Fpv.Result>; addPercentage(percentage: bigint): Fpv.Result>; addPercentage(percentage: Fpv): Fpv.Result>; addPercentage(percentage: Fpv.Compatible): Fpv.Result>; subPercentage(percentage: bigint): Fpv.Result>; subPercentage(percentage: Fpv): Fpv.Result>; subPercentage(percentage: Fpv.Compatible): Fpv.Result>; toNumber(): number; }; /** * ***Warning*** * Does not support negative `decimals`. */ declare function Fpv(_v: Fpv.Compatible, _decimals: T1): Fpv.Result>; declare namespace Fpv { type Result = Result$0; type ErrorCode = "FPV.ERR_DIVISION_BY_ZERO" | "FPV.ERR_NEGATIVE_DECIMALS" | "FPV.ERR_NEGATIVE_EXPONENT" | "FPV.ERR_CANNOT_SQUARE_NAGATIVE"; type Compatible = Fpv | bigint; type Decimals = bigint; type Calculator = { unwrap(value: Compatible): bigint; eq(x: bigint, y: bigint): boolean; eq(x: Fpv, y: bigint): boolean; eq(x: bigint, y: Fpv): boolean; eq(x: Fpv, y: Fpv): boolean; eq(x: Compatible, y: Compatible): boolean; lt(x: bigint, y: bigint): boolean; lt(x: Fpv, y: bigint): boolean; lt(x: bigint, y: Fpv): boolean; lt(x: Fpv, y: Fpv): boolean; lt(x: Compatible, y: Compatible): boolean; gt(x: bigint, y: bigint): boolean; gt(x: Fpv, y: bigint): boolean; gt(x: bigint, y: Fpv): boolean; gt(x: Fpv, y: Fpv): boolean; gt(x: Compatible, y: Compatible): boolean; lteq(x: bigint, y: bigint): boolean; lteq(x: Fpv, y: bigint): boolean; lteq(x: bigint, y: Fpv): boolean; lteq(x: Fpv, y: Fpv): boolean; lteq(x: Compatible, y: Compatible): boolean; gteq(x: bigint, y: bigint): boolean; gteq(x: Fpv, y: bigint): boolean; gteq(x: bigint, y: Fpv): boolean; gteq(x: Fpv, y: Fpv): boolean; gteq(x: Compatible, y: Compatible): boolean; add(x: bigint, y: bigint, decimals: T1): Result>; add(x: Fpv, y: bigint, decimals: T1): Result>; add(x: bigint, y: Fpv, decimals: T1): Result>; add(x: Fpv, y: Fpv, decimals: T1): Result>; add(x: Compatible, y: Compatible, decimals: T1): Result>; sub(x: bigint, y: bigint, decimals: T1): Result>; sub(x: Fpv, y: bigint, decimals: T1): Result>; sub(x: bigint, y: Fpv, decimals: T1): Result>; sub(x: Fpv, y: Fpv, decimals: T1): Result>; sub(x: Compatible, y: Compatible, decimals: T1): Result>; mul(x: bigint, y: bigint, decimals: T1): Result>; mul(x: Fpv, y: bigint, decimals: T1): Result>; mul(x: bigint, y: Fpv, decimals: T1): Result>; mul(x: Fpv, y: Fpv, decimals: T1): Result>; mul(x: Compatible, y: Compatible, decimals: T1): Result>; div(x: bigint, y: bigint, decimals: T1): Result>; div(x: Fpv, y: bigint, decimals: T1): Result>; div(x: bigint, y: Fpv, decimals: T1): Result>; div(x: Fpv, y: Fpv, decimals: T1): Result>; div(x: Compatible, y: Compatible, decimals: T1): Result>; pow(x: bigint, y: bigint, decimals: T1): Result>; pow(x: Fpv, y: bigint, decimals: T1): Result>; pow(x: bigint, y: Fpv, decimals: T1): Result>; pow(x: Fpv, y: Fpv, decimals: T1): Result>; pow(x: Compatible, y: Compatible, decimals: T1): Result>; sqrt(x: bigint, decimals: T1): Result>; sqrt(x: Fpv, decimals: T1): Result>; sqrt(x: Compatible, decimals: T1): Result>; convert(x: bigint, oldDecimals: T1, newDecimals: T2): Result>; convert(x: Fpv, oldDecimals: T1, newDecimals: T2): Result>; convert(x: Compatible, oldDecimals: T1, newDecimals: T2): Result>; percentageOf(x: bigint, y: bigint, decimals: T1): Result>; percentageOf(x: Fpv, y: bigint, decimals: T1): Result>; percentageOf(x: bigint, y: Fpv, decimals: T1): Result>; percentageOf(x: Fpv, y: Fpv, decimals: T1): Result>; percentageOf(x: Compatible, y: Compatible, decimals: T1): Result>; percentageGain(oldValue: bigint, newValue: bigint, decimals: T1): Result>; percentageGain(oldValue: Fpv, newValue: bigint, decimals: T1): Result>; percentageGain(oldValue: bigint, newValue: Fpv, decimals: T1): Result>; percentageGain(oldValue: Fpv, newValue: Fpv, decimals: T1): Result>; percentageGain(oldValue: Compatible, newValue: Compatible, decimals: T1): Result>; percentageLoss(oldValue: bigint, newValue: bigint, decimals: T1): Result>; percentageLoss(oldValue: Fpv, newValue: bigint, decimals: T1): Result>; percentageLoss(oldValue: bigint, newValue: Fpv, decimals: T1): Result>; percentageLoss(oldValue: Fpv, newValue: Fpv, decimals: T1): Result>; percentageLoss(oldValue: Compatible, newValue: Compatible, decimals: T1): Result>; percentageChange(oldValue: bigint, newValue: bigint, decimals: T1): Result>; percentageChange(oldValue: Fpv, newValue: bigint, decimals: T1): Result>; percentageChange(oldValue: bigint, newValue: Fpv, decimals: T1): Result>; percentageChange(oldValue: Fpv, newValue: Fpv, decimals: T1): Result>; percentageChange(oldValue: Compatible, newValue: Compatible, decimals: T1): Result>; sliceOf(x: bigint, percentage: bigint, decimals: T1): Result>; sliceOf(x: Fpv, percentage: bigint, decimals: T1): Result>; sliceOf(x: bigint, percentage: Fpv, decimals: T1): Result>; sliceOf(x: Fpv, percentage: Fpv, decimals: T1): Result>; sliceOf(x: Compatible, percentage: Compatible, decimals: T1): Result>; addPercentage(x: bigint, percentage: bigint, decimals: T1): Result>; addPercentage(x: Fpv, percentage: bigint, decimals: T1): Result>; addPercentage(x: bigint, percentage: Fpv, decimals: T1): Result>; addPercentage(x: Fpv, percentage: Fpv, decimals: T1): Result>; addPercentage(x: Compatible, percentage: Compatible, decimals: T1): Result>; subPercentage(x: bigint, percentage: bigint, decimals: T1): Result>; subPercentage(x: Fpv, percentage: bigint, decimals: T1): Result>; subPercentage(x: bigint, percentage: Fpv, decimals: T1): Result>; subPercentage(x: Fpv, percentage: Fpv, decimals: T1): Result>; subPercentage(x: Compatible, percentage: Compatible, decimals: T1): Result>; }; const Calculator: Calculator; } type Array$0$1 = Array; /** * ***Brief*** * A type that represents an optional value, encapsulating either a value `Some` * or the absence of a value `None`. */ type Option = Some | None; declare namespace Option { type Async = Promise>; type Array = Array$0$1>; /** * ***Brief*** * Utility class for handling tasks within `Option`. */ type Handler = { /** * ***Brief*** * Wraps a value into an `Option`, turning `null` or `undefined` to `None`. * * ***Example*** * ```ts * let foo: string | undefined; * Option * .flag(foo) * .map(foo => { * /// ... * }); * ``` */ flag(value: T1 | null | undefined): Option; /** * ***Brief*** * Iterates through an array of `Option`, short-circuiting at the first `None`. * * ***Example*** * ```ts * let o0: Option<200n>; * let o1: Option<201n>; * let o2: Option<202n>; * let o: Option<[200n, 201n, 202n]> = Option.all([o0, o1, o2]); * ``` */ all>(...options: T1): Option>; /** * ***Brief*** * Iterates through an array of `Option`, short-circuiting at the first `Some`. * * ***Example*** * ```ts * let o0: Option<200n>; * let o1: Option<201n>; * let o2: Option<202n>; * let o: Option<200n | 201n | 202n> = Option.any([o0, o1, o2]); * ``` */ any>(...options: T1): Option[number]>; }; const Handler: Handler; } type Error = BrandedStruct<"Error"> & { /** * ***Brief*** * The unique identifier for this error. */ code: T1; /** * ***Brief*** * A human-readable message that explains the nature of the error. */ message: Option; /** * ***Brief*** * An optional value that can hold additional data or context related to the error. */ payload: Option; /** * ***Brief*** * The stack trace associated with the error. */ stack: string; }; /** * ***Brief*** * A custom error with an optional message and payload for strongly-typed errors. * * ***Note*** * This is a general-purpose error structure to manage domain-specific error codes and provide better context. */ declare function Error(_configuration: Error.Configuration): Error; declare function Error(_code: T1, _message?: string, _payload?: T2): Error; declare namespace Error { type Configuration = { code: T1; message?: string; payload?: T2; stack?: string; handler?: Error.Handler; }; type Task = Closure<[e: Error], void>; type Handler = { match(unknown: unknown): unknown is Error; match(unknown: unknown, task: Task): unknown is Error; match(unknown: unknown, code: T1): unknown is Error; match(unknown: unknown, code: T1, task: Task): unknown is Error; /** * ***Brief*** * `panic` throws an error with optional message and stack trace location. * * ***Example*** * ```ts * panic(Error("MATH.ERR_DIVISION_BY_ZERO")); * panic(Error({ * code: "MATH.ERR_DIVISION_BY_ZERO", * message: Some("Math: Cannot divide by zero."), * payload: None, * stack: StackTrace(...) * })); * panic("An unrecoverable error has occured."); * ``` */ panic(e: Error, handler?: Handler): never; panic(code: T1, at?: Function, handler?: Handler): never; localStackTrace(at: Function): Option; }; const Handler: Handler; } type Unsafe = Parsable & { inspect(): unknown; }; declare function Unsafe(_value: unknown): Unsafe; declare const flag: typeof Option.Handler.flag; declare const allO: typeof Option.Handler.all; declare const anyO: typeof Option.Handler.any; declare const allR: typeof Result.Handler.all; declare const anyR: typeof Result.Handler.any; declare const wrap: typeof Result.Handler.wrap; declare const wrapAsync: typeof Result.Handler.wrapAsync; type Some = Branded<"Some"> & { /** * ***Brief*** * `some` checks if the current instance is `Some`. * * ***Example*** * ```ts * let option: Option<200n>; * if (option.some()) { * let value: 200n = option.unlock(); * /// ... * } * ``` */ some(): this is Some; /** * ***Brief*** * `none` checks if the current instance is `None`. * * ***Example*** * ```ts * let option: Option<200n>; * if (option.none()) { * /// `Option` cannot `unlock` because it is `None`. * /// ... * } * ``` */ none(): this is None; /** * ***Brief*** * `expect` terminates with `panic` if the `Option` is `None`. * * ***Warning*** * Reserved for debugging or unrecoverable errors. * * ***Example*** * ```ts * let option: Option<200n>; * let status: 200n = option.expect("This is unexpected and unrecoverable."); * ``` */ expect(): T1; expect(__: unknown): T1; expect(__?: unknown): T1; /** * ***Brief*** * Unwraps the wrapped value of type `T1`. * * ***Requirement*** * Does not `panic`. * * ***Example*** * ```ts * let unsafe: Unsafe = Unsafe(500n); * unsafe.unwrap(); * ``` */ unwrap(): T1; /** * ***Brief*** * Retrieves the value of a `Some`, or falls back to the provided value if it’s `None`. * * ***Example*** * ```ts * let option: Option<200n> = None; * let status: 200n = option.unwrapOr(200n); * console.log(status); /// 200n. * ``` */ unwrapOr(__: unknown): T1; /** * ***Brief*** * Chains an task until the first `None` is encountered. * * ***Example*** * ```ts * let option: Option<200n> = None; * option * .and(value => { * /// Task is skipped because `Option` is `None`. * /// ... * return Some(value + 1n); * }) * .and(value => { * /// Task is skipped because `Option` is `None`. * /// ... * }); * ``` */ and(task: Closure<[T1], Option>): Option; /** * ***Brief*** * Transforms the `Some` value if present, but if this is already an `None`, it remains unchanged. * * ***Example*** * ```ts * let option0: Option<200n> = Some(200n); * let option1: Option<201n> = option.map(value => { * /// Task is run because `Option` is `Some`. * /// ... * return value + 1n; * }); * ``` */ map(task: Closure<[T1], T2>): Some; /** * ***Brief*** * Converts an `Option` to a `Result`. * * ***Example*** * ```ts * let option: Option<200n>; * let result: Result<200n, 404n> = option.toResult(404n); * ``` */ toResult(__: unknown): Ok; }; /** * ***Brief*** * The value within an `Option`. */ declare function Some(_value: T1): Some; declare namespace Some { type From> = T1 extends Some ? Some