//#region src/option.d.ts
/**
 * Present value variant.
 *
 * @template A Value type.
 *
 * @example
 * const option = new Some(42);
 * option.value // 42
 * option.status // "some"
 */
declare class Some<A> {
  readonly value: A;
  readonly status: "some";
  constructor(value: A);
  /** Returns true, narrowing Option to Some. */
  isSome(): this is Some<A>;
  /** Returns false, narrowing Option to None. */
  isNone(): this is None;
  /**
   * Transforms value.
   *
   * @template B Transformed type.
   * @param fn Transformation function.
   * @returns Some with transformed value.
   * @throws {Panic} If fn throws.
   *
   * @example
   * some(2).map(x => x * 2) // Some(4)
   */
  map<B>(fn: (a: A) => B): Some<B>;
  /**
   * Chains Option-returning function.
   *
   * @template B New value type.
   * @param fn Function returning Option.
   * @returns Option from fn.
   * @throws {Panic} If fn throws.
   *
   * @example
   * some(2).andThen(x => x > 0 ? some(x) : none()) // Some(2)
   */
  andThen<B>(fn: (a: A) => Option<B>): Option<B>;
  /**
   * Chains async Option-returning function.
   *
   * @template B New value type.
   * @param fn Async function returning Option.
   * @returns Promise of Option from fn.
   * @throws {Panic} If fn throws synchronously or rejects.
   *
   * @example
   * await some(1).andThenAsync(async x => some(await fetchData(x)))
   */
  andThenAsync<B>(fn: (a: A) => Promise<Option<B>>): Promise<Option<B>>;
  /**
   * Pattern matches on Option.
   *
   * @template T Return type.
   * @param handlers Some and none handlers.
   * @returns Result of some handler.
   * @throws {Panic} If handler throws.
   *
   * @example
   * some(2).match({ some: x => x * 2, none: () => 0 }) // 4
   */
  match<T>(handlers: {
    some: (a: A) => T;
    none: () => T;
  }): T;
  /**
   * Extracts value.
   *
   * @param _message Ignored.
   * @returns The value.
   *
   * @example
   * some(42).unwrap() // 42
   */
  unwrap(_message?: string): A;
  /**
   * Returns value, ignoring fallback.
   *
   * @template B Fallback type.
   * @param _fallback Ignored.
   * @returns The value.
   *
   * @example
   * some(42).unwrapOr(0) // 42
   */
  unwrapOr<B>(_fallback: B): A;
  /**
   * Returns value, ignoring fallback thunk.
   *
   * @template B Fallback type.
   * @param _fallback Ignored.
   * @returns The value.
   *
   * @example
   * some(42).unwrapOrElse(() => 0) // 42
   */
  unwrapOrElse<B>(_fallback: () => B): A;
  /**
   * Runs side effect, returns self.
   *
   * @param fn Side effect function.
   * @returns Self.
   * @throws {Panic} If fn throws.
   *
   * @example
   * some(2).tap(console.log).map(x => x * 2) // logs 2, returns Some(4)
   */
  tap(fn: (a: A) => void): Some<A>;
  /**
   * Runs async side effect, returns self.
   *
   * @param fn Async side effect function.
   * @returns Promise of self.
   * @throws {Panic} If fn throws synchronously or rejects.
   *
   * @example
   * await some(2).tapAsync(async x => await log(x))
   */
  tapAsync(fn: (a: A) => Promise<void>): Promise<Some<A>>;
  /**
   * Returns Some if predicate passes, None otherwise.
   *
   * @param predicate Test function.
   * @returns Some if predicate returns true, None otherwise.
   * @throws {Panic} If predicate throws.
   *
   * @example
   * some(5).filter(x => x > 3) // Some(5)
   * some(2).filter(x => x > 3) // None
   */
  filter(predicate: (a: A) => boolean): Option<A>;
  /**
   * Makes Some yieldable in Option.gen blocks.
   * Immediately returns the value without yielding.
   */
  [Symbol.iterator](): Generator<None, A, unknown>;
}
/**
 * Absent value variant (singleton).
 *
 * @example
 * const option = None.instance;
 * option.status // "none"
 */
declare class None {
  readonly status: "none";
  private constructor();
  /** Singleton instance. */
  static readonly instance: None;
  /** Returns false, narrowing Option to Some. */
  isSome(): this is Some<never>;
  /** Returns true, narrowing Option to None. */
  isNone(): this is None;
  /**
   * No-op on None, returns self.
   *
   * @template U New phantom value type.
   * @param _fn Ignored.
   * @returns Self.
   */
  map<U>(_fn: (a: never) => U): None;
  /**
   * No-op on None, returns self.
   *
   * @template U New phantom value type.
   * @param _fn Ignored.
   * @returns Self.
   */
  andThen<U>(_fn: (a: never) => Option<U>): None;
  /**
   * No-op on None, returns Promise of self.
   *
   * @template U New phantom value type.
   * @param _fn Ignored.
   * @returns Promise of self.
   */
  andThenAsync<U>(_fn: (a: never) => Promise<Option<U>>): Promise<None>;
  /**
   * Pattern matches on Option.
   *
   * @template R Return type.
   * @param handlers Some and none handlers.
   * @returns Result of none handler.
   * @throws {Panic} If handler throws.
   *
   * @example
   * none().match({ some: x => x, none: () => "empty" }) // "empty"
   */
  match<R>(handlers: {
    some: (a: never) => R;
    none: () => R;
  }): R;
  /**
   * Throws error with optional message.
   *
   * @param message Error message.
   * @throws Always throws.
   *
   * @example
   * none().unwrap() // throws Panic
   * none().unwrap("custom") // throws Panic("custom")
   */
  unwrap(message?: string): never;
  /**
   * Returns fallback value.
   *
   * @template U Fallback type.
   * @param fallback Fallback value.
   * @returns Fallback.
   *
   * @example
   * none().unwrapOr(42) // 42
   */
  unwrapOr<U>(fallback: U): U;
  /**
   * Computes and returns fallback value.
   *
   * @template U Fallback type.
   * @param fallback Fallback thunk.
   * @returns Result of fallback.
   * @throws {Panic} If fallback throws.
   *
   * @example
   * none().unwrapOrElse(() => 42) // 42
   */
  unwrapOrElse<U>(fallback: () => U): U;
  /**
   * No-op on None, returns self.
   *
   * @param _fn Ignored.
   * @returns Self.
   */
  tap(_fn: (a: never) => void): None;
  /**
   * No-op on None, returns Promise of self.
   *
   * @param _fn Ignored.
   * @returns Promise of self.
   */
  tapAsync(_fn: (a: never) => Promise<void>): Promise<None>;
  /**
   * No-op on None, returns self.
   *
   * @param _predicate Ignored.
   * @returns Self.
   */
  filter(_predicate: (a: never) => boolean): None;
  /**
   * Makes None yieldable in Option.gen blocks.
   * Yields None for proper generator short-circuiting.
   */
  [Symbol.iterator](): Generator<None, never, unknown>;
}
/**
 * Union type representing presence or absence of a value.
 *
 * @template A Value type.
 *
 * @example
 * type MaybeUser = Option<User>;
 */
type Option<A> = Some<A> | None;
/**
 * Infer the value type from an Option.
 * Distributive: InferValue<Some<A> | Some<B>> = A | B
 */
type InferValue<O> = O extends Some<infer A> ? A : never;
/**
 * Constraint for any Option type.
 * Used in Option.gen to accept flexible return types from generators.
 */
type AnyOption = Some<unknown> | None;
declare function some(): Some<void>;
declare function some<A>(value: A): Some<A>;
declare function optionAwait<A>(promise: Promise<Option<A>>): AsyncGenerator<None, A, unknown>;
/** Shape of a serialized Some over RPC. */
interface SerializedSome<A> {
  status: "some";
  value: A;
}
/** Shape of a serialized None over RPC. */
interface SerializedNone {
  status: "none";
}
/** Shape of a serialized Option over RPC. */
type SerializedOption<A> = SerializedSome<A> | SerializedNone;
/**
 * Utilities for creating and handling Option types.
 *
 * @example
 * const option = Option.from(maybeNull);
 * const value = option.map(x => x.id).unwrapOr("default");
 */
declare const Option: {
  /**
   * Creates present value.
   *
   * @example
   * Option.some(42)  // Some<number>
   * Option.some()    // Some<void>
   */
  readonly some: typeof some;
  /**
   * Creates absent value.
   *
   * @example
   * Option.none() // None
   */
  readonly none: () => None;
  /**
   * Type guard for Some.
   *
   * @example
   * if (Option.isSome(option)) { option.value }
   */
  readonly isSome: <A>(option: Option<A>) => option is Some<A>;
  /**
   * Type guard for None.
   *
   * @example
   * if (Option.isNone(option)) { // handle absent }
   */
  readonly isNone: <A>(option: Option<A>) => option is None;
  /**
   * Transforms value, passes None through.
   *
   * @example
   * Option.map(some(2), x => x * 2) // Some(4)
   * Option.map(x => x * 2)(some(2)) // Some(4)
   */
  readonly map: {
    <A, B>(option: Option<A>, fn: (a: A) => B): Option<B>;
    <A, B>(fn: (a: A) => B): (option: Option<A>) => Option<B>;
  };
  /**
   * Chains Option-returning function on Some.
   *
   * @example
   * Option.andThen(some(2), x => x > 0 ? some(x) : none()) // Some(2)
   */
  readonly andThen: {
    <A, B>(option: Option<A>, fn: (a: A) => Option<B>): Option<B>;
    <A, B>(fn: (a: A) => Option<B>): (option: Option<A>) => Option<B>;
  };
  /**
   * Chains async Option-returning function on Some.
   *
   * @example
   * await Option.andThenAsync(some(1), async x => some(await fetch(x)))
   */
  readonly andThenAsync: {
    <A, B>(option: Option<A>, fn: (a: A) => Promise<Option<B>>): Promise<Option<B>>;
    <A, B>(fn: (a: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>;
  };
  /**
   * Pattern matches on Option.
   *
   * @example
   * Option.match(some(2), { some: x => x * 2, none: () => 0 }) // 4
   */
  readonly match: {
    <A, T>(option: Option<A>, handlers: {
      some: (a: A) => T;
      none: () => T;
    }): T;
    <A, T>(handlers: {
      some: (a: A) => T;
      none: () => T;
    }): (option: Option<A>) => T;
  };
  /**
   * Runs side effect on Some value, returns original option.
   *
   * @example
   * Option.tap(some(2), console.log) // logs 2, returns Some(2)
   */
  readonly tap: {
    <A>(option: Option<A>, fn: (a: A) => void): Option<A>;
    <A>(fn: (a: A) => void): (option: Option<A>) => Option<A>;
  };
  /**
   * Runs async side effect on Some value, returns original option.
   *
   * @example
   * await Option.tapAsync(some(2), async x => await log(x))
   */
  readonly tapAsync: {
    <A>(option: Option<A>, fn: (a: A) => Promise<void>): Promise<Option<A>>;
    <A>(fn: (a: A) => Promise<void>): (option: Option<A>) => Promise<Option<A>>;
  };
  /**
   * Extracts value or throws.
   *
   * @example
   * Option.unwrap(some(42)) // 42
   * Option.unwrap(none()) // throws Panic
   */
  readonly unwrap: <A>(option: Option<A>, message?: string) => A;
  /**
   * Extracts value or returns fallback.
   *
   * @example
   * Option.unwrapOr(some(42), 0) // 42
   * Option.unwrapOr(none(), 0) // 0
   */
  readonly unwrapOr: {
    <A, B>(option: Option<A>, fallback: B): A | B;
    <B>(fallback: B): <A>(option: Option<A>) => A | B;
  };
  /**
   * Generator-based composition for Option types.
   *
   * @example
   * const option = Option.gen(function* () {
   *   const a = yield* getA(); // Option<A>
   *   const b = yield* getB(a); // Option<B>
   *   return Option.some({ a, b });
   * });
   * // Option<{a, b}>
   *
   * @example
   * // Async with Option.await
   * const option = await Option.gen(async function* () {
   *   const a = yield* Option.await(fetchA());
   *   const b = yield* Option.await(fetchB(a));
   *   return Option.some({ a, b });
   * });
   */
  readonly gen: {
    <R extends AnyOption>(body: () => Generator<None, R, unknown>): Option<InferValue<R>>;
    <R extends AnyOption, This>(body: (this: This) => Generator<None, R, unknown>, thisArg: This): Option<InferValue<R>>;
    <R extends AnyOption>(body: () => AsyncGenerator<None, R, unknown>): Promise<Option<InferValue<R>>>;
    <R extends AnyOption, This>(body: (this: This) => AsyncGenerator<None, R, unknown>, thisArg: This): Promise<Option<InferValue<R>>>;
  };
  /**
   * Wraps Promise<Option> to be yieldable in async Option.gen blocks.
   *
   * @example
   * yield* Option.await(fetchUser(id))
   */
  readonly await: typeof optionAwait;
  /**
   * Converts an Option to a plain object for serialization (e.g., RPC, server actions).
   *
   * @example
   * const serialized = Option.serialize(some(42)); // { status: "some", value: 42 }
   */
  readonly serialize: <A>(option: Option<A>) => SerializedOption<A>;
  /**
   * Rehydrates serialized Option from RPC back into Some/None instances.
   * Returns null if not a serialized Option.
   *
   * @example
   * const option = Option.deserialize<User>(rpcResponse);
   */
  readonly deserialize: <A>(value: unknown) => Option<A> | null;
  /**
   * Splits array of Options into tuple of [someValues, noneCount].
   *
   * @example
   * partition([some(1), none(), some(2)]) // [[1, 2], 1]
   */
  readonly partition: <A>(options: readonly Option<A>[]) => [A[], number];
  /**
   * Flattens nested Option into single Option.
   *
   * @example
   * const nested = Option.some(Option.some(42));
   * Option.flatten(nested) // Some(42)
   */
  readonly flatten: <A>(option: Option<Option<A>>) => Option<A>;
  /**
   * Converts nullable value to Option.
   * null and undefined become None, everything else becomes Some.
   *
   * @example
   * Option.from(user)         // Some(user) if user exists
   * Option.from(null)         // None
   * Option.from(undefined)    // None
   */
  readonly from: <A>(value: A | null | undefined) => Option<NonNullable<A>>;
  /**
   * Creates Option based on predicate result.
   * Some if predicate passes, None otherwise.
   *
   * @example
   * Option.fromPredicate(5, x => x > 3)           // Some(5)
   * Option.fromPredicate(2, x => x > 3)           // None
   * Option.fromPredicate(x => x > 3)(5)           // Some(5) - pipeable
   */
  readonly fromPredicate: {
    <A, B extends A>(value: A, predicate: (a: A) => a is B): Option<B>;
    <A>(value: A, predicate: (a: A) => boolean): Option<A>;
    <A, B extends A>(predicate: (a: A) => a is B): (value: A) => Option<B>;
    <A>(predicate: (a: A) => boolean): (value: A) => Option<A>;
  };
  /**
   * Filters Option based on predicate.
   * Some becomes None if predicate fails.
   *
   * @example
   * Option.filter(some(5), x => x > 3)            // Some(5)
   * Option.filter(some(2), x => x > 3)            // None
   * Option.filter(x => x > 3)(some(5))            // Some(5) - pipeable
   */
  readonly filter: {
    <A, B extends A>(option: Option<A>, predicate: (a: A) => a is B): Option<B>;
    <A>(option: Option<A>, predicate: (a: A) => boolean): Option<A>;
    <A, B extends A>(predicate: (a: A) => a is B): (option: Option<A>) => Option<B>;
    <A>(predicate: (a: A) => boolean): (option: Option<A>) => Option<A>;
  };
  /**
   * Combines two Options into Option of tuple.
   * Returns Some([a, b]) if both are Some, None otherwise.
   *
   * @example
   * Option.zip(some(1), some("a"))                // Some([1, "a"])
   * Option.zip(some(1), none())                   // None
   */
  readonly zip: <A, B>(optionA: Option<A>, optionB: Option<B>) => Option<[A, B]>;
  /**
   * Extracts value or computes fallback lazily.
   *
   * @example
   * Option.unwrapOrElse(some(42), () => 0)           // 42
   * Option.unwrapOrElse(none(), () => expensiveDefault()) // expensiveDefault()
   */
  readonly unwrapOrElse: {
    <A, B>(option: Option<A>, fallback: () => B): A | B;
    <B>(fallback: () => B): <A>(option: Option<A>) => A | B;
  };
};
//#endregion
//#region src/error.d.ts
/**
 * Unrecoverable error — user code threw inside Option operations.
 *
 * @example
 * // Panic in generator cleanup:
 * Option.gen(function* () {
 *   try {
 *     yield* Option.none();
 *   } finally {
 *     throw new Error("cleanup failed");  // Panic!
 *   }
 * });
 *
 * // Panic in combinator:
 * Option.some(1).map(() => { throw new Error("oops"); });  // Panic!
 */
declare class Panic extends Error {
  readonly _tag: "Panic";
  readonly cause?: unknown;
  constructor(args: {
    message: string;
    cause?: unknown;
  });
  toJSON(): object;
}
/**
 * Type guard for Panic instances.
 *
 * @example
 * if (isPanic(value)) { value.cause }
 */
declare const isPanic: (value: unknown) => value is Panic;
/**
 * Throw an unrecoverable Panic.
 *
 * @example
 * panic("something went wrong", cause);
 */
declare const panic: (message: string, cause?: unknown) => never;
//#endregion
export { type InferValue, None, Option, Panic, type SerializedNone, type SerializedOption, type SerializedSome, Some, isPanic, panic };
//# sourceMappingURL=index.d.mts.map