effect-app 2.19.4 → 2.19.5

package/src/Pure.ts

@@ -7,9 +7,6 @@ const S1 = Symbol()
 const S2 = Symbol()
 const W = Symbol()
 
-/**
- * @tsplus type PureEnv
- */
 export interface PureState<S, S2 = S> {
   readonly [S1]: (_: S) => void
   readonly [S2]: () => S2
@@ -17,17 +14,11 @@ export interface PureState<S, S2 = S> {
   state: S2
 }
 
-/**
- * @tsplus type PureEnv
- */
 export interface PureLog<W> {
   readonly [W]: () => W
   log: Chunk.Chunk<W>
 }
 
-/**
- * @tsplus type PureEnv
- */
 export interface PureEnv<W, S, S2 = S> extends PureState<S, S2>, PureLog<W> {}
 
 export interface PureEnvTest extends PureState<any>, PureLog<any> {}
@@ -49,9 +40,6 @@ export function makePureEnv<W, S, S2 = S>(s: S2): PureEnv<W, S, S2> {
   return new PureEnvBase<W, S, S2>(s)
 }
 
-/**
- * @tsplus unify PureEnv
- */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function unifyPureEnv<X extends PureEnv<any, any, any>>(
   self: X
@@ -64,16 +52,10 @@ export function unifyPureEnv<X extends PureEnv<any, any, any>>(
   return self
 }
 
-/**
- * @tsplus type Pure
- */
 export type Pure<W, S, S2, R, E, A> = Effect.Effect<A, E, PureEnvEnv<W, S, S2> | R>
 
 // type dsl<W, S, S2> = ProgramDSL<W, S, S2>
 
-/**
- * @tsplus static Pure.Ops GMUA_
- */
 export function GMUA_<W, S, S2, GR, GE, GA, MR, ME, MA, UR, UE, UA>(
   get: Pure<W, S, S2, GR, GE, GA>,
   modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>,
@@ -82,9 +64,6 @@ export function GMUA_<W, S, S2, GR, GE, GA, MR, ME, MA, UR, UE, UA>(
   return Effect.flatMap(get, modify).pipe(Effect.flatMap(([s, a]) => Effect.map(update(s), () => a)))
 }
 
-/**
- * @tsplus static Pure.Ops GMUA
- */
 export function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>) {
   return <GR, GE, UR, UE, UA>(
     get: Pure<W, S, S2, GR, GE, GA>,
@@ -92,10 +71,6 @@ export function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2,
   ) => GMUA_(get, modify, update)
 }
 
-/**
- * @tsplus static Pure.Ops GMU_
- */
-
 export function GMU_<W, S, S2, GR, GE, GA, MR, ME, UR, UE, UA>(
   get: Pure<W, S, S2, GR, GE, GA>,
   modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>,
@@ -104,9 +79,6 @@ export function GMU_<W, S, S2, GR, GE, GA, MR, ME, UR, UE, UA>(
   return Effect.flatMap(get, modify).pipe(Effect.flatMap(update))
 }
 
-/**
- * @tsplus static Pure.Ops GMU
- */
 export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>) {
   return <GR, GE, UR, UE, UA>(
     get: Pure<W, S, S2, GR, GE, GA>,
@@ -124,40 +96,24 @@ export interface PureEnvEnv<W, S, S2> extends Context.ServiceTagged<typeof PureE
   env: PureEnv<W, S, S2>
 }
 
-/**
- * @tsplus static Pure.Ops get
- */
 export function get<S>(): Pure<never, S, S, never, never, S> {
   return Effect.map(castTag<never, S, S>(), (_) => _.env.state)
 }
 
-/**
- * @tsplus static Pure.Ops set
- */
 export function set<S>(s: S): Pure<never, S, S, never, never, void> {
   return Effect.map(castTag<never, S, S>(), (_) => _.env.state = s)
 }
 
 export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
 
-/**
- * @tsplus static Pure.Ops log
- */
 export function log<W>(w: W): PureLogT<W> {
   return Effect.map(castTag<W, unknown, never>(), (_) => _.env.log = Chunk.append(_.env.log, w))
 }
 
-/**
- * @tsplus static Pure.Ops logMany
- */
 export function logMany<W>(w: Iterable<W>): PureLogT<W> {
   return Effect.map(castTag<W, unknown, never>(), (_) => _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w)))
 }
 
-/**
- * @tsplus static Pure.Ops runAll
- * @tsplus fluent effect/io/Effect runAll
- */
 export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -181,10 +137,6 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
-/**
- * @tsplus static Pure.Ops runResult
- * @tsplus fluent effect/io/Effect runResult
- */
 export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -192,10 +144,6 @@ export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Effect.map(r, ([s]) => s)))
 }
 
-/**
- * @tsplus static Pure.Ops runTerm
- * @tsplus fluent effect/io/Effect runTerm
- */
 export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -203,10 +151,6 @@ export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.flatMap(runAll(self, s), ([evts, r]) => Effect.map(r, ([s3, a]) => tuple(s3, Chunk.toArray(evts), a)))
 }
 
-/**
- * @tsplus static Pure.Ops runTermDiscard
- * @tsplus fluent effect/io/Effect runTermDiscard
- */
 export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -214,10 +158,6 @@ export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.map(runTerm(self, s), ([s3, w3]) => tuple(s3, w3))
 }
 
-/**
- * @tsplus static Pure.Ops runA
- * @tsplus fluent effect/io/Effect runA
- */
 export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -225,9 +165,6 @@ export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Effect.map(r, ([, a]) => a)))
 }
 
-/**
- * @tsplus static Pure.Ops modifyWith
- */
 export function modify<S2, A, S3>(
   mod: (s: S2) => readonly [S3, A]
 ): Effect.Effect<A, never, { env: PureEnv<never, S2, S3> }> {
@@ -238,9 +175,6 @@ export function modify<S2, A, S3>(
     })) as any
 }
 
-/**
- * @tsplus static Pure.Ops modifyWithEffect
- */
 export function modifyM<W, R, E, A, S2, S3>(
   mod: (s: S2) => Effect.Effect<readonly [S3, A], E, FixEnv<R, W, S2, S3>>
 ): Effect.Effect<A, E, FixEnv<R, W, S2, S3>> {
@@ -251,9 +185,6 @@ export function modifyM<W, R, E, A, S2, S3>(
   ) as any
 }
 
-/**
- * @tsplus static Pure.Ops updateWith
- */
 export function updateWith<S2, S3>(upd: (s: S2) => S3) {
   return modify((_: S2) => {
     const r = upd(_)
@@ -261,9 +192,6 @@ export function updateWith<S2, S3>(upd: (s: S2) => S3) {
   })
 }
 
-/**
- * @tsplus static Pure.Ops updateWithEffect
- */
 export function updateWithEffect<W, R, E, S2, S3>(
   upd: (s: S2, log: (evt: W) => PureLogT<W>) => Effect.Effect<S3, E, FixEnv<R, W, S2, S3>>
 ): Effect.Effect<S3, E, FixEnv<R, W, S2, S3>> {
@@ -278,9 +206,6 @@ export type FixEnv<R, W, S, S2> =
 //   return Effect.accessM((_: PureState<S>) => Ref.get(_.state).map(self))
 // }
 
-// /**
-//  * @tsplus static Pure.Ops getM
-//  */
 // export function getM<W, S, R, E, A>(self: (s: S) => Pure<W, S, R, E, A>): Pure<W, S, R, E, A> {
 //   return Effect.accessM((_: PureState<S>) => Ref.get(_.state).flatMap(self))
 // }
@@ -298,25 +223,6 @@ export type FixEnv<R, W, S, S2> =
 //   return (self: (s: S) => Pure<W, S, R, E, A>) => access(_ => Ref.get(_.state).flatMap(self))
 // }
 
-/**
- * @tsplus type Pure.Ops
- */
-export interface PureOps {
-  // $: PureAspects
-}
-
-// /**
-//  * @tsplus type Pure.Ops
-//  */
-
-// export interface PureAspects {}
-export const Pure: PureOps = {
-  // $: {}
-}
-
-// /**
-//  * @tsplus static Pure.Ops makeDSL
-//  */
 // export function makeProgramDSL<W, S, S2 = S>(): ProgramDSL<W, S, S2> {
 //   return makeDSL_<W,S, S2>()
 // }
@@ -422,35 +328,20 @@ export const Pure: PureOps = {
 
 // type dsl_<W,S, S2 = S> = ReturnType<typeof makeDSL_<W, S, S2>>
 
-// /**
-//  * @tsplus type Pure/DSL
-//  */
 // export interface ProgramDSL<W, S, S2 = S> extends dsl_<W, S, S2> { }
 
-// /**
-//  * @tsplus fluent Pure/DSL modifyWithEffect
-//  */
 // export function dslmodifyM<W, S, R, E, A>(dsl: ProgramDSL<W, S>, mod: (s: S, dsl: ProgramDSL<W, S>) => Effect.Effect<R, E, readonly [S, A]>) {
 //     return dsl.modifyM(_ => mod(_, dsl))
 // }
 
-// /**
-//  * @tsplus fluent Pure/DSL modifyWith
-//  */
 // export function dslmodify<W, S, A>(dsl: ProgramDSL<W, S>, mod: (s: S, dsl: ProgramDSL<W, S>) => readonly [S, A]) {
 //     return dsl.modify(_ => mod(_, dsl))
 // }
 
-// /**
-//  * @tsplus fluent Pure/DSL updateWithEffect
-//  */
 // export function dslupdateM<W, S, R, E, S2, S3>(dsl: ProgramDSL<W, S, S2>, upd: (s: S2, dsl: ProgramDSL<W, S, S2>) => Effect.Effect<R, E, S3>) {
 //     return dsl.updateM(_ => upd(_, dsl))
 // }
 
-// /**
-//  * @tsplus fluent Pure/DSL updateWith
-//  */
 // export function dslupdate<W, S>(dsl: ProgramDSL<W, S>, upd: (s: S, dsl: ProgramDSL<W, S>) => S) {
 //     return dsl.update(_ => upd(_, dsl))
 // }

package/src/Schema/ext.ts

@@ -125,9 +125,6 @@ export const defaultMap = <A, A2, I, R>(s: Schema<ReadonlyMap<A, A2>, I, R>) =>
 export const defaultSet = <A, I, R>(s: Schema<ReadonlySet<A>, I, R>) =>
   s.pipe(withDefaultConstructor(() => new Set<A>()))
 
-/**
- * @tsplus getter effect/schema/Schema withDefaultMake
- */
 export const withDefaultMake = <Self extends S.Schema<any, any, never>>(s: Self) => {
   const a = Object.assign(S.decodeSync(s) as WithDefaults<Self>, s)
   Object.setPrototypeOf(a, s)

package/src/Set.ts

@@ -6,9 +6,6 @@ import { not } from "effect/Predicate"
 import type { Predicate, Refinement } from "./Function.js"
 import { identity, pipe, tuple } from "./Function.js"
 
-/**
- * @tsplus fluent ets/Set find
- */
 export function find_<A, B extends A>(
   as: ReadonlySet<A>,
   refinement: Refinement<A, B>
@@ -18,9 +15,6 @@ export function find_<A>(set: ReadonlySet<A>, predicate: Predicate<A>) {
   return [...set].find(predicate)
 }
 
-/**
- * @tsplus fluent ets/Set findFirst
- */
 export function findFirst_<A, B extends A>(
   set: ReadonlySet<A>,
   refinement: Refinement<A, B>
@@ -30,9 +24,6 @@ export function findFirst_<A>(set: ReadonlySet<A>, predicate: Predicate<A>): Opt
   return Option.fromNullable([...set].find(predicate))
 }
 
-/**
- * @tsplus fluent ets/Set findFirstMap
- */
 export function findFirstMap_<A, B>(
   set: ReadonlySet<A>,
   f: (a: A) => Option.Option<B>
@@ -152,7 +143,6 @@ export function some<A>(predicate: Predicate<A>): (set: Set<A>) => boolean {
 
 /**
  * true if one or more elements match predicate
- * @tsplus fluent ets/Set some
  */
 export function some_<A>(set: Set<A>, predicate: Predicate<A>): boolean {
   return some(predicate)(set)
@@ -256,7 +246,6 @@ export function filter<A>(predicate: Predicate<A>): (set: Set<A>) => Set<A> {
 
 /**
  * Filter set values using predicate
- * @tsplus fluent ets/Set filter
  */
 export function filter_<A, B extends A>(
   set: Set<A>,

package/src/Tag.ts

@@ -1,20 +1,11 @@
-// /**
-//  * @tsplus fluent effect/data/Context/Tag withEffect_
-//  */
 // export function accessM_<T, I, R, E, A>(self: Tag<T, I>, f: (x: T) => Effect<R, E, A>) {
 //   return Effect.serviceWithEffect(self)(f)
 // }
 
 import { Layer } from "effect"
 
-// /**
-//  * @tsplus fluent effect/data/Context/Tag with_
-//  */
 // export function access_<T, I, B>(self: Tag<T, I>, f: (x: T) => B) {
 //   return Effect.serviceWith(self)(f)
 // }
 
-/**
- * @tsplus fluent effect/data/Context/Tag makeLayer
- */
 export const makeLayer = Layer.succeed

package/src/Unify.ts

@@ -4,9 +4,6 @@
 import type { Chunk, Either, Option } from "effect"
 import type { Effect, EffectTypeId } from "effect/Effect"
 
-/**
- * @tsplus unify effect/io/Effect
- */
 export function unifyEffect<X extends { readonly [EffectTypeId]: Effect.VarianceStruct<any, any, any> }>(
   self: X
 ): Effect<
@@ -17,20 +14,12 @@ export function unifyEffect<X extends { readonly [EffectTypeId]: Effect.Variance
   return self as any
 }
 
-/**
- * @tsplus unify effect/data/Chunk
- */
 export function unifyChunk<X extends Chunk.Chunk<any>>(
   self: X
 ): Chunk.Chunk<[X] extends [Chunk.Chunk<infer A>] ? A : never> {
   return self
 }
 
-/**
- * @tsplus unify effect/data/Either
- * @tsplus unify effect/data/Either.Left
- * @tsplus unify effect/data/Either.Right
- */
 export function unifyEither<X extends Either.Either<any, any>>(
   self: X
 ): Either.Either<
@@ -40,11 +29,6 @@ export function unifyEither<X extends Either.Either<any, any>>(
   return self
 }
 
-/**
- * @tsplus unify effect/data/Option
- * @tsplus unify effect/data/Option.Some
- * @tsplus unify effect/data/Option.None
- */
 export function unifyOption<X extends Option.Option<any>>(
   self: X
 ): Option.Option<

package/src/_ext/date.ts

@@ -15,70 +15,28 @@ import {
   subYears
 } from "date-fns"
 
-/**
- * @tsplus fluent Date addDays
- */
 export const DateAddDays: (date: Date, amount: number) => Date = addDays
-/**
- * @tsplus fluent Date subDays
- */
 export const DateSubDays: (date: Date, amount: number) => Date = subDays
 
-/**
- * @tsplus fluent Date addHours
- */
 export const DateAddHours: (date: Date, amount: number) => Date = addHours
-/**
- * @tsplus fluent Date subHours
- */
 export const DateSubHours: (date: Date, amount: number) => Date = subHours
 
-/**
- * @tsplus fluent Date addMinutes
- */
 export const DateAddMinutes: (date: Date, amount: number) => Date = addMinutes
 
-/**
- * @tsplus fluent Date subMinutes
- */
 export const DateSubMinutes: (date: Date, amount: number) => Date = subMinutes
 
-/**
- * @tsplus fluent Date addSeconds
- */
 export const DateAddSeconds: (date: Date, amount: number) => Date = addSeconds
 
-/**
- * @tsplus fluent Date subSeconds
- */
 export const DateSubSeconds: (date: Date, amount: number) => Date = subSeconds
 
-/**
- * @tsplus fluent Date addYears
- */
 export const DateAddYears: (date: Date, amount: number) => Date = addYears
 
-/**
- * @tsplus fluent Date subYears
- */
 export const DateSubYears: (date: Date, amount: number) => Date = subYears
 
-/**
- * @tsplus fluent Date addMonths
- */
 export const DateAddMonths: (date: Date, amount: number) => Date = addMonths
 
-/**
- * @tsplus fluent Date subMonths
- */
 export const DateSubMonths: (date: Date, amount: number) => Date = subMonths
 
-/**
- * @tsplus fluent Date addWeeks
- */
 export const DateAddWeeks: (date: Date, amount: number) => Date = addWeeks
 
-/**
- * @tsplus fluent Date subWeeks
- */
 export const DateSubWeeks: (date: Date, amount: number) => Date = subWeeks

package/src/_ext/misc.ts

@@ -11,9 +11,6 @@ export type _E<T extends Effect.Effect<any, any, any>> = [T] extends [
 ] ? E
   : never
 
-/**
- * @tsplus fluent effect/data/Option encaseInEffect
- */
 export function encaseMaybeInEffect_<E, A>(
   o: Option.Option<A>,
   onError: LazyArg<E>
@@ -21,9 +18,6 @@ export function encaseMaybeInEffect_<E, A>(
   return Option.match(o, { onNone: () => Effect.fail(onError()), onSome: Effect.succeed })
 }
 
-/**
- * @tsplus fluent effect/data/Option encaseInEither
- */
 export function encaseMaybeEither_<E, A>(
   o: Option.Option<A>,
   onError: LazyArg<E>
@@ -31,18 +25,12 @@ export function encaseMaybeEither_<E, A>(
   return Option.match(o, { onNone: () => Either.left(onError()), onSome: Either.right })
 }
 
-/**
- * @tsplus getter effect/io/Effect toNullable
- */
 export function toNullable<R, E, A>(
   self: Effect.Effect<Option.Option<A>, E, R>
 ) {
   return Effect.map(self, (_) => Option.getOrNull(_))
 }
 
-/**
- * @tsplus fluent effect/io/Effect scope
- */
 export function scope<R, E, A, R2, E2, A2>(
   scopedEffect: Effect.Effect<A, E, R | Scope.Scope>,
   effect: Effect.Effect<A2, E2, R2>
@@ -50,32 +38,9 @@ export function scope<R, E, A, R2, E2, A2>(
   return Effect.zipRight(scopedEffect, effect).pipe(Effect.scoped)
 }
 
-/**
- * @tsplus fluent effect/io/Effect flatMapScoped
- */
 export function flatMapScoped<R, E, A, R2, E2, A2>(
   scopedEffect: Effect.Effect<A, E, R | Scope.Scope>,
   effect: (a: A) => Effect.Effect<A2, E2, R2>
 ): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>> {
   return scopedEffect.pipe(Effect.flatMap(effect), Effect.scoped)
 }
-
-// /**
-//  * @tsplus fluent effect/io/Effect withScoped
-//  */
-// export function withScoped<R, E, A, R2, E2, A2>(
-//   effect: Effect.Effect<R2, E2, A2>,
-//   scopedEffect: Effect.Effect<R | Scope.Scope, E, A>
-// ): Effect.Effect<Exclude<R | R2, Scope.Scope>, E | E2, A2> {
-//   return scopedEffect.zipRight(effect).scoped
-// }
-
-// /**
-//  * @tsplus fluent effect/io/Effect withScoped
-//  */
-// export function withScopedFlatMap<R, E, A, R2, E2, A2>(
-//   effect: (a: A) => Effect.Effect<R2, E2, A2>,
-//   scopedEffect: Effect.Effect<R | Scope.Scope, E, A>
-// ): Effect.Effect<Exclude<R | R2, Scope.Scope>, E | E2, A2> {
-//   return scopedEffect.flatMap(effect).scoped
-// }

package/src/_ext/ord.ext.ts

@@ -1,9 +1,6 @@
 import { Chunk } from "effect"
 import type { Equivalence } from "effect"
 
-/**
- * @tsplus getter Generator toArray
- */
 export function toArray<A>(
   gen: Generator<A, void, unknown>
 ) {
@@ -12,9 +9,6 @@ export function toArray<A>(
 
 /**
  * Remove duplicates from an array, keeping the first occurrence of an element.
- *
- * @tsplus static effect/data/Chunk.Ops uniq
- * @tsplus pipeable effect/data/Chunk uniq
  */
 export function uniq<A>(E: Equivalence.Equivalence<A>) {
   return (self: Chunk.Chunk<A>): Chunk.Chunk<A> => {
@@ -33,9 +27,6 @@ export function uniq<A>(E: Equivalence.Equivalence<A>) {
  * Test if a value is a member of an array. Takes a `Equivalence.Equivalence<A>` as a single
  * argument which returns the function to use to search for a value of type `A`
  * in an array of type `Chunk.Chunk<A>`.
- *
- * @tsplus static effect/data/Chunk.Ops elem2
- * @tsplus pipeable effect/data/Chunk elem2
  */
 export function elem<A>(E: Equivalence.Equivalence<A>, value: A) {
   return (self: Chunk.Chunk<A>): boolean => {

package/src/ids.ts

@@ -9,9 +9,6 @@ export interface RequestIdBrand extends StringIdBrand {
   readonly RequestId: unique symbol
 }
 
-/**
- * @tsplus type RequestId
- */
 export type RequestId = NonEmptyString255
 // a request id may be made from a span id, which does not comply with StringId schema.
 export const RequestId = extendM(
@@ -29,8 +26,5 @@ export const RequestId = extendM(
   .pipe(withDefaultMake)
 
 export interface UserProfileIdBrand extends Simplify<B.Brand<"UserProfileId"> & StringIdBrand> {}
-/**
- * @tsplus type UserProfileId
- */
 export type UserProfileId = StringId & UserProfileIdBrand
 export const UserProfileId = brandedStringId<UserProfileId>()

package/src/internal/Prelude.d.ts

@@ -43,60 +43,46 @@ export type Layer<in ROut, out E = never, out RIn = never> = LAYER.Layer<ROut, E
 export declare namespace Either {
     export * from "effect/Either";
 }
-/** @tsplus type effect/data/Either */
 export type Either<R, L = never> = EITHER.Either<R, L>;
 export declare namespace Order {
     export * from "effect/Order";
 }
-/** @tsplus type effect/data/Order */
 export type Order<in A> = ORD.Order<A>;
 export declare namespace Ref {
     export * from "effect/Ref";
 }
-/** @tsplus type effect/data/Ref */
 export type Ref<in out A> = REF.Ref<A>;
 export declare namespace Duration {
     export * from "effect/Duration";
 }
-/** @tsplus type effect/data/Duration */
 export type Duration = DUR.Duration;
 export declare namespace Context {
     export * from "effect-app/Context";
 }
-/** @tsplus type effect/data/Context */
 export type Context<in Services> = CTX.Context<Services>;
 export declare namespace FiberRef {
     export * from "effect/FiberRef";
 }
-/** @tsplus type effect/data/FiberRef */
 export type FiberRef<in out A> = FR.FiberRef<A>;
 export declare namespace Cause {
     export * from "effect/Cause";
 }
-/** @tsplus type effect/data/Cause */
 export type Cause<A> = C.Cause<A>;
 export declare namespace Exit {
     export * from "effect/Exit";
 }
-/** @tsplus type effect/data/Exit */
 export type Exit<A, E = never> = EX.Exit<A, E>;
 export declare namespace HashMap {
     export * from "effect/HashMap";
 }
-/** @tsplus type effect/data/HashMap */
 export type HashMap<out Key, out Value> = HM.HashMap<Key, Value>;
 export declare namespace Scope {
     export * from "effect/Scope";
 }
-/** @tsplus type effect/data/Scope */
 export type Scope = SCOPE.Scope;
 export declare namespace Option {
     export * from "effect/Option";
 }
-/**
- * @tsplus companion effect/data/Option.Ops
- * @tsplus type effect/data/Option
- */
 export type Option<A> = O.Option<A>;
 export declare namespace Equivalence {
     export * from "effect/Equivalence";
@@ -113,15 +99,10 @@ export type Equal = EQL.Equal;
 export declare namespace Chunk {
     export * from "effect/Chunk";
 }
-/**
- * @tsplus companion effect/data/Chunk.Ops
- * @tsplus type effect/data/Chunk
- */
 export type Chunk<out A> = CNK.Chunk<A>;
 export declare namespace NonEmptySet {
     export * from "effect-app/NonEmptySet";
 }
-/** @tsplus type ets/NonEmptySet */
 export type NonEmptySet<A> = NS.NonEmptySet<A>;
 export declare namespace Record {
     export * from "effect/Record";
@@ -130,20 +111,10 @@ export type Record<K extends keyof any, T> = globalThis.Record<K, V>;
 export declare namespace Array {
     export * from "effect-app/Array";
 }
-/**
- * @tsplus type Array
- * @tsplus type Iterable
- * @tsplus companion effect/data/Array.Ops
- * @tsplus companion effect/data/Array.Ops
- */
 export type Array<A> = globalThis.ReadonlyArray<A>;
 export declare namespace ReadonlySet {
     export * from "effect-app/Set";
 }
-/**
- * @tsplus type ets/Set
- * @tsplus type ets/ReadonlySet
- */
 export type ReadonlySet<A> = SET.Set<A>;
 export declare namespace Schema {
     export * from "effect/Schema";
@@ -151,9 +122,5 @@ export declare namespace Schema {
     export type Encoded<S> = SCHEMA.Schema.Encoded<S>;
     export type Context<S> = SCHEMA.Schema.Context<S>;
 }
-/**
- * @tsplus type ets/Set
- * @tsplus type ets/Schema
- */
 export type Schema<in out A, in out I = A, out R = never> = SCHEMA.Schema<A, I, R>;
 //# sourceMappingURL=Prelude.d.ts.map