export declare const get: <A, E>(self: RcRef<A, E>) => Effect.Effect<A, E, Scope.Scope>

export declare const make: <A, E, R>(options: {
  readonly acquire: Effect.Effect<A, E, R>
  readonly idleTimeToLive?: Duration.DurationInput | undefined
}) => Effect.Effect<RcRef<A, E>, never, R | Scope.Scope>

import { Effect, RcRef } from "effect"

Effect.gen(function* () {
  const ref = yield* RcRef.make({
    acquire: Effect.acquireRelease(Effect.succeed("foo"), () => Effect.log("release foo"))
  })

  // will only acquire the resource once, and release it
  // when the scope is closed
  yield* RcRef.get(ref).pipe(Effect.andThen(RcRef.get(ref)), Effect.scoped)
})

export interface RcRef<out A, out E = never>
  extends Effect.Effect<A, E, Scope.Scope>,
    Readable.Readable<A, E, Scope.Scope> {
  readonly [TypeId]: RcRef.Variance<A, E>
  readonly [Unify.typeSymbol]?: unknown
  readonly [Unify.unifySymbol]?: RcRefUnify<this>
  readonly [Unify.ignoreSymbol]?: RcRefUnifyIgnore
}

export interface Variance<A, E> {
  readonly _A: Types.Covariant<A>
  readonly _E: Types.Covariant<E>
}

export interface RcRefUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
  RcRef?: () => A[Unify.typeSymbol] extends RcRef<infer A0, infer E0> | infer _ ? RcRef<A0, E0> : never
}

export interface RcRefUnifyIgnore extends Effect.EffectUnifyIgnore {
  Effect?: true
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId