utils

export interface Subject<in out A, in out E = never, out R = never>
  extends Push<A, E, R, A, E, R | Scope.Scope>,
    Pipeable.Pipeable {
  readonly subscriberCount: Effect.Effect<number, never, R>
  readonly interrupt: Effect.Effect<void, never, R>
}

export interface Tagged<A, E, I> extends Subject<A, E, I> {
  readonly tag: C.Tagged<I, Subject<A, E>>

  readonly make: (replay?: number) => Layer.Layer<I>
  readonly provide: Provide<I>
}

export type Provide<I> = <
  const Args extends readonly [Fx<any, any, any> | Effect.Effect<any, any, any>, number?] | readonly [number]
>(
  ...args: Args
) => Args extends readonly [infer _ extends number]
  ? <T extends Fx<any, any, any> | Effect.Effect<any, any, any>>(
      fxOrEffect: T
    ) => [T] extends [Fx<infer B, infer E2, infer R2>]
      ? Fx<B, E2, Exclude<R2, I>>
      : [T] extends [Effect.Effect<infer B, infer E2, infer R2>]
        ? Effect.Effect<B, E2, Exclude<R2, I>>
        : never
  : Args extends readonly [Fx<infer B, infer E2, infer R2>]
    ? Fx<B, E2, Exclude<R2, I>>
    : Args extends readonly [Effect.Effect<infer B, infer E2, infer R2>]
      ? Effect.Effect<B, E2, Exclude<R2, I>>
      : never

export declare function fromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => Subject<A, E, R>): Subject<A, E, I | R>

export declare function make<A, E>(replay?: number): Effect.Effect<Subject<A, E>, never, Scope.Scope>

export declare function tagged<A, E = never>(): {
  <const I extends C.IdentifierFactory<any>>(identifier: I): Subject.Tagged<A, E, C.IdentifierOf<I>>
  <const I>(identifier: I): Subject.Tagged<A, E, C.IdentifierOf<I>>
}

export declare function unsafeMake<A, E = never>(replay: number = 0): Subject<A, E>