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>;
};

declare const Error: <A extends Record<string, any> = {}>(
  args: Equals<A, {}> extends true ? void : { [P in keyof A]: A[P] },
) => YieldableError & Readonly<A>;

declare class NoSuchElementException extends YieldableError<this> & {
  readonly _tag: "NoSuchElementException";
} & Readonly<{
  message?: string;
}> {
  constructor(args: {
    readonly message?: string;
  });
}

declare function TaggedError<Tag extends string>(
  tag: Tag,
): <A extends Record<string, any> = {}>(
  args: Equals<A, {}> extends true ? void : { [P in string | number | symbol]: A[P] },
) => YieldableError & {
  readonly _tag: Tag;
} & Readonly<A>;

declare class TimeoutException extends YieldableError<this> & {
  readonly _tag: "TimeoutException";
} & Readonly<{}> {
  constructor(args: void);
}

interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
  readonly [ChannelTypeId]: VarianceStruct<
    never,
    unknown,
    YieldableError,
    unknown,
    never,
    unknown,
    never
  >;
  readonly [EffectTypeId]: VarianceStruct<never, YieldableError, never>;
  readonly [SinkTypeId]: VarianceStruct<never, unknown, never, YieldableError, never>;
  readonly [StreamTypeId]: VarianceStruct<never, YieldableError, never>;
  readonly [TypeId]: Variance<never, YieldableError, never>;
  [iterator](): MicroIterator<Micro<never, YieldableError, never>>;
}

declare function runFork<A, E>(
  effect: Micro<A, E>,
  options?: {
    readonly scheduler?: MicroScheduler;
    readonly signal?: AbortSignal;
  },
): MicroFiberImpl<A, E>;

declare function runPromise<A, E>(
  effect: Micro<A, E>,
  options?: {
    readonly scheduler?: MicroScheduler;
    readonly signal?: AbortSignal;
  },
): Promise<A>;

declare function runPromiseExit<A, E>(
  effect: Micro<A, E>,
  options?: {
    readonly scheduler?: MicroScheduler;
    readonly signal?: AbortSignal;
  },
): Promise<MicroExit<A, E>>;

declare function runSync<A, E>(effect: Micro<A, E>): A;

declare function runSyncExit<A, E>(effect: Micro<A, E>): MicroExit<A, E>;

declare function fork<A, E, R>(self: Micro<A, E, R>): Micro<MicroFiber<A, E>, never, R>;

declare function forkDaemon<A, E, R>(self: Micro<A, E, R>): Micro<MicroFiber<A, E>, never, R>;

declare const forkIn: {
  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R>;
  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<MicroFiber<A, E>, never, R>;
};

declare function forkScoped<A, E, R>(
  self: Micro<A, E, R>,
): Micro<MicroFiber<A, E>, never, MicroScope | R>;

declare const filterOrFail: {
  <A, B, E2>(
    refinement: Refinement<A, B>,
    orFailWith: (a: NoInfer<A>) => E2,
  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>;
  <A, E2>(
    predicate: Predicate<NoInfer<A>>,
    orFailWith: (a: NoInfer<A>) => E2,
  ): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>;
  <A, E, R, B, E2>(
    self: Micro<A, E, R>,
    refinement: Refinement<A, B>,
    orFailWith: (a: A) => E2,
  ): Micro<B, E | E2, R>;
  <A, E, R, E2>(
    self: Micro<A, E, R>,
    predicate: Predicate<A>,
    orFailWith: (a: A) => E2,
  ): Micro<A, E | E2, R>;
};