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

export declare const all: All.Signature

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare const fiberId: STM<never, never, FiberId.FiberId>

export declare const filter: {
  <A, R, E>(predicate: (a: A) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, A[]>
  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, A[]>
}

export declare const filterNot: {
  <A, R, E>(predicate: (a: A) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, A[]>
  <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, A[]>
}

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

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

export declare const gen: <Eff extends STMGen<any, any, any>, AEff>(
  f: (resume: Adapter) => Generator<Eff, AEff, any>
) => STM<
  [Eff] extends [never] ? never : [Eff] extends [STMGen<infer R, any, any>] ? R : never,
  [Eff] extends [never] ? never : [Eff] extends [STMGen<any, infer E, any>] ? E : never,
  AEff
>

export declare const interrupt: STM<never, never, never>

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

const s = initial

while (cont(s)) {
  s = body(s)
}

return s

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

const as = []
let s = initial

while (cont(s)) {
  as.push(body(s))
  s = inc(s)
}

return as

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

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

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

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

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

export declare const replicate: {
  (n: number): <R, E, A>(self: STM<R, E, A>) => STM<R, E, A>[]
  <R, E, A>(self: STM<R, E, A>, n: number): STM<R, E, A>[]
}

export declare const replicateSTM: {
  (n: number): <R, E, A>(self: STM<R, E, A>) => STM<R, E, A[]>
  <R, E, A>(self: STM<R, E, A>, n: number): STM<R, E, A[]>
}

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

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

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

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

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

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

export declare const try: { <A, E>(options: { readonly try: LazyArg<A>; readonly catch: (u: unknown) => E; }): STM<never, E, A>; <A>(try_: LazyArg<A>): STM<never, unknown, A>; }

export declare const unit: STM<never, never, void>

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

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

export declare const provideService: {
  <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <R, E, A>(
    self: STM<R, E, A>
  ) => STM<Exclude<R, Context.Tag.Identifier<T>>, E, A>
  <R, E, A, T extends Context.Tag<any, any>>(self: STM<R, E, A>, tag: T, resource: Context.Tag.Service<T>): STM<
    Exclude<R, Context.Tag.Identifier<T>>,
    E,
    A
  >
}

export declare const provideServiceSTM: {
  <T extends Context.Tag<any, any>, R1, E1>(tag: T, stm: STM<R1, E1, Context.Tag.Service<T>>): <R, E, A>(
    self: STM<R, E, A>
  ) => STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A>
  <R, E, A, T extends Context.Tag<any, any>, R1, E1>(
    self: STM<R, E, A>,
    tag: T,
    stm: STM<R1, E1, Context.Tag.Service<T>>
  ): STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1, A>
}

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

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

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

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

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

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

export declare const let: {
  <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(
    self: STM<R, E, K>
  ) => STM<R, E, Effect.MergeRecord<K, { [k in N]: A }>>
  <R, E, K, N extends string, A>(self: STM<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): STM<
    R,
    E,
    Effect.MergeRecord<K, { [k in N]: A }>
  >
}

export declare const firstSuccessOf: <R, E, A>(effects: Iterable<STM<R, E, A>>) => STM<R, E, A>

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

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

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

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

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

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

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

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

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

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

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

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

export declare const retry: STM<never, never, never>

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

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

export declare const filterOrElse: {
  <A, B extends A, X extends A, R2, E2, A2>(refinement: Refinement<A, B>, orElse: (a: X) => STM<R2, E2, A2>): <R, E>(
    self: STM<R, E, A>
  ) => STM<R2 | R, E2 | E, B | A2>
  <A, X extends A, Y extends A, R2, E2, A2>(predicate: Predicate<X>, orElse: (a: Y) => STM<R2, E2, A2>): <R, E>(
    self: STM<R, E, A>
  ) => STM<R2 | R, E2 | E, A | A2>
  <R, E, A, B extends A, X extends A, R2, E2, A2>(
    self: STM<R, E, A>,
    refinement: Refinement<A, B>,
    orElse: (a: X) => STM<R2, E2, A2>
  ): STM<R | R2, E | E2, B | A2>
  <R, E, A, X extends A, Y extends A, R2, E2, A2>(
    self: STM<R, E, A>,
    predicate: Predicate<X>,
    orElse: (a: Y) => STM<R2, E2, A2>
  ): STM<R | R2, E | E2, A | A2>
}

export declare const filterOrFail: {
  <A, B extends A, X extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: X) => E2): <R, E>(
    self: STM<R, E, A>
  ) => STM<R, E2 | E, B>
  <A, X extends A, Y extends A, E2>(predicate: Predicate<X>, orFailWith: (a: Y) => E2): <R, E>(
    self: STM<R, E, A>
  ) => STM<R, E2 | E, A>
  <R, E, A, B extends A, X extends A, E2>(
    self: STM<R, E, A>,
    refinement: Refinement<A, B>,
    orFailWith: (a: X) => E2
  ): STM<R, E | E2, B>
  <R, E, A, X extends A, Y extends A, E2>(self: STM<R, E, A>, predicate: Predicate<X>, orFailWith: (a: Y) => E2): STM<
    R,
    E | E2,
    A
  >
}

export declare const ensuring: {
  <R1, B>(finalizer: STM<R1, never, B>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E, A>
  <R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1, never, B>): STM<R | R1, E, A>
}

export declare const match: {
  <E, A2, A, A3>(options: { readonly onFailure: (error: E) => A2; readonly onSuccess: (value: A) => A3 }): <R>(
    self: STM<R, E, A>
  ) => STM<R, never, A2 | A3>
  <R, E, A2, A, A3>(
    self: STM<R, E, A>,
    options: { readonly onFailure: (error: E) => A2; readonly onSuccess: (value: A) => A3 }
  ): STM<R, never, A2 | A3>
}

export declare const matchSTM: {
  <E, R1, E1, A1, A, R2, E2, A2>(options: {
    readonly onFailure: (e: E) => STM<R1, E1, A1>
    readonly onSuccess: (a: A) => STM<R2, E2, A2>
  }): <R>(self: STM<R, E, A>) => STM<R1 | R2 | R, E1 | E2, A1 | A2>
  <R, E, R1, E1, A1, A, R2, E2, A2>(
    self: STM<R, E, A>,
    options: { readonly onFailure: (e: E) => STM<R1, E1, A1>; readonly onSuccess: (a: A) => STM<R2, E2, A2> }
  ): STM<R | R1 | R2, E1 | E2, A1 | A2>
}

export declare const head: <R, E, A>(self: STM<R, E, Iterable<A>>) => STM<R, Option.Option<E>, A>

export declare const isFailure: <R, E, A>(self: STM<R, E, A>) => STM<R, never, boolean>

export declare const isSuccess: <R, E, A>(self: STM<R, E, A>) => STM<R, never, boolean>

export declare const some: <R, E, A>(self: STM<R, E, Option.Option<A>>) => STM<R, Option.Option<E>, A>

export declare const unsome: <R, E, A>(self: STM<R, Option.Option<E>, A>) => STM<R, E, Option.Option<A>>

export declare const as: {
  <A2>(value: A2): <R, E, A>(self: STM<R, E, A>) => STM<R, E, A2>
  <R, E, A, A2>(self: STM<R, E, A>, value: A2): STM<R, E, A2>
}

export declare const asSome: <R, E, A>(self: STM<R, E, A>) => STM<R, E, Option.Option<A>>

export declare const asSomeError: <R, E, A>(self: STM<R, E, A>) => STM<R, Option.Option<E>, A>