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

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

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

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

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

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

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

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

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

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

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