Either

declare const all: <I extends Iterable<Either<any, any>> | Record<string, Either<any, any>>>(
  input: I,
) => [I] extends [ReadonlyArray<Either<any, any>>]
  ? Either<
      { [K in keyof I]: [I[K]] extends [Either<infer A, any>] ? A : never },
      I[number] extends never ? never : [I[number]] extends [Either<any, infer E>] ? E : never
    >
  : [I] extends [Iterable<Either<infer A, infer E>>]
    ? Either<Array<A>, E>
    : Either<
        { [K in keyof I]: [I[K]] extends [Either<infer A, any>] ? A : never },
        I[keyof I] extends never ? never : [I[keyof I]] extends [Either<any, infer E>] ? E : never
      >;

declare const ap: {
  <A, E2>(that: Either<A, E2>): <A2, E>(self: Either<(right: A) => A2, E>) => Either<A2, E2 | E>;
  <A, A2, E, E2>(self: Either<(right: A) => A2, E>, that: Either<A, E2>): Either<A2, E | E2>;
};

declare const fromNullable: {
  <A, E>(onNullable: (right: A) => E): (self: A) => Either<NonNullable<A>, E>;
  <A, E>(self: A, onNullable: (right: A) => E): Either<NonNullable<A>, E>;
};

declare const fromOption: {
  <E>(onNone: () => E): <A>(self: Option<A>) => Either<A, E>;
  <A, E>(self: Option<A>, onNone: () => E): Either<A, E>;
};

declare const left: <E>(e: E) => Either<never, E>;

declare const right: <A>(a: A) => Either<A>;

declare const bind: {
  <N extends string, A extends object, B, E2>(
    name: Exclude<N, keyof A>,
    f: (a: NoInfer<A>) => Either<B, E2>,
  ): <E>(
    self: Either<A, E>,
  ) => Either<{ [K in string | number | symbol]: K extends keyof A ? A[K] : B }, E2 | E>;
  <A extends object, E, N extends string, B, E2>(
    self: Either<A, E>,
    name: Exclude<N, keyof A>,
    f: (a: NoInfer<A>) => Either<B, E2>,
  ): Either<{ [K in string | number | symbol]: K extends keyof A ? A[K] : B }, E | E2>;
};

declare const bindTo: {
  <N extends string>(name: N): <A, E>(self: Either<A, E>) => Either<{ [K in string]: A }, E>;
  <A, E, N extends string>(self: Either<A, E>, name: N): Either<{ [K in string]: A }, E>;
};

declare const Do: Either<{}>;

declare function getEquivalence<A, E>(__namedParameters: {
  left: Equivalence<E>;
  right: Equivalence<A>;
}): Equivalence<Either<A, E>>;

declare const orElse: {
  <E, A2, E2>(that: (left: E) => Either<A2, E2>): <A>(self: Either<A, E>) => Either<A2 | A, E2>;
  <A, E, A2, E2>(self: Either<A, E>, that: (left: E) => Either<A2, E2>): Either<A | A2, E2>;
};

declare const filterOrLeft: {
  <A, B, E2>(
    refinement: Refinement<NoInfer<A>, B>,
    orLeftWith: (right: NoInfer<A>) => E2,
  ): <E>(self: Either<A, E>) => Either<B, E2 | E>;
  <A, E2>(
    predicate: Predicate<NoInfer<A>>,
    orLeftWith: (right: NoInfer<A>) => E2,
  ): <E>(self: Either<A, E>) => Either<A, E2 | E>;
  <A, E, B, E2>(
    self: Either<A, E>,
    refinement: Refinement<A, B>,
    orLeftWith: (right: A) => E2,
  ): Either<B, E | E2>;
  <A, E, E2>(
    self: Either<A, E>,
    predicate: Predicate<A>,
    orLeftWith: (right: A) => E2,
  ): Either<A, E | E2>;
};

declare const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>>;

declare const getLeft: <A, E>(self: Either<A, E>) => Option<E>;

declare const getOrElse: {
  <E, A2>(onLeft: (left: E) => A2): <A>(self: Either<A, E>) => A2 | A;
  <A, E, A2>(self: Either<A, E>, onLeft: (left: E) => A2): A | A2;
};

declare const getOrNull: <A, E>(self: Either<A, E>) => A | null;

declare const getOrThrow: <A, E>(self: Either<A, E>) => A;

declare const getOrThrowWith: {
  <E>(onLeft: (left: E) => unknown): <A>(self: Either<A, E>) => A;
  <A, E>(self: Either<A, E>, onLeft: (left: E) => unknown): A;
};

declare const getOrUndefined: <A, E>(self: Either<A, E>) => A | undefined;

declare const getRight: <A, E>(self: Either<A, E>) => Option<A>;

declare const merge: <A, E>(self: Either<A, E>) => E | A;

declare const isEither: (input: unknown) => input is Either<unknown, unknown>;

declare const isLeft: <A, E>(self: Either<A, E>) => self is Left<E, A>;

declare const isRight: <A, E>(self: Either<A, E>) => self is Right<E, A>;

declare const liftPredicate: {
  <A, B, E>(refinement: Refinement<A, B>, orLeftWith: (a: A) => E): (a: A) => Either<B, E>;
  <B, E, A = B>(predicate: Predicate<A>, orLeftWith: (a: A) => E): (a: B) => Either<B, E>;
  <A, E, B>(self: A, refinement: Refinement<A, B>, orLeftWith: (a: A) => E): Either<B, E>;
  <B, E, A = B>(self: B, predicate: Predicate<A>, orLeftWith: (a: A) => E): Either<B, E>;
};

declare function flip<A, E>(self: Either<A, E>): Either<E, A>;

declare const map: {
  <A, A2>(f: (right: A) => A2): <E>(self: Either<A, E>) => Either<A2, E>;
  <A, E, A2>(self: Either<A, E>, f: (right: A) => A2): Either<A2, E>;
};

declare const mapBoth: {
  <E, E2, A, A2>(options: {
    readonly onLeft: (left: E) => E2;
    readonly onRight: (right: A) => A2;
  }): (self: Either<A, E>) => Either<A2, E2>;
  <A, E, E2, A2>(
    self: Either<A, E>,
    options: {
      readonly onLeft: (left: E) => E2;
      readonly onRight: (right: A) => A2;
    },
  ): Either<A2, E2>;
};

declare const mapLeft: {
  <E, E2>(f: (left: E) => E2): <A>(self: Either<A, E>) => Either<A, E2>;
  <A, E, E2>(self: Either<A, E>, f: (left: E) => E2): Either<A, E2>;
};

type Either<A, E = never> = Left<E, A> | Right<E, A>;

interface EitherUnify<
  A extends {
    [typeSymbol]?: any;
  },
> {
  Either?: () => A[typeof typeSymbol] extends Either<R0, L0> | _ ? Either<R0, L0> : never;
}

interface EitherUnifyIgnore {
  Effect?: true;
  Option?: true;
  Tag?: true;
}

interface Left<out E, out A> extends Pipeable, Inspectable, STM<A, E>, Effect<A, E> {
  readonly _op: "Left";
  readonly _tag: "Left";
  readonly [ChannelTypeId]: VarianceStruct<never, unknown, E, unknown, A, unknown, never>;
  readonly [EffectTypeId]: VarianceStruct<A, E, never>;
  [ignoreSymbol]?: EitherUnifyIgnore;
  readonly [SinkTypeId]: VarianceStruct<A, unknown, never, E, never>;
  readonly [STMTypeId]: {
    readonly _A: Covariant<A>;
    readonly _E: Covariant<E>;
    readonly _R: Covariant<never>;
  };
  readonly [StreamTypeId]: VarianceStruct<A, E, never>;
  readonly [TypeId]: {
    readonly _L: Covariant<E>;
    readonly _R: Covariant<A>;
  };
  [typeSymbol]?: unknown;
  [unifySymbol]?: EitherUnify<Left<E, A>>;
  readonly left: E;
  [iterator](): EffectGenerator<Left<E, A>>;
}

interface Right<out E, out A> extends Pipeable, Inspectable, STM<A, E>, Effect<A, E> {
  readonly _op: "Right";
  readonly _tag: "Right";
  readonly [ChannelTypeId]: VarianceStruct<never, unknown, E, unknown, A, unknown, never>;
  readonly [EffectTypeId]: VarianceStruct<A, E, never>;
  [ignoreSymbol]?: EitherUnifyIgnore;
  readonly [SinkTypeId]: VarianceStruct<A, unknown, never, E, never>;
  readonly [STMTypeId]: {
    readonly _A: Covariant<A>;
    readonly _E: Covariant<E>;
    readonly _R: Covariant<never>;
  };
  readonly [StreamTypeId]: VarianceStruct<A, E, never>;
  readonly [TypeId]: {
    readonly _L: Covariant<E>;
    readonly _R: Covariant<A>;
  };
  [typeSymbol]?: unknown;
  [unifySymbol]?: EitherUnify<Right<E, A>>;
  readonly right: A;
  [iterator](): EffectGenerator<Right<E, A>>;
}

declare const transposeMapOption: <A, B, E = never>(f: (self: A) => Either<B, E>) => (self: Option<A>) => Either<Option<B>, E> & <A, B, E = never>(self: Option<A>, f: (self: A) => Either<B, E>) => Either<Option<B>, E>

declare function transposeOption<A = never, E = never>(
  self: Option<Either<A, E>>,
): Either<Option<A>, E>;

declare const let: {
  <N extends string, A extends object, B>(
    name: Exclude<N, keyof A>,
    f: (r: NoInfer<A>) => B,
  ): <E>(
    self: Either<A, E>,
  ) => Either<{ [K in string | number | symbol]: K extends keyof A ? A[K] : B }, E>;
  <A extends object, E, N extends string, B>(
    self: Either<A, E>,
    name: Exclude<N, keyof A>,
    f: (r: NoInfer<A>) => B,
  ): Either<{ [K in string | number | symbol]: K extends keyof A ? A[K] : B }, E>;
};

declare const try: {
  <A, E>(options: {
    readonly catch: (error: unknown) => E;
    readonly try: LazyArg<A>;
  }): Either<A, E>;
  <A>(evaluate: LazyArg<A>): Either<A, unknown>;
}

declare const void: Either<void>

declare const match: {
  <E, B, A, C = B>(options: {
    readonly onLeft: (left: E) => B;
    readonly onRight: (right: A) => C;
  }): (self: Either<A, E>) => B | C;
  <A, E, B, C = B>(
    self: Either<A, E>,
    options: {
      readonly onLeft: (left: E) => B;
      readonly onRight: (right: A) => C;
    },
  ): B | C;
};

declare const andThen: {
  <A, A2, E2>(f: (right: A) => Either<A2, E2>): <E>(self: Either<A, E>) => Either<A2, E2 | E>;
  <A2, E2>(f: Either<A2, E2>): <E, A>(self: Either<A, E>) => Either<A2, E2 | E>;
  <A, A2>(f: (right: A) => A2): <E>(self: Either<A, E>) => Either<A2, E>;
  <A2>(right: NotFunction<A2>): <A, E>(self: Either<A, E>) => Either<A2, E>;
  <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2>): Either<A2, E | E2>;
  <A, E, A2, E2>(self: Either<A, E>, f: Either<A2, E2>): Either<A2, E | E2>;
  <A, E, A2>(self: Either<A, E>, f: (right: A) => A2): Either<A2, E>;
  <A, E, A2>(self: Either<A, E>, f: NotFunction<A2>): Either<A2, E>;
};

declare const flatMap: {
  <A, A2, E2>(f: (right: A) => Either<A2, E2>): <E>(self: Either<A, E>) => Either<A2, E2 | E>;
  <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2>): Either<A2, E | E2>;
};

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;

interface EitherTypeLambda extends TypeLambda {
  readonly type: Either<unknown, unknown>;
}

declare const zipWith: {
  <A2, E2, A, B>(
    that: Either<A2, E2>,
    f: (right: A, right2: A2) => B,
  ): <E>(self: Either<A, E>) => Either<B, E2 | E>;
  <A, E, A2, E2, B>(
    self: Either<A, E>,
    that: Either<A2, E2>,
    f: (right: A, right2: A2) => B,
  ): Either<B, E | E2>;
};