export declare const alt: <E, A>(
  that: () => ObservableEither<E, A>
) => (fa: ObservableEither<E, A>) => ObservableEither<E, A>

export declare const ap: <E, A>(
  fa: ObservableEither<E, A>
) => <B>(fab: ObservableEither<E, (a: A) => B>) => ObservableEither<E, B>

export declare const bimap: <E, G, A, B>(
  f: (e: E) => G,
  g: (a: A) => B
) => (fa: ObservableEither<E, A>) => ObservableEither<G, B>

export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: ObservableEither<E, A>) => ObservableEither<G, A>

export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: ObservableEither<E, A>) => ObservableEither<E, B>

export declare const chain: <A, E, B>(
  f: (a: A) => ObservableEither<E, B>
) => (ma: ObservableEither<E, A>) => ObservableEither<E, B>

export declare const chainW: <A, E2, B>(
  f: (a: A) => ObservableEither<E2, B>
) => <E1>(ma: ObservableEither<E1, A>) => ObservableEither<E2 | E1, B>

export declare const throwError: <E, A>(e: E) => ObservableEither<E, A>

export declare const apFirst: <E, B>(
  fb: ObservableEither<E, B>
) => <A>(fa: ObservableEither<E, A>) => ObservableEither<E, A>

export declare const apSecond: <E, B>(
  fb: ObservableEither<E, B>
) => <A>(fa: ObservableEither<E, A>) => ObservableEither<E, B>

export declare const chainFirst: <E, A, B>(
  f: (a: A) => ObservableEither<E, B>
) => (ma: ObservableEither<E, A>) => ObservableEither<E, A>

export declare const flatten: <E, A>(mma: ObservableEither<E, ObservableEither<E, A>>) => ObservableEither<E, A>

export declare const orElse: <E, A, M>(
  onLeft: (e: E) => ObservableEither<M, A>
) => (ma: ObservableEither<E, A>) => ObservableEither<M, A>

export declare const swap: <E, A>(ma: ObservableEither<E, A>) => ObservableEither<A, E>

export declare const fromIO: <E, A>(fa: IO<A>) => ObservableEither<E, A>

export declare const fromIOEither: <E, A>(fa: IOEither<E, A>) => ObservableEither<E, A>

export declare const fromObservable: <E, A>(fa: Observable<A>) => ObservableEither<E, A>

export declare const fromTask: <E, A>(fa: Task<A>) => ObservableEither<E, A>

export declare const fromTaskEither: <E, A>(t: TE.TaskEither<E, A>) => ObservableEither<E, A>

export declare const left: <E = never, A = never>(e: E) => ObservableEither<E, A>

export declare const leftIO: <E = never, A = never>(me: IO<E>) => ObservableEither<E, A>

export declare const leftObservable: <E = never, A = never>(ma: Observable<E>) => ObservableEither<E, A>

export declare const right: <E = never, A = never>(a: A) => ObservableEither<E, A>

export declare const rightIO: <E = never, A = never>(ma: IO<A>) => ObservableEither<E, A>

export declare const rightObservable: <E = never, A = never>(ma: Observable<A>) => ObservableEither<E, A>

export declare const tryCatch: <A>(a: Observable<A>) => ObservableEither<unknown, A>

export declare const fold: <E, A, B>(
  onLeft: (e: E) => Observable<B>,
  onRight: (a: A) => Observable<B>
) => (ma: ObservableEither<E, A>) => Observable<B>

export declare const getOrElse: <E, A>(onLeft: (e: E) => Observable<A>) => (ma: ObservableEither<E, A>) => Observable<A>

export declare const Alt: Alt2<'ObservableEither'>

export declare const Applicative: Applicative2<'ObservableEither'>

export declare const Apply: Apply2<'ObservableEither'>

export declare const Bifunctor: Bifunctor2<'ObservableEither'>

export declare const Functor: Functor2<'ObservableEither'>

export declare const Monad: Monad2<'ObservableEither'>

export declare const MonadIO: MonadIO2<'ObservableEither'>

export declare const MonadObservable: MonadObservable2<'ObservableEither'>

export declare const MonadTask: MonadTask2<'ObservableEither'>

export declare const MonadThrow: MonadThrow2<'ObservableEither'>

export declare const URI: 'ObservableEither'

export type URI = typeof URI

export declare const observableEither: Monad2<'ObservableEither'> &
  Bifunctor2<'ObservableEither'> &
  Alt2<'ObservableEither'> &
  MonadObservable2<'ObservableEither'> &
  MonadThrow2<'ObservableEither'>

export interface ObservableEither<E, A> extends Observable<E.Either<E, A>> {}

export declare const Do: ObservableEither<never, {}>

export declare const bind: <K extends string, E, A, B>(
  name: Exclude<K, keyof A>,
  f: (a: A) => ObservableEither<E, B>
) => (fa: ObservableEither<E, A>) => ObservableEither<E, { [P in K | keyof A]: P extends keyof A ? A[P] : B }>

export declare const bindTo: <K extends string, E, A>(
  name: K
) => (fa: ObservableEither<E, A>) => ObservableEither<E, { [P in K]: A }>

export declare const bindW: <K extends string, E2, A, B>(
  name: Exclude<K, keyof A>,
  f: (a: A) => ObservableEither<E2, B>
) => <E1>(
  fa: ObservableEither<E1, A>
) => ObservableEither<E2 | E1, { [P in K | keyof A]: P extends keyof A ? A[P] : B }>

export declare const filterOrElse: {
  <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (
    ma: ObservableEither<E, A>
  ) => ObservableEither<E, B>
  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (ma: ObservableEither<E, A>) => ObservableEither<E, A>
}

export declare const fromEither: <E, A>(ma: E.Either<E, A>) => ObservableEither<E, A>

export declare const fromOption: <E>(onNone: () => E) => <A>(ma: Option<A>) => ObservableEither<E, A>

export declare const fromPredicate: {
  <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (a: A) => ObservableEither<E, B>
  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (a: A) => ObservableEither<E, A>
}

export declare const of: <E, A>(a: A) => ObservableEither<E, A>

export declare const toTaskEither: <E, A>(o: ObservableEither<E, A>) => TE.TaskEither<E, A>