type MicroCause<E> = MicroCause.Die | MicroCause.Fail<E> | MicroCause.Interrupt

export interface Proto<Tag extends string, E> extends Pipeable, globalThis.Error {
  readonly [MicroCauseTypeId]: {
    _E: Covariant<E>
  }
  readonly _tag: Tag
  readonly traces: ReadonlyArray<string>
}

export interface Die extends Proto<"Die", never> {
  readonly defect: unknown
}

export interface Fail<E> extends Proto<"Fail", E> {
  readonly error: E
}

export interface Interrupt extends Proto<"Interrupt", never> {}

type Error<T> = T extends MicroCause.Fail<infer E> ? E : never

declare const MicroCauseTypeId: unique symbol

type MicroCauseTypeId = typeof MicroCauseTypeId

declare const causeDie: (defect: unknown, traces?: ReadonlyArray<string>) => MicroCause<never>

declare const causeFail: <E>(error: E, traces?: ReadonlyArray<string>) => MicroCause<E>

declare const causeInterrupt: (traces?: ReadonlyArray<string>) => MicroCause<never>

declare const causeIsDie: <E>(self: MicroCause<E>) => self is MicroCause.Die

declare const causeIsFail: <E>(self: MicroCause<E>) => self is MicroCause.Fail<E>

declare const causeIsInterrupt: <E>(self: MicroCause<E>) => self is MicroCause.Interrupt

declare const causeSquash: <E>(self: MicroCause<E>) => unknown

declare const causeWithTrace: {
  (trace: string): <E>(self: MicroCause<E>) => MicroCause<E>
  <E>(self: MicroCause<E>, trace: string): MicroCause<E>
}

type MicroExit<A, E> = MicroExit.Success<A, E> | MicroExit.Failure<A, E>

export interface Proto<out A, out E = never> extends Micro<A, E> {
  readonly [MicroExitTypeId]: MicroExitTypeId
}

export interface Success<out A, out E> extends Proto<A, E> {
  readonly _tag: "Success"
  readonly value: A
}

export interface Failure<out A, out E> extends Proto<A, E> {
  readonly _tag: "Failure"
  readonly cause: MicroCause<E>
}

declare const MicroExitTypeId: unique symbol

type MicroExitTypeId = typeof TypeId

declare const exitDie: (defect: unknown) => MicroExit<never>

declare const exitFail: <E>(e: E) => MicroExit<never, E>

declare const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E>

declare const exitInterrupt: MicroExit<never, never>

declare const exitIsDie: <A, E>(
  self: MicroExit<A, E>
) => self is MicroExit.Failure<A, E> & { readonly cause: MicroCause.Die }

declare const exitIsFail: <A, E>(
  self: MicroExit<A, E>
) => self is MicroExit.Failure<A, E> & { readonly cause: MicroCause.Fail<E> }

declare const exitIsFailure: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E>

declare const exitIsInterrupt: <A, E>(
  self: MicroExit<A, E>
) => self is MicroExit.Failure<A, E> & { readonly cause: MicroCause.Interrupt }

declare const exitIsSuccess: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Success<A, E>

declare const exitSucceed: <A>(a: A) => MicroExit<A, never>

declare const exitVoid: MicroExit<void, never>

declare const exitVoidAll: <I extends Iterable<MicroExit<any, any>>>(
  exits: I
) => MicroExit<void, I extends Iterable<MicroExit<infer _A, infer _E>> ? _E : never>

declare const isMicroExit: (u: unknown) => u is MicroExit<unknown, unknown>

export interface MicroFiber<out A, out E = never> {
  readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>

  readonly currentOpCount: number
  readonly getRef: <I, A>(ref: Context.Reference<I, A>) => A
  readonly context: Context.Context<never>
  readonly addObserver: (cb: (exit: MicroExit<A, E>) => void) => () => void
  readonly unsafeInterrupt: () => void
  readonly unsafePoll: () => MicroExit<A, E> | undefined
}

export interface Variance<out A, out E = never> {
  readonly _A: Covariant<A>
  readonly _E: Covariant<E>
}

declare const MicroFiberTypeId: unique symbol

type MicroFiberTypeId = typeof MicroFiberTypeId

declare const fiberAwait: <A, E>(self: MicroFiber<A, E>) => Micro<MicroExit<A, E>>

declare const fiberInterrupt: <A, E>(self: MicroFiber<A, E>) => Micro<void>

declare const fiberInterruptAll: <A extends Iterable<MicroFiber<any, any>>>(fibers: A) => Micro<void>

declare const fiberJoin: <A, E>(self: MicroFiber<A, E>) => Micro<A, E>

declare const all: <
  const Arg extends Iterable<Micro<any, any, any>> | Record<string, Micro<any, any, any>>,
  O extends NoExcessProperties<
    { readonly concurrency?: Concurrency | undefined; readonly discard?: boolean | undefined },
    O
  >
>(
  arg: Arg,
  options?: O
) => All.Return<Arg, O>

declare const filter: <A, E, R>(
  iterable: Iterable<A>,
  f: (a: NoInfer<A>) => Micro<boolean, E, R>,
  options?: { readonly concurrency?: Concurrency | undefined; readonly negate?: boolean | undefined }
) => Micro<Array<A>, E, R>

declare const filterMap: <A, B, E, R>(
  iterable: Iterable<A>,
  f: (a: NoInfer<A>) => Micro<Option.Option<B>, E, R>,
  options?: { readonly concurrency?: Concurrency | undefined }
) => Micro<Array<B>, E, R>

declare const forEach: {
  <A, B, E, R>(
    iterable: Iterable<A>,
    f: (a: A, index: number) => Micro<B, E, R>,
    options?: { readonly concurrency?: Concurrency | undefined; readonly discard?: false | undefined }
  ): Micro<Array<B>, E, R>
  <A, B, E, R>(
    iterable: Iterable<A>,
    f: (a: A, index: number) => Micro<B, E, R>,
    options: { readonly concurrency?: Concurrency | undefined; readonly discard: true }
  ): Micro<void, E, R>
}

declare const whileLoop: <A, E, R>(options: {
  readonly while: LazyArg<boolean>
  readonly body: LazyArg<Micro<A, E, R>>
  readonly step: (a: A) => void
}) => Micro<void, E, R>

declare const async: <A, E = never, R = never>(
  register: (resume: (effect: Micro<A, E, R>) => void, signal: AbortSignal) => void | Micro<void, never, R>
) => Micro<A, E, R>

declare const die: (defect: unknown) => Micro<never>

declare const fail: <E>(error: E) => Micro<never, E>

declare const failCause: <E>(cause: MicroCause<E>) => Micro<never, E>

declare const failCauseSync: <E>(evaluate: LazyArg<MicroCause<E>>) => Micro<never, E>

declare const failSync: <E>(error: LazyArg<E>) => Micro<never, E>

declare const fromEither: <R, L>(either: Either.Either<R, L>) => Micro<R, L>

declare const fromOption: <A>(option: Option.Option<A>) => Micro<A, NoSuchElementException>

declare const gen: <Self, Eff extends YieldWrap<Micro<any, any, any>>, AEff>(
  ...args: [self: Self, body: (this: Self) => Generator<Eff, AEff, never>] | [body: () => Generator<Eff, AEff, never>]
) => Micro<
  AEff,
  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never,
  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer _E, infer R>>] ? R : never
>

declare const never: Micro<never, never, never>

declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) => Micro<A>

declare const succeed: <A>(value: A) => Micro<A>

declare const succeedNone: Micro<Option.Option<never>, never, never>

declare const succeedSome: <A>(a: A) => Micro<Option.Option<A>>

declare const suspend: <A, E, R>(evaluate: LazyArg<Micro<A, E, R>>) => Micro<A, E, R>

declare const sync: <A>(evaluate: LazyArg<A>) => Micro<A>

import { Micro } from "effect"

Micro.try({
  try: () => {
    throw new Error("boom")
  },
  catch: (cause) => new Error("caught", { cause })
})

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

import { Micro } from "effect"

Micro.tryPromise({
  try: () => Promise.resolve("success"),
  catch: (cause) => new Error("caught", { cause })
})

declare const tryPromise: <A, E>(options: {
  readonly try: (signal: AbortSignal) => PromiseLike<A>
  readonly catch: (error: unknown) => E
}) => Micro<A, E>

declare const void: Micro<void, never, never>

declare const withMicroFiber: <A, E = never, R = never>(
  evaluate: (fiber: MicroFiberImpl<A, E>) => Micro<A, E, R>
) => Micro<A, E, R>

declare const yieldFlush: Micro<void, never, never>

declare const yieldNow: Micro<void, never, never>

declare const yieldNowWith: (priority?: number) => Micro<void>

declare const delay: {
  (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E, R>
}

declare const sleep: (millis: number) => Micro<void>

declare const timeout: {
  (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | TimeoutException, R>
  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E | TimeoutException, R>
}

declare const timeoutOption: {
  (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>
  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<Option.Option<A>, E, R>
}

declare const timeoutOrElse: {
  <A2, E2, R2>(options: {
    readonly duration: number
    readonly onTimeout: LazyArg<Micro<A2, E2, R2>>
  }): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
  <A, E, R, A2, E2, R2>(
    self: Micro<A, E, R>,
    options: { readonly duration: number; readonly onTimeout: LazyArg<Micro<A2, E2, R2>> }
  ): Micro<A | A2, E | E2, R | R2>
}

declare const Do: Micro<{}, never, never>

declare const bind: {
  <N extends string, A extends Record<string, any>, B, E2, R2>(
    name: N,
    f: (a: NoInfer<A>) => Micro<B, E2, R2>
  ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(
    self: Micro<A, E, R>,
    name: N,
    f: (a: NoInfer<A>) => Micro<B, E2, R2>
  ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
}

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

declare const let: {
  <N extends string, A extends Record<string, any>, B>(
    name: N,
    f: (a: NoInfer<A>) => B
  ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E, R>
  <A extends Record<string, any>, E, R, B, N extends string>(
    self: Micro<A, E, R>,
    name: N,
    f: (a: NoInfer<A>) => B
  ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E, R>
}

declare const context: <R>() => Micro<Context.Context<R>>

declare const provideContext: {
  <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>
  <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>
}

declare const provideService: {
  <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>
  <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>
}

declare const provideServiceEffect: {
  <I, S, E2, R2>(
    tag: Context.Tag<I, S>,
    acquire: Micro<S, E2, R2>
  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
  <A, E, R, I, S, E2, R2>(
    self: Micro<A, E, R>,
    tag: Context.Tag<I, S>,
    acquire: Micro<S, E2, R2>
  ): Micro<A, E | E2, Exclude<R, I> | R2>
}

declare const service: {
  <I, S>(tag: Context.Reference<I, S>): Micro<S>
  <I, S>(tag: Context.Tag<I, S>): Micro<S, never, I>
}

declare const serviceOption: <I, S>(tag: Context.Tag<I, S>) => Micro<Option.Option<S>>

declare const updateContext: {
  <R2, R>(
    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
  ): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
  <A, E, R, R2>(self: Micro<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): Micro<A, E, R2>
}

declare const updateService: {
  <I, A>(tag: Context.Reference<I, A>, f: (value: A) => A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>
  <I, A>(tag: Context.Tag<I, A>, f: (value: A) => A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R | I>
  <XA, E, R, I, A>(self: Micro<XA, E, R>, tag: Context.Reference<I, A>, f: (value: A) => A): Micro<XA, E, R>
  <XA, E, R, I, A>(self: Micro<XA, E, R>, tag: Context.Tag<I, A>, f: (value: A) => A): Micro<XA, E, R | I>
}

declare class CurrentConcurrency

declare class CurrentScheduler

import * as Micro from "effect/Micro"

Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
  concurrency: "inherit"
}).pipe(
  Micro.withConcurrency(2) // use a concurrency of 2
)

declare const withConcurrency: {
  (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
  <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>
}

declare const catchAll: {
  <E, B, E2, R2>(f: (e: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>
}

declare const catchAllCause: {
  <E, B, E2, R2>(
    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
  <A, E, R, B, E2, R2>(
    self: Micro<A, E, R>,
    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
  ): Micro<A | B, E2, R | R2>
}

declare const catchAllDefect: {
  <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>
  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2>
}

declare const catchCauseIf: {
  <E, B, E2, R2, EB extends MicroCause<E>>(
    refinement: Refinement<MicroCause<E>, EB>,
    f: (cause: EB) => Micro<B, E2, R2>
  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>
  <E, B, E2, R2>(
    predicate: Predicate<MicroCause<NoInfer<E>>>,
    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>
  <A, E, R, B, E2, R2, EB extends MicroCause<E>>(
    self: Micro<A, E, R>,
    refinement: Refinement<MicroCause<E>, EB>,
    f: (cause: EB) => Micro<B, E2, R2>
  ): Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>
  <A, E, R, B, E2, R2>(
    self: Micro<A, E, R>,
    predicate: Predicate<MicroCause<NoInfer<E>>>,
    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
  ): Micro<A | B, E | E2, R | R2>
}

declare const catchIf: {
  <E, EB extends E, A2, E2, R2>(
    refinement: Refinement<NoInfer<E>, EB>,
    f: (e: EB) => Micro<A2, E2, R2>
  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
  <E, A2, E2, R2>(
    predicate: Predicate<NoInfer<E>>,
    f: (e: NoInfer<E>) => Micro<A2, E2, R2>
  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
  <A, E, R, EB extends E, A2, E2, R2>(
    self: Micro<A, E, R>,
    refinement: Refinement<E, EB>,
    f: (e: EB) => Micro<A2, E2, R2>
  ): Micro<A | A2, E2 | Exclude<E, EB>, R | R2>
  <A, E, R, A2, E2, R2>(
    self: Micro<A, E, R>,
    predicate: Predicate<E>,
    f: (e: E) => Micro<A2, E2, R2>
  ): Micro<A | A2, E | E2, R | R2>
}

declare const catchTag: {
  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
    k: K,
    f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
  ): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
  <A, E, R, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1, A1>(
    self: Micro<A, E, R>,
    k: K,
    f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
  ): Micro<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1>
}

declare const either: <A, E, R>(self: Micro<A, E, R>) => Micro<Either.Either<A, E>, never, R>

declare const ignore: <A, E, R>(self: Micro<A, E, R>) => Micro<void, never, R>

declare const ignoreLogged: <A, E, R>(self: Micro<A, E, R>) => Micro<void, never, R>

declare const mapError: {
  <E, E2>(f: (e: E) => E2): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>
  <A, E, R, E2>(self: Micro<A, E, R>, f: (e: E) => E2): Micro<A, E2, R>
}

declare const mapErrorCause: {
  <E, E2>(f: (e: MicroCause<E>) => MicroCause<E2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>
  <A, E, R, E2>(self: Micro<A, E, R>, f: (e: MicroCause<E>) => MicroCause<E2>): Micro<A, E2, R>
}

declare const option: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, never, R>

declare const orDie: <A, E, R>(self: Micro<A, E, R>) => Micro<A, never, R>

declare const orElseSucceed: {
  <B>(f: LazyArg<B>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | B, never, R>
  <A, E, R, B>(self: Micro<A, E, R>, f: LazyArg<B>): Micro<A | B, never, R>
}

declare const retry: {
  <A, E>(
    options?:
      | { while?: Predicate<E> | undefined; times?: number | undefined; schedule?: MicroSchedule | undefined }
      | undefined
  ): <R>(self: Micro<A, E, R>) => Micro<A, E, R>
  <A, E, R>(
    self: Micro<A, E, R>,
    options?:
      | { while?: Predicate<E> | undefined; times?: number | undefined; schedule?: MicroSchedule | undefined }
      | undefined
  ): Micro<A, E, R>
}

declare const tapDefect: {
  <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>
}