STM

declare const acquireUseRelease: {
  <A, A2, E2, R2, A3, E3, R3>(use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): <E, R>(acquire: STM<A, E, R>) => Effect<A2, E2 | E3 | E, R2 | R3 | R>;
  <A, E, R, A2, E2, R2, A3, E3, R3>(acquire: STM<A, E, R>, use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): Effect<A2, E | E2 | E3, R | R2 | R3>;
}

declare const all: All.Signature

declare const attempt: <A>(evaluate: LazyArg<A>) => STM<A, unknown>

declare const check: (predicate: LazyArg<boolean>) => STM<void>

declare const cond: <A, E>(predicate: LazyArg<boolean>, error: LazyArg<E>, result: LazyArg<A>) => STM<A, E>

declare const context: <R>() => STM<Context.Context<R>, never, R>

declare const contextWith: <R0, R>(f: (environment: Context.Context<R0>) => R) => STM<R, never, R0>

declare const contextWithSTM: <R0, A, E, R>(f: (environment: Context.Context<R0>) => STM<A, E, R>) => STM<A, E, R0 | R>

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

declare const dieMessage: (message: string) => STM<never>

declare const dieSync: (evaluate: LazyArg<unknown>) => STM<never>

declare const every: {
  <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<boolean, E, R>;
  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<boolean, E, R>;
}

declare const exists: {
  <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<boolean, E, R>;
  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<boolean, E, R>;
}

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

declare const failSync: <E>(evaluate: LazyArg<E>) => STM<never, E>

declare const fiberId: STM<FiberId.FiberId>

declare const filter: {
  <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<Array<A>, E, R>;
  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<Array<A>, E, R>;
}

declare const filterNot: {
  <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<Array<A>, E, R>;
  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<Array<A>, E, R>;
}

declare const fromEither: <A, E>(either: Either.Either<A, E>) => STM<A, E>

declare const fromOption: <A>(option: Option.Option<A>) => STM<A, Option.Option<never>>

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

declare const interrupt: STM<never>

declare const interruptAs: (fiberId: FiberId.FiberId) => STM<never>

declare const iterate: <Z, E, R>(initial: Z, options: {
  readonly body: (z: Z) => STM<Z, E, R>;
  readonly while: Predicate<Z>;
}) => STM<Z, E, R>

declare const loop: {
  <Z, A, E, R>(initial: Z, options: {
    readonly body: (z: Z) => STM<A, E, R>;
    readonly discard?: false;
    readonly step: (z: Z) => Z;
    readonly while: (z: Z) => boolean;
  }): STM<Array<A>, E, R>;
  <Z, A, E, R>(initial: Z, options: {
    readonly body: (z: Z) => STM<A, E, R>;
    readonly discard: true;
    readonly step: (z: Z) => Z;
    readonly while: (z: Z) => boolean;
  }): STM<void, E, R>;
}

declare const mergeAll: {
  <A2, A>(zero: A2, f: (a2: A2, a: A) => A2): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A2, E, R>;
  <A, E, R, A2>(iterable: Iterable<STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM<A2, E, R>;
}

declare const reduce: {
  <S, A, E, R>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
  <S, A, E, R>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
}

declare const reduceAll: {
  <A, E2, R2>(initial: STM<A, E2, R2>, f: (x: A, y: A) => A): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>;
  <A, E, R, E2, R2>(iterable: Iterable<STM<A, E, R>>, initial: STM<A, E2, R2>, f: (x: A, y: A) => A): STM<A, E | E2, R | R2>;
}

declare const reduceRight: {
  <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
  <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
}

declare const replicate: {
  (n: number): <A, E, R>(self: STM<A, E, R>) => Array<STM<A, E, R>>;
  <A, E, R>(self: STM<A, E, R>, n: number): Array<STM<A, E, R>>;
}

declare const replicateSTM: {
  (n: number): <A, E, R>(self: STM<A, E, R>) => STM<Array<A>, E, R>;
  <A, E, R>(self: STM<A, E, R>, n: number): STM<Array<A>, E, R>;
}

declare const replicateSTMDiscard: {
  (n: number): <A, E, R>(self: STM<A, E, R>) => STM<void, E, R>;
  <A, E, R>(self: STM<A, E, R>, n: number): STM<void, E, R>;
}

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

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

declare const succeedSome: <A>(value: A) => STM<Option.Option<A>>

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

declare const sync: <A>(evaluate: () => A) => STM<A>

declare const mapInputContext: {
  <R0, R>(f: (context: Context<R0>) => Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E, R0>;
  <A, E, R0, R>(self: STM<A, E, R>, f: (context: Context<R0>) => Context<R>): STM<A, E, R0>;
}

declare const provideContext: {
  <R>(env: Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E>;
  <A, E, R>(self: STM<A, E, R>, env: Context<R>): STM<A, E>;
}

declare const provideService: {
  <I, S>(tag: Tag<I, S>, resource: NoInfer<S>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, Exclude<R, I>>;
  <A, E, R, I, S>(self: STM<A, E, R>, tag: Tag<I, S>, resource: NoInfer<S>): STM<A, E, Exclude<R, I>>;
}

declare const provideServiceSTM: {
  <I, S, E1, R1>(tag: Tag<I, S>, stm: STM<NoInfer<S>, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, I>>;
  <A, E, R, I, S, E1, R1>(self: STM<A, E, R>, tag: Tag<I, S>, stm: STM<NoInfer<S>, E1, R1>): STM<A, E | E1, R1 | Exclude<R, I>>;
}

declare const provideSomeContext: {
  <R>(context: Context<R>): <R1, E, A>(self: STM<A, E, R1>) => STM<A, E, Exclude<R1, R>>;
  <R, R1, E, A>(self: STM<A, E, R1>, context: Context<R>): STM<A, E, Exclude<R1, R>>;
}

declare const commit: <A, E, R>(self: STM<A, E, R>) => Effect.Effect<A, E, R>

declare const commitEither: <A, E, R>(self: STM<A, E, R>) => Effect.Effect<A, E, R>

declare const bind: {
  <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: NoInfer<K>) => STM<A, E2, R2>): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, { [k in string]: A }>, E2 | E, R2 | R>;
  <K, E, R, N extends string, A, E2, R2>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: NoInfer<K>) => STM<A, E2, R2>): STM<MergeRecord<K, { [k in string]: A }>, E | E2, R | R2>;
}

declare const bindTo: {
  <N extends string>(tag: N): <A, E, R>(self: STM<A, E, R>) => STM<Record<N, A>, E, R>;
  <A, E, R, N extends string>(self: STM<A, E, R>, tag: N): STM<Record<N, A>, E, R>;
}

declare const Do: STM<{}>

declare function firstSuccessOf<A, E, R>(effects: Iterable<STM<A, E, R>>): STM<A, E, R>

declare const catchAll: {
  <E, B, E1, R1>(f: (e: E) => STM<B, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<B | A, E1, R1 | R>;
  <A, E, R, B, E1, R1>(self: STM<A, E, R>, f: (e: E) => STM<B, E1, R1>): STM<A | B, E1, R | R1>;
}

declare const catchSome: {
  <E, A2, E2, R2>(pf: (error: E) => Option<STM<A2, E2, R2>>): <A, R>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>;
  <A, E, R, A2, E2, R2>(self: STM<A, E, R>, pf: (error: E) => Option<STM<A2, E2, R2>>): STM<A | A2, E | E2, R | R2>;
}

declare const catchTag: {
  <K extends string, E extends {
    _tag: string;
  }, A1, E1, R1>(k: K, f: (e: Extract<E, {
    _tag: K;
  }>) => STM<A1, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, {
    _tag: K;
  }>, R1 | R>;
  <A, E extends {
    _tag: string;
  }, R, K extends string, A1, E1, R1>(self: STM<A, E, R>, k: K, f: (e: Extract<E, {
    _tag: K;
  }>) => STM<A1, E1, R1>): STM<A | A1, E1 | Exclude<E, {
    _tag: K;
  }>, R | R1>;
}

declare const catchTags: {
  <E extends {
    _tag: string;
  }, Cases extends { [K in string]: (error: Extract<E, {
    _tag: K;
  }>) => STM<any, any, any> }>(cases: Cases): <A, R>(self: STM<A, E, R>) => STM<A | { [K in string | number | symbol]: Cases[K] extends (...args: Array<any>) => STM<A, any, any> ? A : never }[keyof Cases], Exclude<E, {
    _tag: keyof Cases;
  }> | { [K in string | number | symbol]: Cases[K] extends (...args: Array<any>) => STM<any, E, any> ? E : never }[keyof Cases], R | { [K in string | number | symbol]: Cases[K] extends (...args: Array<any>) => STM<any, any, R> ? R : never }[keyof Cases]>;
  <R, E extends {
    _tag: string;
  }, A, Cases extends { [K in string]: (error: Extract<E, {
    _tag: K;
  }>) => STM<any, any, any> }>(self: STM<A, E, R>, cases: Cases): STM<A | { [K in string | number | symbol]: Cases[K] extends (...args: Array<any>) => STM<A, any, any> ? A : never }[keyof Cases], Exclude<E, {
    _tag: keyof Cases;
  }> | { [K in string | number | symbol]: Cases[K] extends (...args: Array<any>) => STM<any, E, any> ? E : never }[keyof Cases], R | { [K in string | number | symbol]: Cases[K] extends (...args: Array<any>) => STM<any, any, R> ? R : never }[keyof Cases]>;
}

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

declare const orDieWith: {
  <E>(f: (error: E) => unknown): <A, R>(self: STM<A, E, R>) => STM<A, never, R>;
  <A, E, R>(self: STM<A, E, R>, f: (error: E) => unknown): STM<A, never, R>;
}

declare const orElse: {
  <A2, E2, R2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, E2, R2 | R>;
  <A, E, R, A2, E2, R2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<A | A2, E2, R | R2>;
}

declare const orElseEither: {
  <A2, E2, R2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<Either<A2, A>, E2, R2 | R>;
  <A, E, R, A2, E2, R2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<Either<A2, A>, E2, R | R2>;
}

declare const orElseFail: {
  <E2>(error: LazyArg<E2>): <A, E, R>(self: STM<A, E, R>) => STM<A, E2, R>;
  <A, E, R, E2>(self: STM<A, E, R>, error: LazyArg<E2>): STM<A, E2, R>;
}

declare const orElseOptional: {
  <A2, E2, R2>(that: LazyArg<STM<A2, Option<E2>, R2>>): <A, E, R>(self: STM<A, Option<E>, R>) => STM<A2 | A, Option<E2 | E>, R2 | R>;
  <A, E, R, A2, E2, R2>(self: STM<A, Option<E>, R>, that: LazyArg<STM<A2, Option<E2>, R2>>): STM<A | A2, Option<E | E2>, R | R2>;
}

declare const orElseSucceed: {
  <A2>(value: LazyArg<A2>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, never, R>;
  <A, E, R, A2>(self: STM<A, E, R>, value: LazyArg<A2>): STM<A | A2, never, R>;
}

declare const orTry: {
  <A1, E1, R1>(that: LazyArg<STM<A1, E1, R1>>): <A, E, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | E, R1 | R>;
  <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: LazyArg<STM<A1, E1, R1>>): STM<A | A1, E | E1, R | R1>;
}

declare const retry: STM<never>

declare const filterOrDie: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
  <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
  <A, E, R, B>(self: STM<A, E, R>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<B, E, R>;
  <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM<A, E, R>;
}

declare const filterOrDieMessage: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>, message: string): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
  <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
  <A, E, R, B>(self: STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM<B, E, R>;
  <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, message: string): STM<A, E, R>;
}

declare const filterOrElse: {
  <A, B, C, E2, R2>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => STM<C, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<B | C, E2 | E, R2 | R>;
  <A, B, E2, R2>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => STM<B, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<A | B, E2 | E, R2 | R>;
  <A, E, R, B, C, E2, R2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => STM<C, E2, R2>): STM<B | C, E | E2, R | R2>;
  <A, E, R, B, E2, R2>(self: STM<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => STM<B, E2, R2>): STM<A | B, E | E2, R | R2>;
}