//#region src/option.d.ts
/**
 * Represents some value of type `T`.
 */
type SomeOption<T> = {
  readonly value: T;
} & OptionMethods<T>;
/**
 * Represents the absence of a value of type `T`.
 */
type NoneOption<T> = {
  readonly value: null;
} & OptionMethods<T>;
/**
 * Type `Option` represents an optional value: every `Option` is either `Some` and contains a value, or `None`, and does not.
 *
 * `Option`s are commonly paired with pattern matching to query the presence of a value and take action, always accounting for the `None` case.
 *
 * @example
 * ```typescript
 * const x: Option<number> = Some(5);
 * const y: Option<number> = None();
 *
 * if (x.isSome() && y.isSome()) console.log(x.value + y.value);
 * else console.log('One of the options is None');
 * ```
 *
 * @template T Contains the type of the value that may be present in the `Option`.
 */
type Option<T> = SomeOption<T> | NoneOption<T>;
interface OptionMethods<T> {
  /**
   * Returns `true` if the option is a `Some` value.
   */
  isSome(): this is SomeOption<T>;
  /**
   * Returns `true` if the option is a `Some` and the value inside of it matches a predicate.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  isSomeAnd(f: (val: T) => boolean): boolean;
  /**
   * Returns `true` if the option is a `None` value.
   */
  isNone(): this is NoneOption<T>;
  /**
   * Returns `true` if the option is a `None` or the value inside of it matches a predicate.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  isNoneOr(f: (val: T) => boolean): boolean;
  /**
   * Returns the contained `Some` value.
   *
   * @throws Panics if the value is a `None` with a custom panic message provided by `msg`.
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  expect(msg: string): T;
  /**
   * Returns the contained `Some` value.
   *
   * @throws Panics if the self value equals `None`.
   */
  unwrap(): T;
  /**
   * Returns the contained `Some` value or a provided default.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  unwrapOr(defaultVal: T): T;
  /**
   * Returns the contained `Some` value or computes it from a closure.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  unwrapOrElse(f: () => T): T;
  /**
   * Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  map<U>(f: (val: T) => U): Option<U>;
  /**
   * Calls the provided closure with a reference to the contained value (if `Some`).
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  inspect(f: (val: T) => void): Option<T>;
  /**
   * Returns the provided default result (if none), or applies a function to the contained value (if any).
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  mapOr<U>(defaultVal: U, f: (val: T) => U): U;
  /**
   * Computes a default function result (if none), or applies a different function to the contained value (if any).
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  mapOrElse<U>(defaultF: () => U, f: (val: T) => U): U;
  /**
   * Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err)`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  okOr<E extends ResultError>(err: E): Result<T, E>;
  /**
   * Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err())`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  okOrElse<E extends ResultError>(errF: () => E): Result<T, E>;
  /**
   * Returns an iterator over the possibly contained value.
   */
  iter(): IterableIterator<T>;
  /**
   * Returns `None` if the option is `None`, otherwise returns `optb`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  and<U>(optb: Option<U>): Option<U>;
  /**
   * Returns `None` if the option is `None`, otherwise calls `f` with the wrapped value and returns the result.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  andThen<U>(f: (val: T) => Option<U>): Option<U>;
  /**
   * Returns `None` if the option is `None`, otherwise calls `predicate` with the wrapped value and returns:
   * - `Some(t)` if `predicate` returns `true` (where `t` is the wrapped value), and
   * - `None` if `predicate` returns `false`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  filter(predicate: (val: T) => boolean): Option<T>;
  /**
   * Returns the option if it contains a value, otherwise returns `optb`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  or<T2>(optb: Option<T2>): Option<T | T2>;
  /**
   * Returns the option if it contains a value, otherwise calls `f` and returns the result.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  orElse<T2>(f: () => Option<T2>): Option<T | T2>;
  /**
   * Returns `Some` if exactly one of `this`, `optb` is `Some`, otherwise returns `None`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  xor<T2>(optb: Option<T2>): Option<T | T2>;
  /**
   * Inserts `value` into the option, then returns a reference to it.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  insert(value: T): T;
  /**
   * Inserts `value` into the option if it is `None`, then returns a reference to the contained value.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  getOrInsert(value: T): T;
  /**
   * Inserts a value computed from `f` into the option if it is `None`, then returns a reference to the contained value.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  getOrInsertWith(f: () => T): T;
  /**
   * Takes the value out of the option, leaving a `None` in its place.
   */
  take(): Option<T>;
  /**
   * Takes the value out of the option, but only if the predicate evaluates to `true` on the value.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  takeIf(predicate: (val: T) => boolean): Option<T>;
  /**
   * Replaces the actual value in the option by the value given in parameter, returning the old value if present,
   * leaving a `Some` in its place.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  replace(value: T): Option<T>;
  /**
   * Converts from `Option<Option<T>>` to `Option<T>`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  flatten<U>(this: Option<Option<U>>): Option<U>;
}
/**
 * Some value of type `T`.
 * @param value The value to be wrapped in a `Some`.
 * @returns An `Option` representing the presence of a value.
 */
declare function Some<T>(value: T): Option<T>;
/**
 * No value.
 * @returns An `Option` representing the absence of a value.
 */
declare function None<T = never>(): Option<T>;
//#endregion
//#region src/result.d.ts
/**
 * The base interface for all errors returned by a `Result`.
 * It requires a `code` property which can be used to identify the error type.
 */
interface ResultError {
  code: string;
}
/**
 * Represents a successful `Result` containing a value of type `T`.
 */
type OkResult<T, E extends ResultError> = {
  readonly value: T;
  readonly error: null;
} & ResultMethods<T, E>;
/**
 * Represents a failed `Result` containing an error of type `E`.
 */
type ErrResult<T, E extends ResultError> = {
  readonly value: null;
  readonly error: E;
} & ResultMethods<T, E>;
/**
 * `Result<T, E>` is the type used for returning and propagating errors.
 *
 * It is a type with the parameters, `Ok(T)`, representing success and containing a value,
 * and `Err(E)`, representing error and containing an error value.
 *
 * Functions return `Result` whenever errors are expected and recoverable.
 *
 * The error type `E` must extend `ResultError` which contains a `code` property of type `string`.
 *
 * @example
 * ```typescript
 * const divide = (a: number, b: number) => {
 *   if (b === 0) return Err({ code: 'DIVIDE_BY_ZERO' });
 *   return Ok(a / b);
 * }
 *
 * const { value, error } = divide(10, 2);
 * if (error) console.error(error.code);
 * else console.log(value);
 * ```
 *
 * @template T - Contains the success value.
 * @template E - Contains the error value. Must have a `code` property of type `string`.
 */
type Result<T, E extends ResultError> = OkResult<T, E> | ErrResult<T, E>;
interface ResultMethods<T, E extends ResultError> {
  /**
   * Returns `true` if the result is `Ok`.
   */
  isOk(): this is OkResult<T, E>;
  /**
   * Returns `true` if the result is `Ok` and the value inside of it matches a predicate.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  isOkAnd(f: (val: T) => boolean): this is OkResult<T, E>;
  /**
   * Returns `true` if the result is `Err`.
   */
  isErr(): this is ErrResult<T, E>;
  /**
   * Returns `true` if the result is `Err` and the value inside of it matches a predicate.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  isErrAnd(f: (err: E) => boolean): this is ErrResult<T, E>;
  /**
   * Converts from `Result<T, E>` to `Option<T>`.
   *
   * Converts self into an `Option<T>`, consuming self, and converting the error to `None`, if any.
   */
  ok(): Option<T>;
  /**
   * Converts from `Result<T, E>` to `Option<E>`.
   *
   * Converts self into an `Option<E>`, consuming self, and discarding the success value, if any.
   */
  err(): Option<E>;
  /**
   * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value, leaving an `Err` value untouched.
   *
   * This function can be used to compose the results of two functions.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  map<U>(f: (val: T) => U): Result<U, E>;
  /**
   * Returns the provided default (if `Err`), or applies a function to the contained value (if `Ok`).
   *
   * Arguments passed to `mapOr` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `mapOrElse`, which is lazily evaluated.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  mapOr<U>(fallback: U, f: (val: T) => U): U;
  /**
   * Maps a `Result<T, E>` to `U` by applying fallback function `fallbackFn` to a contained `Err` value, or function `f` to a contained `Ok` value.
   *
   * This function can be used to unpack a successful result while handling an error.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  mapOrElse<U>(fallbackFn: (err: E) => U, f: (val: T) => U): U;
  /**
   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value, leaving an `Ok` value untouched.
   *
   * This function can be used to pass through a successful result while handling an error.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  mapErr<F extends ResultError>(f: (err: E) => F): Result<T, F>;
  /**
   * Calls a function with a reference to the contained value if `Ok`.
   *
   * Returns the original result.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  inspect(f: (val: T) => void): Result<T, E>;
  /**
   * Calls a function with a reference to the contained value if `Err`.
   *
   * Returns the original result.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  inspectErr(f: (err: E) => void): Result<T, E>;
  /**
   * Returns an iterator over the possibly contained value.
   *
   * The iterator yields one value if the result is `Ok`, otherwise none.
   */
  iter(): Iterable<T>;
  /**
   * Returns the contained `Ok` value, consuming the `self` value.
   *
   * @throws Panics if the value is an `Err`, with a panic message including the passed message, and the content of the `Err`.
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  expect(msg: string): T;
  /**
   * Returns the contained `Ok` value, consuming the `self` value.
   *
   * @throws Panics if the value is an `Err`, with a panic message provided by the `Err`'s value.
   */
  unwrap(): T;
  /**
   * Returns the contained `Err` value, consuming the `self` value.
   *
   * @throws Panics if the value is an `Ok`, with a panic message including the passed message, and the content of the `Ok`.
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  expectErr(msg: string): E;
  /**
   * Returns the contained `Err` value, consuming the `self` value.
   *
   * @throws Panics if the value is an `Ok`, with a custom panic message provided by the `Ok`'s value.
   */
  unwrapErr(): E;
  /**
   * Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`.
   *
   * Arguments passed to `and` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `andThen`, which is lazily evaluated.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  and<U, E2 extends ResultError>(res: Result<U, E2>): Result<U, E | E2>;
  /**
   * Calls `f` if the result is `Ok`, otherwise returns the `Err` value of `self`.
   *
   * This function can be used for control flow based on `Result` values.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  andThen<U, F extends ResultError>(f: (val: T) => Result<U, F>): Result<U, E | F>;
  /**
   * Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`.
   *
   * Arguments passed to `or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `orElse`, which is lazily evaluated.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  or<T2, F extends ResultError>(res: Result<T2, F>): Result<T | T2, F>;
  /**
   * Calls `f` if the result is `Err`, otherwise returns the `Ok` value of `self`.
   *
   * This function can be used for control flow based on result values.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  orElse<T2, F extends ResultError>(f: (err: E) => Result<T2, F>): Result<T | T2, F>;
  /**
   * Returns the contained `Ok` value or a provided default.
   *
   * Arguments passed to `unwrapOr` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `unwrapOrElse`, which is lazily evaluated.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  unwrapOr<T2>(fallback: T2): T | T2;
  /**
   * Returns the contained `Ok` value or computes it from a closure.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  unwrapOrElse<T2>(f: (err: E) => T2): T | T2;
  /**
   * Converts from `Result<Result<T, E>, E>` to `Result<T, E>`.
   *
   * @throws If this method throws an error other than a panic, it indicates misuse of the library (garbage data, bypass of the type system, or invalid runtime input). Check your code.
   */
  flatten<U, F extends ResultError>(this: Result<Result<U, F>, E>): Result<U, E | F>;
}
/**
 * Contains the success value.
 *
 * @example
 * ```typescript
 * const { value } = Ok(42);
 * ```
 *
 * @param value - The value to wrap in a successful result.
 * @returns A `Result` representing a successful outcome.
 */
declare function Ok<T, E extends ResultError = never>(value: T): Result<T, E>;
/**
 * Contains the error value.
 *
 * @example
 * ```typescript
 * const { error } = Err({ code: 'NOT_FOUND' });
 * ```
 *
 * @param error - The error to wrap in a failed result. Must have a `code` property of type `string`.
 * @returns A `Result` representing a failed outcome.
 */
declare function Err<const C extends string, E extends ResultError & {
  code: C;
}>(error: E): Result<never, E>;
//#endregion
export { Err, ErrResult, None, NoneOption, Ok, OkResult, Option, Result, ResultError, Some, SomeOption };