import type { Err, ExtractErrTypes, ExtractOkTypes, Ok, Result } from './types';
/**
 * Creates a successful Result
 */
export declare function ok<T, E = never>(value: T): Result<T, E>;
/**
 * Creates a failed Result
 */
export declare function err<T = never, E = unknown>(error: E): Result<T, E>;
/**
 * Wraps a function that might throw into a Result
 */
export declare function tryCatch<T, E = unknown>(fn: () => T, errorHandler?: (error: unknown) => E): Result<T, E>;
/**
 * Wraps an async function that might throw into a ResultAsync
 */
export declare function tryCatchAsync<T, E = unknown>(fn: () => Promise<T>, errorHandler?: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
/**
 * Combines multiple Results into a single Result containing an array of values
 * Short-circuits on the first error
 */
export declare function combine<T extends readonly Result<unknown, unknown>[]>(results: T): Result<ExtractOkTypes<T>, ExtractErrTypes<T>>;
/**
 * Combines multiple Results, collecting all errors if any fail
 */
export declare function combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(results: T): Result<ExtractOkTypes<T>, ExtractErrTypes<T>[]>;
/**
 * Helper to convert a nullable value into a Result
 */
export declare function fromNullable<T, E>(value: T | null | undefined, error: E): Result<NonNullable<T>, E>;
/**
 * Helper to convert a Promise into a ResultAsync
 */
export declare function fromPromise<T, E = unknown>(promise: Promise<T>, errorHandler?: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
/**
 * Type guard to check if a value is a Result
 */
export declare function isResult<T, E>(value: unknown): value is Result<T, E>;
/**
 * Sequences an array of async Result operations, stopping at the first error
 */
export declare function sequence<T, E>(operations: (() => Promise<Result<T, E>>)[]): Promise<Result<T[], E>>;
/**
 * Executes async Result operations in parallel
 */
export declare function parallel<T, E>(operations: (() => Promise<Result<T, E>>)[]): Promise<Result<T[], E>>;
/**
 * Maps over an array with a Result-returning function
 */
export declare function traverse<T, U, E>(items: T[], fn: (item: T) => Result<U, E>): Result<U[], E>;
/**
 * Async version of traverse
 */
export declare function traverseAsync<T, U, E>(items: T[], fn: (item: T) => Promise<Result<U, E>>): Promise<Result<U[], E>>;
/**
 * Flattens a nested Result<Result<T, E>, E> into Result<T, E>
 */
export declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
/**
 * Taps into a Result without modifying it - useful for logging/debugging
 */
export declare function tap<T, E>(result: Result<T, E>, onOk?: (value: T) => void, onErr?: (error: E) => void): Result<T, E>;
/**
 * Swaps Ok and Err - useful for inverting logic
 */
export declare function swap<T, E>(result: Result<T, E>): Result<E, T>;
/**
 * Filters a Result based on a predicate
 */
export declare function filter<T, E>(result: Result<T, E>, predicate: (value: T) => boolean, error: E): Result<T, E>;
/**
 * Returns Ok value or throws error - useful at boundaries
 */
export declare function unwrapOrThrow<T, E>(result: Result<T, E>, mapError?: (error: E) => Error): T;
/**
 * Converts Result to Promise - Ok becomes resolved, Err becomes rejected
 */
export declare function toPromise<T, E>(result: Result<T, E>, mapError?: (error: E) => Error): Promise<T>;
/**
 * Gets the Ok value or a default computed lazily
 */
export declare function getOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
/**
 * Collects multiple Results, returning Ok with all values or Err with first error
 */
export declare function all<T, E>(results: Result<T, E>[]): Result<T[], E>;
/**
 * Returns the first Ok result, or the last Err if all fail
 */
export declare function any<T, E>(results: Result<T, E>[]): Result<T, E>;
/**
 * Partitions an array of Results into [successes, failures]
 */
export declare function partition<T, E>(results: Result<T, E>[]): [T[], E[]];
// Ok implementation
declare class OkImpl<T, E> implements Ok<T, E> {
  readonly isOk: unknown;
  readonly isErr: unknown;
  readonly _tag: unknown;
  readonly value: T;
  constructor(value: T);
  map<U>(fn: (value: T) => U): Result<U, E>;
  mapErr<F>(_fn: (error: E) => F): Result<T, F>;
  andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
  orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F>;
  match<U>(patterns: { ok: (value: T) => U, err: (error: E) => U }): U;
  unwrap(): T;
  unwrapOr(_defaultValue: T): T;
  unwrapOrElse(_fn: (error: E) => T): T;
  expect(_msg: string): T;
}
// Err implementation
declare class ErrImpl<T, E> implements Err<T, E> {
  readonly isOk: unknown;
  readonly isErr: unknown;
  readonly _tag: unknown;
  readonly error: E;
  constructor(error: E);
  map<U>(_fn: (value: T) => U): Result<U, E>;
  mapErr<F>(fn: (error: E) => F): Result<T, F>;
  andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E>;
  orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;
  match<U>(patterns: { ok: (value: T) => U, err: (error: E) => U }): U;
  unwrap(): never;
  unwrapOr(defaultValue: T): T;
  unwrapOrElse(fn: (error: E) => T): T;
  expect(msg: string): never;
}