@sapphire/result 3.0.0-pr-589.aa473f9.0 → 3.0.0-pr-935.7da5c8bb

package/dist/{index.d.ts → cjs/index.d.cts}

@@ -1,5 +1,9 @@
 type Awaitable<T> = PromiseLike<T> | T;
+type If<Value extends boolean, TrueResult, FalseResult> = Value extends true ? TrueResult : Value extends false ? FalseResult : TrueResult | FalseResult;
 
+declare const ValueProperty$1: unique symbol;
+declare const SuccessProperty: unique symbol;
+declare const UnwrapSafeProperty: unique symbol;
 /**
  * A type used to express computations that can fail, it can be used for returning and propagating errors. This is a
  * type union with the variants `Ok(T)`, representing success and containing a value, and `Err(E)`, representing error
@@ -10,7 +14,15 @@ type Awaitable<T> = PromiseLike<T> | T;
  *
  * @see {@link https://doc.rust-lang.org/std/result/index.html}
  */
-interface IResult<T, E> {
+declare class Result<T, E, const Success extends boolean = boolean> {
+    /**
+     * Branded value to ensure `Success` is typed correctly.
+     * @internal
+     */
+    protected __STATUS__: Success;
+    private readonly [ValueProperty$1];
+    private readonly [SuccessProperty];
+    private constructor();
     /**
      * Returns `true` if the result is `Ok`.
      *
@@ -27,7 +39,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.is_ok}
      */
-    isOk(): this is ResultOk<T>;
+    isOk(): this is Ok<T, E>;
     /**
      * Returns `true` if the result is `Ok` and the value inside of it matches a predicate.
      *
@@ -49,7 +61,8 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.is_ok_and}
      */
-    isOkAnd<R extends boolean>(cb: (value: T) => R): this is ResultOk<T> & R;
+    isOkAnd<R extends T>(cb: (value: T) => value is R): this is Ok<R, E>;
+    isOkAnd<R extends boolean>(cb: (value: T) => R): this is Ok<T, E> & R;
     /**
      * Returns `true` if the result is `Err`.
      *
@@ -66,7 +79,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err}
      */
-    isErr(): this is ResultErr<E>;
+    isErr(): this is Err<E, T>;
     /**
      * Returns `true` if the result is `Err` and the value inside of it matches a predicate.
      * @param cb The predicate.
@@ -89,7 +102,8 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err_and}
      */
-    isErrAnd<R extends boolean>(cb: (error: E) => R): this is ResultErr<E> & R;
+    isErrAnd<R extends E>(cb: (error: E) => error is R): this is Err<R, T>;
+    isErrAnd<R extends boolean>(cb: (error: E) => R): this is Err<E, T> & R;
     /**
      * Converts from `Result<T, E>` to `Option<T>`.
      *
@@ -108,7 +122,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.ok}
      */
-    ok(): Option<T>;
+    ok(): If<Success, Some<T>, None>;
     /**
      * Converts from `Result<T, E>` to `Option<E>`.
      *
@@ -127,7 +141,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.err}
      */
-    err(): Option<E>;
+    err(): If<Success, None, Some<E>>;
     /**
      * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value, leaving an `Err` value
      * untouched.
@@ -146,7 +160,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map}
      */
-    map<U>(cb: (value: T) => U): Result<U, E>;
+    map<OutputValue>(cb: (value: If<Success, T, never>) => OutputValue): Result<OutputValue, E, Success>;
     /**
      * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Ok` value, leaving an `Err` value
      * untouched.
@@ -176,7 +190,7 @@ interface IResult<T, E> {
      *
      * @note This is an extension not supported in Rust
      */
-    mapInto<IT, IE>(cb: (value: T) => Result<IT, IE>): Result<IT, E | IE>;
+    mapInto<OutputResult extends AnyResult>(cb: (value: If<Success, T, never>) => OutputResult): If<Success, OutputResult, Err<E>>;
     /**
      * Returns the provided default (if `Err`), or applies a function to the contained value (if `Ok`),
      *
@@ -198,7 +212,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or}
      */
-    mapOr<U>(defaultValue: U, cb: (value: T) => U): U;
+    mapOr<MappedOutputValue, DefaultOutputValue>(defaultValue: DefaultOutputValue, cb: (value: If<Success, T, never>) => MappedOutputValue): If<Success, MappedOutputValue, DefaultOutputValue>;
     /**
      * Maps a `Result<T, E>` to `U` by applying fallback function default to a contained `Err` value, or function `cb`
      * to a contained `Ok` value.
@@ -220,7 +234,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or_else}
      */
-    mapOrElse<U>(op: (error: E) => U, cb: (value: T) => U): U;
+    mapOrElse<OutputValue, OutputError>(op: (error: If<Success, never, E>) => OutputError, cb: (value: If<Success, T, never>) => OutputValue): If<Success, OutputValue, OutputError>;
     /**
      * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value, leaving an `Ok` value
      * untouched.
@@ -241,7 +255,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map_err}
      */
-    mapErr<F>(cb: (error: E) => F): Result<T, F>;
+    mapErr<OutputError>(cb: (error: If<Success, never, E>) => OutputError): Result<T, OutputError, Success>;
     /**
      * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value, leaving an `Ok` value
      * untouched.
@@ -270,7 +284,7 @@ interface IResult<T, E> {
      *
      * @note This is an extension not supported in Rust
      */
-    mapErrInto<IT, IE>(cb: (error: E) => Result<IT, IE>): Result<T | IT, IE>;
+    mapErrInto<OutputResult extends AnyResult>(cb: (error: If<Success, never, E>) => OutputResult): If<Success, Ok<T>, OutputResult>;
     /**
      * Calls the provided closure with a reference to the contained value (if `Ok`).
      * @param cb The predicate.
@@ -289,7 +303,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.inspect}
      */
-    inspect(cb: (value: T) => void): this;
+    inspect(cb: (value: T) => unknown): this;
     /**
      * Calls the provided closure with a reference to the contained value (if `Ok`) and awaits it.
      * @param cb The predicate.
@@ -308,7 +322,7 @@ interface IResult<T, E> {
      *
      * @note This is an extension not supported in Rust
      */
-    inspectAsync(cb: (value: T) => Awaitable<void>): Promise<this>;
+    inspectAsync(cb: (value: T) => Awaitable<unknown>): Promise<this>;
     /**
      * Calls the provided closure with a reference to the contained error (if `Err`).
      * @param cb The predicate.
@@ -327,7 +341,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.inspect_err}
      */
-    inspectErr(cb: (error: E) => void): this;
+    inspectErr(cb: (error: E) => unknown): this;
     /**
      * Calls the provided closure with a reference to the contained error (if `Err`) and awaits it.
      * @param cb The predicate.
@@ -346,7 +360,7 @@ interface IResult<T, E> {
      *
      * @note This is an extension not supported in Rust
      */
-    inspectErrAsync(cb: (error: E) => Awaitable<void>): Promise<this>;
+    inspectErrAsync(cb: (error: E) => Awaitable<unknown>): Promise<this>;
     /**
      * Returns an iterator over the possibly contained value.
      *
@@ -395,7 +409,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.expect}
      */
-    expect(message: string): T;
+    expect(message: string): If<Success, T, never>;
     /**
      * Returns the contained `Err` value.
      *
@@ -419,7 +433,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.expect_err}
      */
-    expectErr(message: string): E;
+    expectErr(message: string): If<Success, never, E>;
     /**
      * Returns the contained `Ok` value.
      *
@@ -428,6 +442,7 @@ interface IResult<T, E> {
      * @seealso {@link unwrapOrElse}
      * @seealso {@link unwrapErr}
      * @seealso {@link unwrapRaw}
+     * @seealso {@link unwrapSafe}
      *
      * @example
      * ```typescript
@@ -446,7 +461,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap}
      */
-    unwrap(): T;
+    unwrap(): If<Success, T, never>;
     /**
      * Returns the contained `Err` value.
      *
@@ -455,6 +470,7 @@ interface IResult<T, E> {
      * @seealso {@link unwrapOr}
      * @seealso {@link unwrapOrElse}
      * @seealso {@link unwrapRaw}
+     * @seealso {@link unwrapSafe}
      *
      * @example
      * ```typescript
@@ -473,7 +489,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_err}
      */
-    unwrapErr(): E;
+    unwrapErr(): If<Success, never, E>;
     /**
      * Returns the contained `Ok` value or the provided default.
      *
@@ -483,6 +499,7 @@ interface IResult<T, E> {
      * @seealso {@link unwrapOrElse}
      * @seealso {@link unwrapErr}
      * @seealso {@link unwrapRaw}
+     * @seealso {@link unwrapSafe}
      *
      * @param defaultValue The default value.
      *
@@ -499,13 +516,14 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_or}
      */
-    unwrapOr<V>(defaultValue: V): T | V;
+    unwrapOr<OutputValue>(defaultValue: OutputValue): If<Success, T, OutputValue>;
     /**
      * Returns the contained `Ok` value or computes it from a closure.
      * @seealso {@link unwrap}
      * @seealso {@link unwrapOr}
      * @seealso {@link unwrapErr}
      * @seealso {@link unwrapRaw}
+     * @seealso {@link unwrapSafe}
      *
      * @param op The predicate.
      *
@@ -519,7 +537,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_or_else}
      */
-    unwrapOrElse<V>(op: (error: E) => V): T | V;
+    unwrapOrElse<OutputValue>(op: (error: E) => OutputValue): If<Success, T, OutputValue>;
     /**
      * Returns the contained `Ok` value.
      *
@@ -528,6 +546,7 @@ interface IResult<T, E> {
      * @seealso {@link unwrapOr}
      * @seealso {@link unwrapOrElse}
      * @seealso {@link unwrapErr}
+     * @seealso {@link unwrapSafe}
      *
      * @example
      * ```typescript
@@ -544,7 +563,21 @@ interface IResult<T, E> {
      * });
      * ```
      */
-    unwrapRaw(): T | never;
+    unwrapRaw(): If<Success, T, never>;
+    /**
+     * Returns the contained `Ok` value or yelds the contained `Err` value.
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also {@link Result.safeTry}.
+     *
+     * If used outside of a `safeTry`'s' body, throws the contained error.
+     * @seealso {@link unwrap}
+     * @seealso {@link unwrapOr}
+     * @seealso {@link unwrapErr}
+     * @seealso {@link unwrapRaw}
+     * @seealso {@link unwrapSafe}
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_safe}
+     */
+    unwrapSafe(): Generator<Err<E, T>, T>;
     /**
      * Returns `result` if the result is `Ok`, otherwise returns the `Err` value of itself.
      * @param result The result to check.
@@ -570,7 +603,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.and}
      */
-    and<U>(result: Result<U, E>): Result<U, E>;
+    and<OutputResult extends AnyResult>(result: OutputResult): If<Success, OutputResult, Err<E>>;
     /**
      * Calls `cb` if the result is `Ok`, otherwise returns the `Err` value of self.
      *
@@ -590,7 +623,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.and_then}
      */
-    andThen<U>(cb: (value: T) => Result<U, E>): Result<U, E>;
+    andThen<OutputResult extends AnyResult>(cb: (value: T) => OutputResult): OutputResult;
     /**
      * Return `result` if the result is `Err`, otherwise returns the `Ok` value of self.
      *
@@ -625,7 +658,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.or}
      */
-    or<F>(result: Result<T, F>): Result<T, F>;
+    or<OutputResult extends AnyResult>(result: OutputResult): If<Success, Ok<T>, OutputResult>;
     /**
      * Calls `cb` if the result is `Err`, otherwise returns the `Ok` value of self.
      *
@@ -645,7 +678,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.or_else}
      */
-    orElse<F>(cb: (error: E) => Result<T, F>): Result<T, F>;
+    orElse<OutputResult extends AnyResult>(cb: (error: E) => OutputResult): If<Success, Ok<T>, OutputResult>;
     /**
      * Returns `true` if the result is an `Ok` and the given value strict equals it.
      * @param value The value to compare.
@@ -668,7 +701,8 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.contains}
      */
-    contains(value: T): boolean;
+    contains<const Value extends T>(this: Ok<T>, value: Value): this is Ok<Value>;
+    contains(this: Err<E>, value: T): false;
     /**
      * Returns `true` if the result is an `Err` and the given error strict equals it.
      * @param error The error to compare.
@@ -691,7 +725,8 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.contains_err}
      */
-    containsErr(error: E): boolean;
+    containsErr(this: Ok<T>, error: E): false;
+    containsErr<const Value extends E>(this: Err<E>, error: Value): this is Err<Value>;
     /**
      * Transposes a `Result` of an `Option` into an `Option` of a `Result`.
      *
@@ -706,7 +741,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.transpose}
      */
-    transpose<IT>(this: Result<Option<IT>, E>): Option<Result<IT, E>>;
+    transpose<InnerValue>(this: Result<Option<InnerValue>, E, Success>): If<Success, Option<Ok<InnerValue>>, Some<Err<E>>>;
     /**
      * Converts from `Result<Result<T, E>, E>` to `Result<T, E>`.
      *
@@ -728,7 +763,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.flatten}
      */
-    flatten<IT>(this: Result<Result<IT, E>, E>): Result<IT, E>;
+    flatten<InnerResult extends AnyResult>(this: Result<InnerResult, E, Success>): If<Success, InnerResult, Err<E>>;
     /**
      * Returns the `Ok` value if self is `Ok`, and the `Err` value if self is `Err`.
      *
@@ -745,7 +780,7 @@ interface IResult<T, E> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.into_ok_or_err}
      */
-    intoOkOrErr(): T | E;
+    intoOkOrErr(): If<Success, T, E>;
     /**
      * Returns a `Promise` object with the awaited value (if `Ok`) or the awaited error (if `Err`).
      *
@@ -757,14 +792,14 @@ interface IResult<T, E> {
      *
      * @note This is an extension not supported in Rust
      */
-    intoPromise(): Promise<Result<Awaited<T>, Awaited<E>>>;
+    intoPromise(): Promise<If<Success, Ok<Awaited<T>>, Err<Awaited<E>>>>;
     /**
      * Checks whether or not `other` equals with self.
      * @param other The other result to compare.
      *
      * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#tymethod.eq}
      */
-    eq(other: Result<T, E>): boolean;
+    eq<OtherValue extends T, OtherError extends E, OtherSuccess extends boolean>(other: Result<OtherValue, OtherError, OtherSuccess>): this is Result<OtherValue, OtherError, OtherSuccess>;
     /**
      * Checks whether or not `other` doesn't equal with self.
      * @param other The other result to compare.
@@ -794,9 +829,9 @@ interface IResult<T, E> {
      * ```
      */
     match<OkValue, ErrValue>(branches: {
-        ok(value: T): OkValue;
-        err(error: E): ErrValue;
-    }): OkValue | ErrValue;
+        ok(this: Ok<T>, value: If<Success, T, never>): OkValue;
+        err(this: Err<E>, error: If<Success, never, E>): ErrValue;
+    }): If<Success, OkValue, ErrValue>;
     /**
      * Returns an iterator over the possibly contained value.
      *
@@ -823,126 +858,218 @@ interface IResult<T, E> {
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.iter}
      */
     [Symbol.iterator](): Generator<T>;
-}
-
-declare class ResultOk<T> implements IResult<T, any> {
-    private readonly value;
-    constructor(value: T);
-    isOk(): this is ResultOk<T>;
-    isOkAnd<R extends boolean>(cb: (value: T) => R): R;
-    isErr(): false;
-    isErrAnd(cb?: (error: never) => boolean): false;
-    ok(): OptionSome<T>;
-    err(): OptionNone;
-    map<U>(cb: (value: T) => U): ResultOk<U>;
-    mapInto<R extends Result<any, any>>(cb: (value: T) => R): R;
-    mapOr<U>(_: U, cb: (value: T) => U): U;
-    mapOrElse<U>(_: (error: never) => U, cb: (value: T) => U): U;
-    mapErr(cb?: (error: never) => any): this;
-    mapErrInto(cb: (error: never) => Result<any, any>): this;
-    inspect(cb: (value: T) => void): this;
-    inspectAsync(cb: (value: T) => Awaitable<unknown>): Promise<this>;
-    inspectErr(cb?: (error: never) => void): this;
-    inspectErrAsync(cb?: (error: never) => Awaitable<unknown>): Promise<this>;
-    iter(): Generator<T>;
-    expect(message?: string): T;
-    expectErr(message: string): never;
-    unwrap(): T;
-    unwrapErr(): never;
-    unwrapOr(defaultValue: unknown): T;
-    unwrapOrElse(op: (error: any) => unknown): T;
-    unwrapRaw(): T;
-    and<R extends Result<any, any>>(result: R): R;
-    andThen<R extends Result<any, any>>(cb: (value: T) => R): R;
-    or(result: Result<T, any>): this;
-    orElse(cb: (error: never) => Result<T, any>): this;
-    contains(value: T): boolean;
-    containsErr(error?: unknown): false;
-    transpose(this: ResultOk<OptionNone>): OptionNone;
-    transpose<Inner>(this: ResultOk<OptionSome<Inner>>): OptionSome<ResultOk<Inner>>;
-    transpose<Inner>(this: ResultOk<Option<Inner>>): Option<ResultOk<Inner>>;
-    flatten<Inner extends Result<any, any>>(this: ResultOk<Inner>): Inner;
-    intoOkOrErr(): T;
-    intoPromise(): Promise<ResultOk<Awaited<T>>>;
-    eq(other: ResultErr<any>): false;
-    eq(other: Result<T, any>): boolean;
-    ne(other: ResultErr<any>): true;
-    ne(other: Result<T, any>): boolean;
-    match<OkValue, ErrValue>(branches: {
-        ok(value: T): OkValue;
-        err(error: never): ErrValue;
-    }): OkValue;
-    [Symbol.iterator](): Generator<T>;
-}
-/**
- * Creates an Ok with no value.
- * @return A successful Result.
- */
-declare function createOk(): ResultOk<unknown>;
-/**
- * Creates an Ok.
- * @typeparam T The result's type.
- * @param x Value to use.
- * @return A successful Result.
- */
-declare function createOk<T>(x: T): ResultOk<T>;
-
-declare class ResultError<E> extends Error {
-    readonly value: E;
-    constructor(message: string, value: E);
-    get name(): string;
-}
-
-/**
- * The union of the two variations of `Result`.
- * @typeparam T The result's type.
- * @typeparam E The error's type.
- */
-type Result<T, E> = Result.Ok<T> | Result.Err<E>;
-declare namespace Result {
-    type Resolvable<T, E> = T | Result<T, E>;
-    function is<T, E>(value: Result<T, E>): true;
-    function is(value: any): value is Result<unknown, unknown>;
+    get [Symbol.toStringTag](): If<Success, 'Ok', 'Err'>;
+    /**
+     * This function, in combination with `[$]`, is intended to emulate
+     * Rust's ? operator.
+     *
+     * @see {@link Result.safeTry}
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.safeTry}
+     */
+    get [UnwrapSafeProperty](): Generator<Err<E, T>, T>;
+    static ok<T = undefined, E = any>(this: void, value?: T): Ok<T, E>;
+    static err<E = undefined, T = any>(this: void, value?: E): Err<E, T>;
+    /**
+     * Checks if the `instance` object is an instance of `Result`, or if it is a `Result`-like object. This override
+     * exists to interoperate with other versions of this class, such as the one coming from another version of this
+     * library or from a different build.
+     *
+     * @param instance The instance to check.
+     * @returns Whether or not the instance is a `Result`.
+     *
+     * @example
+     * ```typescript
+     * import { Result } from '@sapphire/result';
+     * const { ok } = require('@sapphire/result');
+     *
+     * ok(2) instanceof Result; // true
+     * ```
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+    /**
+     * @deprecated Use {@link Result.isResult} instead.
+     *
+     * Checks if the `instance` object is an instance of `Result`, or if it is a `Result`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Result` or a `Result`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Result } from '@sapphire/result';
+     * const { ok } = require('@sapphire/result');
+     *
+     * Result.isResult(ok(2)); // true
+     * ```
+     */
+    static is(instance: unknown): instance is AnyResult;
+    /**
+     * Checks if the `instance` object is an instance of `Result`, or if it is a `Result`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Result` or a `Result`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Result } from '@sapphire/result';
+     * const { ok } = require('@sapphire/result');
+     *
+     * Result.isResult(ok(2)); // true
+     * ```
+     */
+    static isResult(instance: unknown): instance is AnyResult;
     /**
      * Creates a {@link Result} out of a callback.
+     *
      * @typeparam T The result's type.
      * @typeparam E The error's type.
      */
-    function from<T, E = unknown>(op: Resolvable<T, E> | (() => Resolvable<T, E>)): Result<T, E>;
+    static from<T, E = unknown>(this: void, op: ResultResolvable<T, E> | (() => ResultResolvable<T, E>)): Result<T, E>;
     /**
      * Creates a {@link Result} out of a promise or async callback.
+     *
      * @typeparam T The result's type.
      * @typeparam E The error's type.
      */
-    function fromAsync<T, E = unknown>(op: Awaitable<Resolvable<T, E>> | (() => Awaitable<Resolvable<T, E>>)): Promise<Result<T, E>>;
+    static fromAsync<T, E = unknown>(this: void, op: Awaitable<ResultResolvable<T, E>> | (() => Awaitable<ResultResolvable<T, E>>)): Promise<Result<T, E>>;
     /**
      * Creates an {@link Ok} that is the combination of all collected {@link Ok} values as an array, or the first
      * {@link Err} encountered.
+     *
      * @param results An array of {@link Result}s.
      * @returns A new {@link Result}.
      */
-    function all<T extends readonly Result<any, any>[]>(results: [...T]): Result<UnwrapOkArray<T>, UnwrapErrArray<T>[number]>;
+    static all<const Entries extends readonly AnyResult[]>(this: void, results: Entries): Result<UnwrapOkArray<Entries>, UnwrapErrArray<Entries>[number]>;
     /**
      * Returns the first encountered {@link Ok}, or an {@link Err} that is the combination of all collected error values.
+     *
      * @param results An array of {@link Result}s.
      * @returns A new {@link Result}.
      */
-    function any<T extends readonly Result<any, any>[]>(results: [...T]): Result<UnwrapOkArray<T>[number], UnwrapErrArray<T>>;
-    const err: typeof createErr;
-    const ok: typeof createOk;
-    type Err<E> = ResultErr<E>;
-    type Ok<T> = ResultOk<T>;
-    type UnwrapOk<T extends Result<any, any>> = T extends Ok<infer S> ? S : never;
-    type UnwrapErr<T extends Result<any, any>> = T extends Err<infer S> ? S : never;
-    type UnwrapOkArray<T extends readonly Result<any, any>[] | []> = {
+    static any<const Entries extends readonly AnyResult[]>(this: void, results: Entries): Result<UnwrapOk<Entries[number]>, UnwrapErrArray<Entries>>;
+    /**
+     * Evaluates the given generator to a Result returned or an Err yielded from it,
+     * whichever comes first.
+     *
+     * This function, in combination with `[$]`, is intended to emulate
+     * Rust's ? operator.
+     *
+     * @example
+     * ```typescript
+     *	const result = Result.safeTry(function* ({ $ }) {
+     *	  const first = yield* ok(1)[$];
+     *	  const second = yield* ok(1)[$];
+     *
+     *	  return ok(first + second);
+     *  });
+     *
+     *	result.match({
+     *	  ok: (value) => value, // 2
+     *	  err: (error) => {}
+     *	});
+     *```
+     *
+     * @example
+     * ```typescript
+     *	const resultAsync = Result.safeTry(async function* ({ $async }) {
+     *	  const first = yield* $async(Result.fromAsync(() => Promise.resolve(1)));
+     *	  const second = yield* ok(1)[$];
+     *
+     *	  return ok(first + second);
+     *  });
+     *
+     *	resultAsync.match({
+     *	  ok: (value) => value, // 2
+     *	  err: (error) => {}
+     *	});
+     * ```
+     * @param body - What is evaluated. In body, `yield* result[$]` works as
+     * Rust's `result?` expression.
+     * @returns The first occurence of either an yielded Err or a returned Result.
+     */
+    static safeTry<T, E>(body: (options: SafeTryOptions) => Generator<Err<E>, Result<T, E>>): Result<T, E>;
+    /**
+     * Evaluates the given generator to a Result returned or an Err yielded from it,
+     * whichever comes first.
+     *
+     * This function, in combination with `[$]`, is intended to emulate
+     * Rust's ? operator.
+     *
+     * @example
+     * ```typescript
+     *	const result = Result.safeTry(function* ({ $ }) {
+     *	  const first = yield* ok(1)[$];
+     *	  const second = yield* ok(1)[$];
+     *
+     *	  return ok(first + second);
+     *  });
+     *
+     *	result.match({
+     *	  ok: (value) => value, // 2
+     *	  err: (error) => {}
+     *	});
+     *```
+     *
+     * @example
+     * ```typescript
+     *	const resultAsync = Result.safeTry(async function* ({ $async }) {
+     *	  const first = yield* $async(Result.fromAsync(() => Promise.resolve(1)));
+     *	  const second = yield* ok(1)[$];
+     *
+     *	  return ok(first + second);
+     *  });
+     *
+     *	resultAsync.match({
+     *	  ok: (value) => value, // 2
+     *	  err: (error) => {}
+     *	});
+     * ```
+     * @param body - What is evaluated. In body, `yield* result[$]` works as
+     * Rust's `result?` expression.
+     * @returns The first occurence of either an yielded Err or a returned Result.
+     */
+    static safeTry<T, E>(body: (options: SafeTryOptions) => AsyncGenerator<Err<E>, Result<T, E>>): Promise<Result<T, E>>;
+}
+declare namespace Result {
+    type Ok<T, E = any> = Result<T, E, true>;
+    type Err<E, T = any> = Result<T, E, false>;
+    type Any = Result<any, any>;
+    type Resolvable<T, E = any, Success extends boolean = boolean> = T | Result<T, E, Success>;
+    type UnwrapOk<T extends AnyResult> = T extends Ok<infer S> ? S : never;
+    type UnwrapErr<T extends AnyResult> = T extends Err<infer S> ? S : never;
+    type UnwrapOkArray<T extends readonly AnyResult[] | []> = {
         -readonly [P in keyof T]: UnwrapOk<T[P]>;
     };
-    type UnwrapErrArray<T extends readonly Result<any, any>[] | []> = {
+    type UnwrapErrArray<T extends readonly AnyResult[] | []> = {
         -readonly [P in keyof T]: UnwrapErr<T[P]>;
     };
 }
+declare const ok: typeof Result.ok;
+declare const err: typeof Result.err;
+type ResultResolvable<T, E = any, Success extends boolean = boolean> = Result.Resolvable<T, E, Success>;
+type Ok<T, E = any> = Result.Ok<T, E>;
+type Err<E, T = any> = Result.Err<E, T>;
+type AnyResult = Result.Any;
+type UnwrapOk<T extends AnyResult> = Result.UnwrapOk<T>;
+type UnwrapErr<T extends AnyResult> = Result.UnwrapErr<T>;
+type UnwrapOkArray<T extends readonly AnyResult[] | []> = Result.UnwrapOkArray<T>;
+type UnwrapErrArray<T extends readonly AnyResult[] | []> = Result.UnwrapErrArray<T>;
+interface SafeTryOptions {
+    $: typeof UnwrapSafeProperty;
+    $async: <T, E>(result: Promise<Result<T, E>>) => AsyncGenerator<Err<E>, T>;
+}
 
-interface IOption<T> {
+declare const ValueProperty: unique symbol;
+declare const ExistsProperty: unique symbol;
+declare class Option<T, Exists extends boolean = boolean> {
+    /**
+     * Branded value to ensure `Success` is typed correctly.
+     * @internal
+     */
+    protected __STATUS__: Exists;
+    private readonly [ValueProperty];
+    private readonly [ExistsProperty];
+    private constructor();
     /**
      * Returns `true` if the option is a `Some` value.
      *
@@ -959,7 +1086,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some}
      */
-    isSome(): this is OptionSome<T>;
+    isSome(): this is Some<T>;
     /**
      * Returns `true` if the option is a `Some` and the value inside of it matches a predicate.
      * @param cb The predicate.
@@ -982,7 +1109,8 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some_and}
      */
-    isSomeAnd(cb: (value: T) => boolean): boolean;
+    isSomeAnd<R extends T>(cb: (value: T) => value is R): this is Some<R>;
+    isSomeAnd<R extends boolean>(cb: (value: T) => R): this is Some<R> & R;
     /**
      * Returns `true` if the option is a `None` value.
      *
@@ -999,7 +1127,30 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.is_none}
      */
-    isNone(): this is OptionNone;
+    isNone(): this is None;
+    /**
+     * Returns `true` if the option is a `None` value or the value inside of it matches a predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * assert.equal(x.isNoneOr((x) => x > 1), true);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(0);
+     * assert.equal(x.isNoneOr((x) => x > 1), false);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * assert.equal(x.isNoneOr((x) => x > 1), true);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.is_none_or}
+     */
+    isNoneOr<R extends T>(cb: (value: T) => value is R): this is None | Some<R>;
+    isNoneOr<R extends boolean>(cb: (value: T) => R): If<Exists, R, true>;
     /**
      * Returns the contained `Some` value.
      * @param message The message for the error.
@@ -1021,7 +1172,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.expect}
      */
-    expect(message: string): T;
+    expect(message: string): If<Exists, T, never>;
     /**
      * Returns the contained `Some` value.
      *
@@ -1045,7 +1196,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap}
      */
-    unwrap(): T;
+    unwrap(): If<Exists, T, never>;
     /**
      * Returns the contained `Some` value or a provided default.
      *
@@ -1063,7 +1214,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or}
      */
-    unwrapOr<V>(defaultValue: V): T | V;
+    unwrapOr<OutputValue>(defaultValue: OutputValue): If<Exists, T, OutputValue>;
     /**
      * Returns the contained Some value or computes it from a closure.
      *
@@ -1078,7 +1229,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or_else}
      */
-    unwrapOrElse<V>(cb: () => V): T | V;
+    unwrapOrElse<OutputValue>(cb: () => OutputValue): If<Exists, T, OutputValue>;
     /**
      * Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.
      * @param cb The predicate.
@@ -1093,7 +1244,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.map}
      */
-    map<U>(cb: (value: T) => U): Option<U>;
+    map<U>(cb: (value: T) => U): Option<U, Exists>;
     /**
      * Maps a `Some<T>` to the returned `Option<U>` by applying a function to a contained value, leaving `None`
      * untouched.
@@ -1116,7 +1267,7 @@ interface IOption<T> {
      *
      * @note This is an extension not supported in Rust
      */
-    mapInto<Inner>(cb: (value: T) => Option<Inner>): Option<Inner>;
+    mapInto<OutputOption extends AnyOption>(cb: (value: T) => OutputOption): OutputOption;
     /**
      * Returns the provided default result (if none), or applies a function to the contained value (if any).
      *
@@ -1138,7 +1289,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or}
      */
-    mapOr<U>(defaultValue: U, cb: (value: T) => U): U;
+    mapOr<MappedOutputValue, DefaultOutputValue>(defaultValue: DefaultOutputValue, cb: (value: T) => MappedOutputValue): If<Exists, MappedOutputValue, DefaultOutputValue>;
     /**
      * Computes a default function result (if none), or applies a different function to the contained value (if any).
      * @param defaultValue The default value.
@@ -1157,7 +1308,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or_else}
      */
-    mapOrElse<U>(defaultValue: () => U, cb: (value: T) => U): U;
+    mapOrElse<OutputValue, OutputNone>(defaultValue: () => OutputNone, cb: (value: T) => OutputValue): If<Exists, OutputValue, OutputNone>;
     /**
      * Maps a `None` to the returned `Option<U>` by applying a function to a contained value, leaving `Some<T>`
      * untouched.
@@ -1180,7 +1331,7 @@ interface IOption<T> {
      *
      * @note This is an extension not supported in Rust
      */
-    mapNoneInto<Inner>(cb: () => Option<Inner>): Option<T | Inner>;
+    mapNoneInto<OutputOption extends AnyOption>(cb: () => OutputOption): If<Exists, Some<T>, OutputOption>;
     /**
      * Calls the provided closure with a reference to the contained value (if `Some`).
      * @param cb The predicate.
@@ -1218,7 +1369,7 @@ interface IOption<T> {
      *
      * @note This is an extension not supported in Rust
      */
-    inspectAsync(cb: (value: T) => Awaitable<void>): Promise<this>;
+    inspectAsync(cb: (value: T) => Awaitable<unknown>): Promise<this>;
     /**
      * Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err)`.
      *
@@ -1239,7 +1390,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or}
      */
-    okOr<E>(err: E): Result<T, E>;
+    okOr<ErrorValue>(error: ErrorValue): If<Exists, Ok<T>, Err<ErrorValue>>;
     /**
      * Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err())`.
      * @param cb The error to be used.
@@ -1257,7 +1408,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or_else}
      */
-    okOrElse<E>(cb: () => E): Result<T, E>;
+    okOrElse<ErrorValue>(cb: () => ErrorValue): If<Exists, Ok<T>, Err<ErrorValue>>;
     /**
      * Returns an iterator over the possibly contained value.
      *
@@ -1315,7 +1466,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.and}
      */
-    and<U>(option: Option<U>): Option<U>;
+    and<OutputOption extends AnyOption>(option: OutputOption): If<Exists, OutputOption, None>;
     /**
      * Calls `cb` if the result is `Ok`, otherwise returns the `Err` value of self.
      *
@@ -1335,7 +1486,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.and_then}
      */
-    andThen<U>(cb: (value: T) => Option<U>): Option<U>;
+    andThen<OutputOption extends AnyOption>(cb: (value: T) => OutputOption): OutputOption;
     /**
      * Returns the option if it contains a value, otherwise returns `option`.
      * @param option The option.
@@ -1367,7 +1518,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.or}
      */
-    or(option: Option<T>): Option<T>;
+    or<OutputOption extends AnyOption>(option: OutputOption): If<Exists, Some<T>, OutputOption>;
     /**
      * Calls `cb` if the result is `Ok`, otherwise returns the `Err` value of self.
      *
@@ -1386,7 +1537,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.or_else}
      */
-    orElse(cb: () => Option<T>): Option<T>;
+    orElse<OutputOption extends AnyOption>(cb: () => OutputOption): If<Exists, Some<T>, OutputOption>;
     /**
      * Returns `Some` if exactly one of self or `option` is `Some`, otherwise returns `None`.
      * @param option The option to compare.
@@ -1418,7 +1569,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.xor}
      */
-    xor(option: Option<T>): Option<T>;
+    xor<OtherValue, OtherExists extends boolean>(option: Option<OtherValue, OtherExists>): If<Exists, If<OtherExists, None, Some<T>>, Option<OtherValue, OtherExists>>;
     /**
      * Returns None if the option is None, otherwise calls `predicate` with the wrapped value and returns:
      *
@@ -1439,6 +1590,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.filter}
      */
+    filter<R extends T>(predicate: (value: T) => value is R): Option<R>;
     filter(predicate: (value: T) => boolean): Option<T>;
     /**
      * Returns `true` if the option is a `Some` value containing the given value.
@@ -1462,7 +1614,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.contains}
      */
-    contains(value: T): boolean;
+    contains<const Value extends T>(value: If<Exists, Value, unknown>): this is Some<Value>;
     /**
      * Zips self with another `Option`.
      *
@@ -1481,7 +1633,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.zip}
      */
-    zip<U>(other: Option<U>): Option<[T, U]>;
+    zip<OtherValue, OtherExists extends boolean>(other: Option<OtherValue, OtherExists>): Option<[T, OtherValue], If<Exists, OtherExists, false>>;
     /**
      * Zips self and another `Option` with function `f`.
      *
@@ -1510,11 +1662,11 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.zip_with}
      */
-    zipWith<U, R>(other: Option<U>, f: (s: T, o: U) => R): Option<R>;
+    zipWith<OtherValue, OtherExists extends boolean, ReturnValue>(other: Option<OtherValue, OtherExists>, f: (value0: T, value1: OtherValue) => ReturnValue): Option<ReturnValue, If<Exists, OtherExists, false>>;
     /**
      * Unzips an option containing a tuple of two options.
      *
-     * If self is `Some((a, b))` this method returns `[Some(a), Some(b)]`. Otherwise, `[None, None]` is returned.
+     * If self is `Some([a, b])` this method returns `[Some(a), Some(b)]`. Otherwise, `[None, None]` is returned.
      *
      * @example
      * ```typescript
@@ -1529,7 +1681,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unzip}
      */
-    unzip<Inner, U>(this: Option<readonly [Inner, U]>): [Option<Inner>, Option<U>];
+    unzip<Value0, Value1, Exists extends boolean>(this: Option<readonly [Value0, Value1], Exists>): [Option<Value0, Exists>, Option<Value1, Exists>];
     /**
      * Transposes an `Option` of a `Result` into a `Result` of an `Option`.
      *
@@ -1544,7 +1696,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.transpose}
      */
-    transpose<IT, E>(this: Option<Result<IT, E>>): Result<Option<IT>, E>;
+    transpose<ResultValue, ResultError, ResultSuccess extends boolean, Exists extends boolean>(this: Option<Result<ResultValue, ResultError, ResultSuccess>, Exists>): If<Exists, Result<Some<ResultValue>, ResultError, ResultSuccess>, Ok<None>>;
     /**
      * Converts from `Result<Result<T, E>, E>` to `Result<T, E>`.
      *
@@ -1566,7 +1718,7 @@ interface IOption<T> {
      *
      * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.flatten}
      */
-    flatten<IT>(this: Option<Option<IT>>): Option<IT>;
+    flatten<InnerOption extends AnyOption, Exists extends boolean>(this: Option<InnerOption, Exists>): If<Exists, InnerOption, None>;
     /**
      * Returns a `Promise` object with the awaited value (if `Some`).
      *
@@ -1578,21 +1730,21 @@ interface IOption<T> {
      *
      * @note This is an extension not supported in Rust
      */
-    intoPromise(): Promise<Option<Awaited<T>>>;
+    intoPromise(): Promise<Option<Awaited<T>, Exists>>;
     /**
      * Checks whether or not `other` equals with self.
      * @param other The other option to compare.
      *
      * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#tymethod.eq}
      */
-    eq(other: Option<T>): boolean;
+    eq<OtherValue extends T, OtherExists extends boolean>(other: Option<OtherValue, OtherExists>): this is Option<OtherValue, OtherExists>;
     /**
      * Checks whether or not `other` doesn't equal with self.
      * @param other The other option to compare.
      *
      * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#method.ne}
      */
-    ne(other: Option<T>): boolean;
+    ne(other: Option<T, boolean>): boolean;
     /**
      * Runs `ok` function if self is `Ok`, otherwise runs `err` function.
      * @param branches The branches to match.
@@ -1615,9 +1767,9 @@ interface IOption<T> {
      * ```
      */
     match<SomeValue, NoneValue>(branches: {
-        some(value: T): SomeValue;
-        none(): NoneValue;
-    }): SomeValue | NoneValue;
+        some(this: Some<T>, value: T): SomeValue;
+        none(this: None): NoneValue;
+    }): If<Exists, SomeValue, NoneValue>;
     /**
      * Returns an iterator over the possibly contained value.
      *
@@ -1644,214 +1796,115 @@ interface IOption<T> {
      * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.iter}
      */
     [Symbol.iterator](): Generator<T>;
-}
-
-declare class OptionSome<T> implements IOption<T> {
-    private readonly value;
-    constructor(value: T);
-    isSome(): this is OptionSome<T>;
-    isSomeAnd<R extends boolean>(cb: (value: T) => R): R;
-    isNone(): false;
-    expect(message: string): T;
-    unwrap(): T;
-    unwrapOr(defaultValue: unknown): T;
-    unwrapOrElse(cb: () => unknown): T;
-    map<U>(cb: (value: T) => U): OptionSome<U>;
-    mapInto<R extends Option<any>>(cb: (value: T) => R): R;
-    mapOr<U>(_: U, cb: (value: T) => U): U;
-    mapOrElse<U>(_: () => U, cb: (value: T) => U): U;
-    mapNoneInto(cb: () => Option<any>): this;
-    inspect(cb: (value: T) => void): this;
-    inspectAsync(cb: (value: T) => Awaitable<unknown>): Promise<this>;
-    okOr(err?: any): ResultOk<T>;
-    okOrElse(cb: () => any): ResultOk<T>;
-    iter(): Generator<T>;
-    and<R extends Option<any>>(option: R): R;
-    andThen<R extends Option<any>>(cb: (value: T) => R): R;
-    or(option: Option<any>): this;
-    orElse(cb?: () => Option<any>): this;
-    xor(option: OptionSome<T>): OptionNone;
-    xor(option: OptionNone): this;
-    xor(option: Option<T>): this | OptionNone;
-    filter(predicate: (value: T) => true): this;
-    filter(predicate: (value: T) => false): OptionNone;
-    filter(predicate: (value: T) => boolean): this | OptionNone;
-    contains(value: T): boolean;
-    zip(other: OptionNone): OptionNone;
-    zip<U>(other: OptionSome<U>): OptionSome<[T, U]>;
-    zip<U>(other: Option<U>): Option<[T, U]>;
-    zipWith<U, R>(other: OptionNone, f: (s: T, o: U) => R): OptionNone;
-    zipWith<U, R>(other: OptionSome<U>, f: (s: T, o: U) => R): OptionSome<R>;
-    zipWith<U, R>(other: Option<U>, f: (s: T, o: U) => R): Option<R>;
-    unzip<I, U>(this: OptionSome<readonly [I, U]>): [OptionSome<I>, OptionSome<U>];
-    transpose<Inner>(this: OptionSome<ResultOk<Inner>>): ResultOk<OptionSome<Inner>>;
-    transpose<Inner>(this: OptionSome<ResultErr<Inner>>): ResultErr<OptionSome<Inner>>;
-    transpose<IT, E>(this: OptionSome<Result<IT, E>>): Result<OptionSome<IT>, E>;
-    flatten<Inner extends Option<any>>(this: OptionSome<Inner>): Inner;
-    intoPromise(): Promise<OptionSome<Awaited<T>>>;
-    eq(other: OptionNone): false;
-    eq(other: Option<T>): boolean;
-    ne(other: OptionNone): true;
-    ne(other: Option<T>): boolean;
-    match<SomeValue, NoneValue>(branches: {
-        some(value: T): SomeValue;
-        none(): NoneValue;
-    }): SomeValue;
-    [Symbol.iterator](): Generator<T>;
-}
-declare function createSome<T>(value: T): OptionSome<T>;
-
-declare class ResultErr<E> implements IResult<any, E> {
-    private readonly error;
-    constructor(error: E);
-    isOk(): false;
-    isOkAnd(cb?: (value: never) => boolean): false;
-    isErr(): this is ResultErr<E>;
-    isErrAnd(cb: (error: E) => boolean): boolean;
-    ok(): OptionNone;
-    err(): OptionSome<E>;
-    map(cb?: (value: never) => unknown): this;
-    mapInto(cb: (value: never) => Result<any, any>): this;
-    mapOr<U>(defaultValue: U, cb?: (value: never) => U): U;
-    mapOrElse<U>(op: (error: E) => U, cb?: (value: never) => U): U;
-    mapErr<F>(cb: (error: E) => F): ResultErr<F>;
-    mapErrInto<R extends Result<any, any>>(cb: (error: E) => R): R;
-    inspect(cb?: (value: never) => void): this;
-    inspectAsync(cb?: (value: never) => Awaitable<unknown>): Promise<this>;
-    inspectErr(cb: (error: E) => void): this;
-    inspectErrAsync(cb: (error: E) => Awaitable<unknown>): Promise<this>;
-    iter(): Generator<never>;
-    expect(message: string): never;
-    expectErr(message?: string): E;
-    unwrap(): never;
-    unwrapErr(): E;
-    unwrapOr<T>(defaultValue: T): T;
-    unwrapOrElse<T>(op: (error: E) => T): T;
-    unwrapRaw(): never;
-    and(result?: Result<any, E>): this;
-    andThen(cb?: (value: never) => Result<any, E>): this;
-    or<R extends Result<any, any>>(result: R): R;
-    orElse<R extends Result<any, any>>(cb: (error: E) => R): R;
-    contains(value?: any): false;
-    containsErr(error: E): boolean;
-    transpose(): OptionSome<this>;
-    flatten(): this;
-    intoOkOrErr(): E;
-    intoPromise(): Promise<ResultErr<Awaited<E>>>;
-    eq(other: ResultOk<any>): false;
-    eq(other: Result<any, E>): boolean;
-    ne(other: ResultOk<any>): true;
-    ne(other: Result<any, E>): boolean;
-    match<OkValue, ErrValue>(branches: {
-        ok(value: never): OkValue;
-        err(error: E): ErrValue;
-    }): ErrValue;
-    [Symbol.iterator](): Generator<never>;
-}
-/**
- * Creates an Err with no error.
- * @return An erroneous Result.
- */
-declare function createErr(): ResultErr<unknown>;
-/**
- * Creates an Err.
- * @typeparam E The error's type.
- * @param x Value to use.
- * @return An erroneous Result.
- */
-declare function createErr<E>(x: E): ResultErr<E>;
-
-declare class OptionNone implements IOption<any> {
-    isSome(): false;
-    isSomeAnd(cb?: (value: never) => boolean): false;
-    isNone(): this is OptionNone;
-    expect(message: string): never;
-    unwrap(): never;
-    unwrapOr<R>(defaultValue: R): R;
-    unwrapOrElse<R>(cb: () => R): R;
-    map(cb: (value: never) => any): this;
-    mapInto(cb: (value: never) => Option<any>): this;
-    mapOr<R>(defaultValue: R, cb?: (value: never) => R): R;
-    mapOrElse<R>(defaultValue: () => R, cb?: (value: never) => R): R;
-    mapNoneInto<R extends Option<any>>(cb: () => R): R;
-    inspect(cb?: (value: never) => void): this;
-    inspectAsync(cb?: (value: never) => Awaitable<unknown>): Promise<this>;
-    okOr<E>(error: E): ResultErr<E>;
-    okOrElse<E>(cb: () => E): ResultErr<E>;
-    iter(): Generator<never>;
-    and(option: Option<any>): this;
-    andThen(cb: (value: never) => Option<any>): this;
-    or<R extends Option<any>>(option: R): R;
-    orElse<R extends Option<any>>(cb: () => R): R;
-    xor<T>(option: OptionNone): OptionNone;
-    xor<T>(option: OptionSome<T>): OptionSome<T>;
-    xor<T>(option: Option<T>): OptionSome<T> | OptionNone;
-    filter(predicate: (value: never) => boolean): OptionNone;
-    contains(value?: any): false;
-    zip(other: Option<any>): OptionNone;
-    zipWith(other: Option<any>, f: (s: never, o: never) => any): OptionNone;
-    unzip(): [OptionNone, OptionNone];
-    transpose(): ResultOk<OptionNone>;
-    flatten(): OptionNone;
-    intoPromise(): Promise<OptionNone>;
-    eq(other: OptionNone): true;
-    eq(other: OptionSome<any>): false;
-    eq(other: Option<any>): boolean;
-    ne(other: OptionNone): false;
-    ne(other: OptionSome<any>): true;
-    ne(other: Option<any>): boolean;
-    match<SomeValue, NoneValue>(branches: {
-        some(value: never): SomeValue;
-        none(): NoneValue;
-    }): NoneValue;
-    [Symbol.iterator](): Generator<never>;
-}
-declare const createNone: OptionNone;
-
-declare class OptionError extends Error {
-    get name(): string;
-}
-
-/**
- * The union of the two variations of `Option`.
- * @typeparam T The value's type.
- */
-type Option<T> = Option.Some<T> | Option.None;
-declare namespace Option {
-    type Resolvable<T> = T | null | undefined | Option<T>;
-    function is<T>(value: Option<T>): true;
-    function is(value: any): value is Option<unknown>;
+    get [Symbol.toStringTag](): If<Exists, 'Some', 'None'>;
+    static readonly none: Option<any, false>;
+    static some<T = undefined>(this: void, value?: T): Some<T>;
     /**
-     * Creates an {@link Option} out of a value or callback.
+     * Checks if the `instance` object is an instance of `Option`, or if it is a `Option`-like object. This override
+     * exists to interoperate with other versions of this class, such as the one coming from another version of this
+     * library or from a different build.
+     *
+     * @param instance The instance to check.
+     * @returns Whether or not the instance is a `Option`.
+     *
+     * @example
+     * ```typescript
+     * import { Option } from '@sapphire/result';
+     * const { some } = require('@sapphire/result');
+     *
+     * some(2) instanceof Option; // true
+     * ```
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+    /**
+     * @deprecated Use {@link Option.isOption} instead.
+     *
+     * Checks if the `instance` object is an instance of `Option`, or if it is a `Option`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Option` or a `Option`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Option } from '@sapphire/result';
+     * const { some } = require('@sapphire/result');
+     *
+     * Option.isOption(some(2)); // true
+     * ```
+     */
+    static is(instance: unknown): instance is AnyOption;
+    /**
+     * Checks if the `instance` object is an instance of `Option`, or if it is a `Option`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Option` or a `Option`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Option } from '@sapphire/result';
+     * const { some } = require('@sapphire/result');
+     *
+     * Option.isOption(some(2)); // true
+     * ```
+     */
+    static isOption(instance: unknown): instance is AnyOption;
+    /**
+     * Creates a {@link Result} out of a callback.
+     *
      * @typeparam T The result's type.
+     * @typeparam E The error's type.
      */
-    function from<T>(op: Resolvable<T> | (() => Resolvable<T>)): Option<T>;
+    static from<T>(this: void, op: OptionResolvable<T> | (() => OptionResolvable<T>)): Option<T>;
     /**
-     * Creates an {@link Option} out of a value or callback.
+     * Creates a {@link Result} out of a promise or async callback.
+     *
      * @typeparam T The result's type.
+     * @typeparam E The error's type.
      */
-    function fromAsync<T>(op: Awaitable<Resolvable<T>> | (() => Awaitable<Resolvable<T>>)): Promise<Option<T>>;
+    static fromAsync<T>(this: void, op: Awaitable<OptionResolvable<T>> | (() => Awaitable<OptionResolvable<T>>)): Promise<Option<T>>;
     /**
-     * Creates a {@link Some} that is the combination of all collected {@link Some} values as an array, or the first
-     * {@link None} encountered.
-     * @param options An array of {@link Option}s.
-     * @returns A new {@link Option}.
+     * Creates an {@link Ok} that is the combination of all collected {@link Ok} values as an array, or the first
+     * {@link Err} encountered.
+     *
+     * @param results An array of {@link Result}s.
+     * @returns A new {@link Result}.
      */
-    function all<T extends readonly Option<any>[]>(options: [...T]): Option<UnwrapSomeArray<T>>;
+    static all<const Entries extends readonly AnyOption[]>(this: void, results: Entries): Option<UnwrapSomeArray<Entries>>;
     /**
      * Returns the first encountered {@link Some}, or a {@link None} if none was found.
+     *
      * @param options An array of {@link Option}s.
      * @returns A new {@link Option}.
      */
-    function any<T extends readonly Option<any>[]>(options: [...T]): Option<UnwrapSomeArray<T>[number]>;
-    const none: OptionNone;
-    const some: typeof createSome;
-    type Some<T> = OptionSome<T>;
-    type None = OptionNone;
-    type UnwrapSome<T extends Option<any>> = T extends Some<infer S> ? S : never;
-    type UnwrapSomeArray<T extends readonly Option<any>[] | []> = {
+    static any<const Entries extends readonly AnyOption[]>(this: void, results: Entries): Option<UnwrapSome<Entries[number]>>;
+}
+declare namespace Option {
+    type Some<T> = Option<T, true>;
+    type None<T = any> = Option<T, false>;
+    type Any = Option<any>;
+    type Resolvable<T, Exists extends boolean = boolean> = T | null | undefined | Option<T, Exists>;
+    type UnwrapSome<T extends AnyOption> = T extends Some<infer S> ? S : never;
+    type UnwrapSomeArray<T extends readonly AnyOption[] | []> = {
         -readonly [P in keyof T]: UnwrapSome<T[P]>;
     };
 }
+declare const some: typeof Option.some;
+declare const none: Option<any, false>;
+type OptionResolvable<T, Exists extends boolean = boolean> = Option.Resolvable<T, Exists>;
+type Some<T> = Option.Some<T>;
+type None<T = any> = Option.None<T>;
+type AnyOption = Option.Any;
+type UnwrapSome<T extends AnyOption> = Option.UnwrapSome<T>;
+type UnwrapSomeArray<T extends readonly AnyOption[] | []> = Option.UnwrapSomeArray<T>;
+
+declare class OptionError extends Error {
+    get name(): string;
+}
+
+declare class ResultError<E> extends Error {
+    readonly value: E;
+    constructor(message: string, value: E);
+    get name(): string;
+}
 
-export { ResultErr as Err, IOption, IResult, OptionNone as None, ResultOk as Ok, Option, OptionError, Result, ResultError, OptionSome as Some, createErr as err, createNone as none, createOk as ok, createSome as some };
+export { type AnyOption, type AnyResult, type Err, type None, type Ok, Option, OptionError, type OptionResolvable, Result, ResultError, type ResultResolvable, type SafeTryOptions, type Some, type UnwrapErr, type UnwrapErrArray, type UnwrapOk, type UnwrapOkArray, type UnwrapSome, type UnwrapSomeArray, err, none, ok, some };