Micro

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

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

declare function filterMap<A, B, E, R>(iterable: Iterable<A>, f: (a: NoInfer<A>) => Micro<Option<B>, E, R>, options?: {
  readonly concurrency?: Concurrency;
}): 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;
    readonly discard?: false;
  }): 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;
    readonly discard: true;
  }): Micro<void, E, R>;
}

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

declare function 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 function die(defect: unknown): Micro<never>

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

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

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

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

declare function fromEither<R, L>(either: Either<R, L>): Micro<R, L>

declare function fromOption<A>(option: Option<A>): Micro<A, NoSuchElementException>

declare function 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<_A, E, _R>>] ? E : never, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<_A, _E, R>>] ? R : never>

declare const never: Micro<never>

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

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

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

declare function succeedSome<A>(a: A): Micro<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>

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

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>

declare const yieldNow: Micro<void>

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 function 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<A>, E, R>;
  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<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<A2 | A, E2 | E, R2 | R>;
  <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 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 string]: B }>, E2 | E, R2 | R>;
  <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 string]: B }>, E | E2, R | R2>;
}

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

declare const Do: Micro<{}>

declare function context<R>(): Micro<Context<R>>

declare const provideContext: {
  <XR>(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<XR>): Micro<A, E, Exclude<R, XR>>;
}

declare const provideService: {
  <I, S>(tag: 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: Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>;
}

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

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

declare function serviceOption<I, S>(tag: Tag<I, S>): Micro<Option<S>>

declare const updateContext: {
  <R2, R>(f: (context: Context<R2>) => 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<R2>) => Context<NoInfer<R>>): Micro<A, E, R2>;
}

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

declare class CurrentConcurrency extends TagClassShape<"effect/Micro/currentConcurrency", number | "unbounded", this> {
  constructor(_: never);
}

declare class CurrentScheduler extends TagClassShape<"effect/Micro/currentScheduler", MicroScheduler, this> {
  constructor(_: never);
}

declare const withConcurrency: {
  (concurrency: number | "unbounded"): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
  <A, E, R>(self: Micro<A, E, R>, concurrency: number | "unbounded"): 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<B | A, E2, R2 | R>;
  <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<B | A, E2, R2 | R>;
  <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<B | A, E | E2, R2 | R>;
  <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<B | A, E2 | Exclude<E, Error<EB>>, R2 | R>;
  <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<B | A, E | E2, R2 | R>;
  <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, E2 | Exclude<E, Error<EB>>, 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, 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, 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 string, 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 string, 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 function either<A, E, R>(self: Micro<A, E, R>): Micro<Either<A, E>, never, R>

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

declare function 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 function option<A, E, R>(self: Micro<A, E, R>): Micro<Option<A>, never, R>

declare function 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<B | A, 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?: {
    schedule?: MicroSchedule;
    times?: number;
    while?: Predicate<E>;
  }): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
  <A, E, R>(self: Micro<A, E, R>, options?: {
    schedule?: MicroSchedule;
    times?: number;
    while?: Predicate<E>;
  }): 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, R2 | R>;
  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
}

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

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

declare const tapErrorCauseIf: {
  <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R2 | R>;
  <E, B, E2, R2>(predicate: (cause: NoInfer<MicroCause<E>>) => boolean, f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R2 | R>;
  <A, E, R, B, E2, R2, EB extends MicroCause<E>>(self: Micro<A, E, R>, refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: (cause: NoInfer<MicroCause<E>>) => boolean, f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
}

declare const withTrace: {
  (name: string): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
  <A, E, R>(self: Micro<A, E, R>, name: string): Micro<A, E, R>;
}