effect 3.13.1 → 3.13.3

package/src/Schema.ts

@@ -42,7 +42,6 @@ import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
 import type * as pretty_ from "./Pretty.js"
-import * as record_ from "./Record.js"
 import * as redacted_ from "./Redacted.js"
 import * as Request from "./Request.js"
 import * as scheduler_ from "./Scheduler.js"
@@ -93,6 +92,22 @@ export interface Schema<in out A, in out I = A, out R = never> extends Schema.Va
   annotations(annotations: Annotations.GenericSchema<A>): Schema<A, I, R>
 }
 
+/**
+ * @category annotations
+ * @since 3.10.0
+ */
+export interface Annotable<Self extends Schema<A, I, R>, A, I = A, R = never> extends Schema<A, I, R> {
+  annotations(annotations: Annotations.GenericSchema<A>): Self
+}
+
+/**
+ * @category annotations
+ * @since 3.10.0
+ */
+export interface AnnotableClass<Self extends Schema<A, I, R>, A, I = A, R = never> extends Annotable<Self, A, I, R> {
+  new(_: never): Schema.Variance<A, I, R>
+}
+
 /**
  * @category model
  * @since 3.10.0
@@ -103,23 +118,25 @@ export interface SchemaClass<A, I = A, R = never> extends AnnotableClass<SchemaC
  * @category constructors
  * @since 3.10.0
  */
-export const make = <A, I = A, R = never>(ast: AST.AST): SchemaClass<A, I, R> => (class SchemaClass {
-  [TypeId] = variance
-  static ast = ast
-  static annotations(annotations: Annotations.GenericSchema<A>) {
-    return make<A, I, R>(mergeSchemaAnnotations(this.ast, annotations))
-  }
-  static pipe() {
-    return pipeArguments(this, arguments)
-  }
-  static toString() {
-    return String(ast)
+export function make<A, I = A, R = never>(ast: AST.AST): SchemaClass<A, I, R> {
+  return class SchemaClass {
+    [TypeId] = variance
+    static ast = ast
+    static annotations(annotations: Annotations.GenericSchema<A>) {
+      return make<A, I, R>(mergeSchemaAnnotations(this.ast, annotations))
+    }
+    static pipe() {
+      return pipeArguments(this, arguments)
+    }
+    static toString() {
+      return String(ast)
+    }
+    static Type: A
+    static Encoded: I
+    static Context: R
+    static [TypeId] = variance
   }
-  static Type: A
-  static Encoded: I
-  static Context: R
-  static [TypeId] = variance
-})
+}
 
 const variance = {
   /* c8 ignore next */
@@ -277,28 +294,14 @@ export declare namespace Annotable {
     | Annotable<any, never, never, unknown>
 }
 
-/**
- * @category annotations
- * @since 3.10.0
- */
-export interface Annotable<Self extends Schema<A, I, R>, A, I = A, R = never> extends Schema<A, I, R> {
-  annotations(annotations: Annotations.GenericSchema<A>): Self
-}
-
-/**
- * @category annotations
- * @since 3.10.0
- */
-export interface AnnotableClass<Self extends Schema<A, I, R>, A, I = A, R = never> extends Annotable<Self, A, I, R> {
-  new(_: never): Schema.Variance<A, I, R>
-}
-
 /**
  * @since 3.10.0
  */
-export const asSchema = <S extends Schema.All>(
+export function asSchema<S extends Schema.All>(
   schema: S
-): Schema<Schema.Type<S>, Schema.Encoded<S>, Schema.Context<S>> => schema as any
+): Schema<Schema.Type<S>, Schema.Encoded<S>, Schema.Context<S>> {
+  return schema as any
+}
 
 /**
  * @category formatting
@@ -668,22 +671,25 @@ export interface Literal<Literals extends array_.NonEmptyReadonlyArray<AST.Liter
   readonly literals: Readonly<Literals>
 }
 
-const getDefaultLiteralAST = <Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>(
+function getDefaultLiteralAST<Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>(
   literals: Literals
-) =>
-  AST.isMembers(literals)
+): AST.AST {
+  return AST.isMembers(literals)
     ? AST.Union.make(AST.mapMembers(literals, (literal) => new AST.Literal(literal)))
     : new AST.Literal(literals[0])
+}
 
-const makeLiteralClass = <Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>(
+function makeLiteralClass<Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>(
   literals: Literals,
   ast: AST.AST = getDefaultLiteralAST(literals)
-): Literal<Literals> => (class LiteralClass extends make<Literals[number]>(ast) {
-  static override annotations(annotations: Annotations.Schema<Literals[number]>): Literal<Literals> {
-    return makeLiteralClass(this.literals, mergeSchemaAnnotations(this.ast, annotations))
+): Literal<Literals> {
+  return class LiteralClass extends make<Literals[number]>(ast) {
+    static override annotations(annotations: Annotations.Schema<Literals[number]>): Literal<Literals> {
+      return makeLiteralClass(this.literals, mergeSchemaAnnotations(this.ast, annotations))
+    }
+    static literals = [...literals] as Literals
   }
-  static literals = [...literals] as Literals
-})
+}
 
 /**
  * @category constructors
@@ -695,10 +701,10 @@ export function Literal<Literals extends array_.NonEmptyReadonlyArray<AST.Litera
 export function Literal(): Never
 export function Literal<Literals extends ReadonlyArray<AST.LiteralValue>>(
   ...literals: Literals
-): Schema<Literals[number]>
+): SchemaClass<Literals[number]>
 export function Literal<Literals extends ReadonlyArray<AST.LiteralValue>>(
   ...literals: Literals
-): Schema<Literals[number]> | Never {
+): SchemaClass<Literals[number]> | Never {
   return array_.isNonEmptyReadonlyArray(literals) ? makeLiteralClass(literals) : Never
 }
 
@@ -938,11 +944,11 @@ export const TemplateLiteralParser = <Params extends array_.NonEmptyReadonlyArra
   }
   return class TemplateLiteralParserClass extends transformOrFail(from, to, {
     strict: false,
-    decode: (s, _, ast) => {
-      const match = re.exec(s)
+    decode: (i, _, ast) => {
+      const match = re.exec(i)
       return match
         ? ParseResult.succeed(match.slice(1, params.length + 1))
-        : ParseResult.fail(new ParseResult.Type(ast, s, `${re.source}: no match for ${JSON.stringify(s)}`))
+        : ParseResult.fail(new ParseResult.Type(ast, i, `${re.source}: no match for ${JSON.stringify(i)}`))
     },
     encode: (tuple) => ParseResult.succeed(tuple.join(""))
   }) {
@@ -986,7 +992,8 @@ const declareConstructor = <
   },
   annotations?: Annotations.Schema<A, TypeParameters>
 ): SchemaClass<A, I, Schema.Context<TypeParameters[number]>> =>
-  make(
+  makeDeclareClass(
+    typeParameters,
     new AST.Declaration(
       typeParameters.map((tp) => tp.ast),
       (...typeParameters) => options.decode(...typeParameters.map(make) as any),
@@ -1002,7 +1009,46 @@ const declarePrimitive = <A>(
   const decodeUnknown = () => (input: unknown, _: ParseOptions, ast: AST.Declaration) =>
     is(input) ? ParseResult.succeed(input) : ParseResult.fail(new ParseResult.Type(ast, input))
   const encodeUnknown = decodeUnknown
-  return make(new AST.Declaration([], decodeUnknown, encodeUnknown, toASTAnnotations(annotations)))
+  return makeDeclareClass([], new AST.Declaration([], decodeUnknown, encodeUnknown, toASTAnnotations(annotations)))
+}
+
+/**
+ * @category api interface
+ * @since 3.13.3
+ */
+export interface declare<
+  A,
+  I = A,
+  P extends ReadonlyArray<Schema.All> = readonly [],
+  R = Schema.Context<P[number]>
+> extends AnnotableClass<declare<A, I, P, R>, A, I, R> {
+  readonly typeParameters: Readonly<P>
+}
+
+/**
+ * @category api interface
+ * @since 3.13.3
+ */
+export interface AnnotableDeclare<
+  Self extends declare<A, I, P, R>,
+  A,
+  I = A,
+  P extends ReadonlyArray<Schema.All> = readonly [],
+  R = Schema.Context<P[number]>
+> extends declare<A, I, P, R> {
+  annotations(annotations: Annotations.Schema<A>): Self
+}
+
+function makeDeclareClass<P extends ReadonlyArray<Schema.All>, A, I, R>(
+  typeParameters: P,
+  ast: AST.AST
+): declare<A, I, P, R> {
+  return class DeclareClass extends make<A, I, R>(ast) {
+    static override annotations(annotations: Annotations.Schema<A>): declare<A, I, P, R> {
+      return makeDeclareClass(this.typeParameters, mergeSchemaAnnotations(this.ast, annotations))
+    }
+    static typeParameters = [...typeParameters] as any as P
+  }
 }
 
 /**
@@ -1020,7 +1066,7 @@ export const declare: {
    * @category constructors
    * @since 3.10.0
    */
-  <A>(is: (input: unknown) => input is A, annotations?: Annotations.Schema<A>): SchemaClass<A>
+  <A>(is: (input: unknown) => input is A, annotations?: Annotations.Schema<A>): declare<A>
   /**
    * The constraint `R extends Schema.Context<P[number]>` enforces dependencies solely from `typeParameters`.
    * This ensures that when you call `Schema.to` or `Schema.from`, you receive a schema with a `never` context.
@@ -1028,7 +1074,7 @@ export const declare: {
    * @category constructors
    * @since 3.10.0
    */
-  <const P extends ReadonlyArray<Schema.All>, I, A>(
+  <A, I, const P extends ReadonlyArray<Schema.All>>(
     typeParameters: P,
     options: {
       readonly decode: (
@@ -1047,7 +1093,7 @@ export const declare: {
       ) => Effect.Effect<I, ParseResult.ParseIssue, never>
     },
     annotations?: Annotations.Schema<A, { readonly [K in keyof P]: Schema.Type<P[K]> }>
-  ): SchemaClass<A, I, Schema.Context<P[number]>>
+  ): declare<A, I, P>
 } = function() {
   if (Array.isArray(arguments[0])) {
     const typeParameters = arguments[0]
@@ -1074,8 +1120,9 @@ export const fromBrand = <C extends Brand<string | symbol>, A extends Brand.Unbr
   constructor: Brand.Constructor<C>,
   annotations?: Annotations.Filter<C, A>
 ) =>
-<I, R>(self: Schema<A, I, R>): BrandSchema<A & C, I, R> =>
-  makeBrandClass<Schema<A & C, I, R>, string | symbol>(
+<I, R>(self: Schema<A, I, R>): BrandSchema<A & C, I, R> => {
+  const out = makeBrandClass(
+    self,
     new AST.Refinement(
       self.ast,
       function predicate(a: A, _: ParseOptions, ast: AST.AST): option_.Option<ParseResult.ParseIssue> {
@@ -1091,6 +1138,8 @@ export const fromBrand = <C extends Brand<string | symbol>, A extends Brand.Unbr
       })
     )
   )
+  return out as any
+}
 
 /**
  * @category schema id
@@ -1102,7 +1151,7 @@ export const InstanceOfSchemaId: unique symbol = Symbol.for("effect/SchemaId/Ins
  * @category api interface
  * @since 3.10.0
  */
-export interface instanceOf<A> extends AnnotableClass<instanceOf<A>, A> {}
+export interface instanceOf<A> extends AnnotableDeclare<instanceOf<A>, A> {}
 
 /**
  * @category constructors
@@ -1220,26 +1269,27 @@ export interface Union<Members extends ReadonlyArray<Schema.All>> extends
   >
 {
   readonly members: Readonly<Members>
-  annotations(annotations: Annotations.Schema<Schema.Type<Members[number]>>): Union<Members>
 }
 
 const getDefaultUnionAST = <Members extends AST.Members<Schema.All>>(members: Members): AST.AST =>
   AST.Union.make(members.map((m) => m.ast))
 
-const makeUnionClass = <Members extends AST.Members<Schema.All>>(
+function makeUnionClass<Members extends AST.Members<Schema.All>>(
   members: Members,
   ast: AST.AST = getDefaultUnionAST(members)
-): Union<
-  Members
-> => (class UnionClass
-  extends make<Schema.Type<Members[number]>, Schema.Encoded<Members[number]>, Schema.Context<Members[number]>>(ast)
-{
-  static override annotations(annotations: Annotations.Schema<Schema.Type<Members[number]>>): Union<Members> {
-    return makeUnionClass(this.members, mergeSchemaAnnotations(this.ast, annotations))
-  }
+): Union<Members> {
+  return class UnionClass extends make<
+    Schema.Type<Members[number]>,
+    Schema.Encoded<Members[number]>,
+    Schema.Context<Members[number]>
+  >(ast) {
+    static override annotations(annotations: Annotations.Schema<Schema.Type<Members[number]>>): Union<Members> {
+      return makeUnionClass(this.members, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static members = [...members]
-})
+    static members = [...members]
+  }
+}
 
 /**
  * @category combinators
@@ -1454,25 +1504,27 @@ const getDefaultTupleTypeAST = <Elements extends TupleType.Elements, Rest extend
     true
   )
 
-const makeTupleTypeClass = <Elements extends TupleType.Elements, Rest extends TupleType.Rest>(
+function makeTupleTypeClass<Elements extends TupleType.Elements, Rest extends TupleType.Rest>(
   elements: Elements,
   rest: Rest,
   ast: AST.AST = getDefaultTupleTypeAST(elements, rest)
-) => (class TupleTypeClass extends make<
-  TupleType.Type<Elements, Rest>,
-  TupleType.Encoded<Elements, Rest>,
-  Schema.Context<Elements[number]> | Schema.Context<Rest[number]>
->(ast) {
-  static override annotations(
-    annotations: Annotations.Schema<TupleType.Type<Elements, Rest>>
-  ): TupleType<Elements, Rest> {
-    return makeTupleTypeClass(this.elements, this.rest, mergeSchemaAnnotations(this.ast, annotations))
-  }
+) {
+  return class TupleTypeClass extends make<
+    TupleType.Type<Elements, Rest>,
+    TupleType.Encoded<Elements, Rest>,
+    Schema.Context<Elements[number]> | Schema.Context<Rest[number]>
+  >(ast) {
+    static override annotations(
+      annotations: Annotations.Schema<TupleType.Type<Elements, Rest>>
+    ): TupleType<Elements, Rest> {
+      return makeTupleTypeClass(this.elements, this.rest, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static elements = [...elements] as any as Elements
+    static elements = [...elements] as any as Elements
 
-  static rest = [...rest] as any as Rest
-})
+    static rest = [...rest] as any as Rest
+  }
+}
 
 /**
  * @category api interface
@@ -1482,6 +1534,22 @@ export interface Tuple<Elements extends TupleType.Elements> extends TupleType<El
   annotations(annotations: Annotations.Schema<TupleType.Type<Elements, []>>): Tuple<Elements>
 }
 
+/**
+ * @category api interface
+ * @since 3.13.3
+ */
+export interface Tuple2<Fst extends Schema.Any, Snd extends Schema.Any> extends
+  AnnotableClass<
+    Tuple2<Fst, Snd>,
+    readonly [Schema.Type<Fst>, Schema.Type<Snd>],
+    readonly [Schema.Encoded<Fst>, Schema.Encoded<Snd>],
+    Schema.Context<Fst> | Schema.Context<Snd>
+  >
+{
+  readonly elements: readonly [Fst, Snd]
+  readonly rest: readonly []
+}
+
 /**
  * @category constructors
  * @since 3.10.0
@@ -1490,6 +1558,7 @@ export function Tuple<
   const Elements extends TupleType.Elements,
   Rest extends array_.NonEmptyReadonlyArray<TupleType.Rest[number]>
 >(elements: Elements, ...rest: Rest): TupleType<Elements, Rest>
+export function Tuple<Fst extends Schema.Any, Snd extends Schema.Any>(fst: Fst, snd: Snd): Tuple2<Fst, Snd>
 export function Tuple<Elements extends TupleType.Elements>(...elements: Elements): Tuple<Elements>
 export function Tuple(...args: ReadonlyArray<any>): any {
   return Array.isArray(args[0])
@@ -1506,16 +1575,18 @@ export interface Array$<Value extends Schema.Any> extends TupleType<[], [Value]>
   annotations(annotations: Annotations.Schema<TupleType.Type<[], [Value]>>): Array$<Value>
 }
 
-const makeArrayClass = <Value extends Schema.Any>(
+function makeArrayClass<Value extends Schema.Any>(
   value: Value,
   ast?: AST.AST
-): Array$<Value> => (class ArrayClass extends makeTupleTypeClass<[], [Value]>([], [value], ast) {
-  static override annotations(annotations: Annotations.Schema<TupleType.Type<[], [Value]>>) {
-    return makeArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations))
-  }
+): Array$<Value> {
+  return class ArrayClass extends makeTupleTypeClass<[], [Value]>([], [value], ast) {
+    static override annotations(annotations: Annotations.Schema<TupleType.Type<[], [Value]>>) {
+      return makeArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static value = value
-})
+    static value = value
+  }
+}
 
 const Array$ = <Value extends Schema.Any>(value: Value): Array$<Value> => makeArrayClass(value)
 
@@ -1531,83 +1602,77 @@ export {
  * @category api interface
  * @since 3.10.0
  */
-export interface NonEmptyArray<Value extends Schema.Any> extends TupleType<[Value], [Value]> {
+export interface NonEmptyArray<Value extends Schema.Any> extends
+  AnnotableClass<
+    NonEmptyArray<Value>,
+    array_.NonEmptyReadonlyArray<Schema.Type<Value>>,
+    array_.NonEmptyReadonlyArray<Schema.Encoded<Value>>,
+    Schema.Context<Value>
+  >
+{
+  readonly elements: readonly [Value]
+  readonly rest: readonly [Value]
   readonly value: Value
-  annotations(annotations: Annotations.Schema<TupleType.Type<[Value], [Value]>>): NonEmptyArray<Value>
 }
 
-const makeNonEmptyArrayClass = <Value extends Schema.Any>(
+function makeNonEmptyArrayClass<Value extends Schema.Any>(
   value: Value,
   ast?: AST.AST
-): NonEmptyArray<
-  Value
-> => (class NonEmptyArrayClass extends makeTupleTypeClass<[Value], [Value]>([value], [value], ast) {
-  static override annotations(annotations: Annotations.Schema<TupleType.Type<[Value], [Value]>>) {
-    return makeNonEmptyArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations))
-  }
+) {
+  return class NonEmptyArrayClass extends makeTupleTypeClass<[Value], [Value]>([value], [value], ast) {
+    static override annotations(annotations: Annotations.Schema<TupleType.Type<[Value], [Value]>>) {
+      return makeNonEmptyArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static value = value
-})
+    static value = value
+  }
+}
 
 /**
  * @category constructors
  * @since 3.10.0
  */
 export const NonEmptyArray = <Value extends Schema.Any>(value: Value): NonEmptyArray<Value> =>
-  makeNonEmptyArrayClass(value)
+  makeNonEmptyArrayClass(value) as any
 
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface ArrayEnsure<Value extends Schema.Any> extends
-  AnnotableClass<
-    ArrayEnsure<Value>,
-    ReadonlyArray<Schema.Type<Value>>,
-    Schema.Encoded<Value> | ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface ArrayEnsure<Value extends Schema.Any>
+  extends transform<Union<[Value, Array$<Value>]>, Array$<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category constructors
  * @since 3.10.0
  */
-export const ArrayEnsure = <Value extends Schema.Any>(value: Value): ArrayEnsure<Value> => {
-  const value_ = asSchema(value)
-  return class ArrayEnsureClass extends transform(Union(value_, Array$(value_)), Array$(typeSchema(value_)), {
+export function ArrayEnsure<Value extends Schema.Any>(value: Value): ArrayEnsure<Value> {
+  return transform(Union(value, Array$(value)), Array$(typeSchema(asSchema(value))), {
     strict: true,
-    decode: array_.ensure,
-    encode: (arr) => arr.length === 1 ? arr[0] : arr
-  }) {}
+    decode: (i) => array_.ensure(i),
+    encode: (a) => a.length === 1 ? a[0] : a
+  })
 }
 
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface NonEmptyArrayEnsure<Value extends Schema.Any> extends
-  AnnotableClass<
-    NonEmptyArrayEnsure<Value>,
-    array_.NonEmptyReadonlyArray<Schema.Type<Value>>,
-    Schema.Encoded<Value> | array_.NonEmptyReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface NonEmptyArrayEnsure<Value extends Schema.Any>
+  extends transform<Union<[Value, NonEmptyArray<Value>]>, NonEmptyArray<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category constructors
  * @since 3.10.0
  */
-export const NonEmptyArrayEnsure = <Value extends Schema.Any>(value: Value): NonEmptyArrayEnsure<Value> => {
-  const value_ = asSchema(value)
-  return class NonEmptyArrayEnsureClass
-    extends transform(Union(value_, NonEmptyArray(value_)), NonEmptyArray(typeSchema(value_)), {
-      strict: true,
-      decode: array_.ensure as any,
-      encode: (arr) => arr.length === 1 ? arr[0] : arr
-    })
-  {}
+export function NonEmptyArrayEnsure<Value extends Schema.Any>(value: Value): NonEmptyArrayEnsure<Value> {
+  return transform(Union(value, NonEmptyArray(value)), NonEmptyArray(typeSchema(asSchema(value))), {
+    strict: true,
+    decode: (i) => array_.isNonEmptyReadonlyArray(i) ? i : array_.of(i),
+    encode: (a) => a.length === 1 ? a[0] : a
+  })
 }
 
 /**
@@ -2549,17 +2614,12 @@ export const optionalWith: {
    * @category PropertySignature
    * @since 3.10.0
    */
-  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(
-    options: Options
-  ): (self: S) => optionalWith<S, Options>
+  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(options: Options): (self: S) => optionalWith<S, Options>
   /**
    * @category PropertySignature
    * @since 3.10.0
    */
-  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(
-    self: S,
-    options: Options
-  ): optionalWith<S, Options>
+  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(self: S, options: Options): optionalWith<S, Options>
 } = dual((args) => isSchema(args[0]), (self, options) => {
   return new PropertySignatureWithFromImpl(optionalPropertySignatureAST(self, options), self)
 })
@@ -2577,45 +2637,47 @@ export declare namespace Struct {
       | PropertySignature.All
   }
 
-  type Key<F extends Fields, K extends keyof F> = [K] extends [never] ? never :
-    F[K] extends PropertySignature.All<infer Key> ? [Key] extends [never] ? K : Key :
-    K
+  type OptionalEncodedPropertySignature =
+    | PropertySignature<PropertySignature.Token, any, PropertyKey, "?:", any, boolean, unknown>
+    | PropertySignature<PropertySignature.Token, any, PropertyKey, "?:", never, boolean, unknown>
+    | PropertySignature<PropertySignature.Token, never, PropertyKey, "?:", any, boolean, unknown>
+    | PropertySignature<PropertySignature.Token, never, PropertyKey, "?:", never, boolean, unknown>
 
-  type EncodedTokenKeys<Fields extends Struct.Fields> = {
-    [K in keyof Fields]: Fields[K] extends
-      | PropertySignature<PropertySignature.Token, any, PropertyKey, "?:", any, boolean, unknown>
-      | PropertySignature<PropertySignature.Token, any, PropertyKey, "?:", never, boolean, unknown>
-      | PropertySignature<PropertySignature.Token, never, PropertyKey, "?:", any, boolean, unknown>
-      | PropertySignature<PropertySignature.Token, never, PropertyKey, "?:", never, boolean, unknown> ? K
+  type EncodedOptionalKeys<Fields extends Struct.Fields> = {
+    [K in keyof Fields]: Fields[K] extends OptionalEncodedPropertySignature ? K
       : never
   }[keyof Fields]
 
-  type TypeTokenKeys<Fields extends Struct.Fields> = {
-    [K in keyof Fields]: Fields[K] extends OptionalPropertySignature ? K : never
-  }[keyof Fields]
-
-  type OptionalPropertySignature =
+  type OptionalTypePropertySignature =
     | PropertySignature<"?:", any, PropertyKey, PropertySignature.Token, any, boolean, unknown>
     | PropertySignature<"?:", any, PropertyKey, PropertySignature.Token, never, boolean, unknown>
     | PropertySignature<"?:", never, PropertyKey, PropertySignature.Token, any, boolean, unknown>
     | PropertySignature<"?:", never, PropertyKey, PropertySignature.Token, never, boolean, unknown>
 
+  // type TypeOptionalKeys<Fields extends Struct.Fields> = {
+  //   [K in keyof Fields]: Fields[K] extends OptionalTypePropertySignature ? K : never
+  // }[keyof Fields]
+
   /**
    * @since 3.10.0
    */
   export type Type<F extends Fields> = Types.UnionToIntersection<
     {
-      [K in keyof F]: F[K] extends OptionalPropertySignature ? { readonly [H in K]?: Schema.Type<F[H]> } :
+      [K in keyof F]: F[K] extends OptionalTypePropertySignature ? { readonly [H in K]?: Schema.Type<F[H]> } :
         { readonly [h in K]: Schema.Type<F[h]> }
     }[keyof F]
   > extends infer Q ? Q : never
 
+  type Key<F extends Fields, K extends keyof F> = [K] extends [never] ? never :
+    F[K] extends PropertySignature.All<infer Key> ? [Key] extends [never] ? K : Key :
+    K
+
   /**
    * @since 3.10.0
    */
   export type Encoded<F extends Fields> =
-    & { readonly [K in Exclude<keyof F, EncodedTokenKeys<F>> as Key<F, K>]: Schema.Encoded<F[K]> }
-    & { readonly [K in EncodedTokenKeys<F> as Key<F, K>]?: Schema.Encoded<F[K]> }
+    & { readonly [K in Exclude<keyof F, EncodedOptionalKeys<F>> as Key<F, K>]: Schema.Encoded<F[K]> }
+    & { readonly [K in EncodedOptionalKeys<F> as Key<F, K>]?: Schema.Encoded<F[K]> }
 
   /**
    * @since 3.10.0
@@ -2633,7 +2695,7 @@ export declare namespace Struct {
    */
   export type Constructor<F extends Fields> = Types.UnionToIntersection<
     {
-      [K in keyof F]: F[K] extends OptionalPropertySignature ? { readonly [H in K]?: Schema.Type<F[H]> } :
+      [K in keyof F]: F[K] extends OptionalTypePropertySignature ? { readonly [H in K]?: Schema.Type<F[H]> } :
         F[K] extends PropertySignatureWithDefault ? { readonly [H in K]?: Schema.Type<F[H]> } :
         { readonly [h in K]: Schema.Type<F[h]> }
     }[keyof F]
@@ -3094,7 +3156,7 @@ export const pluck: {
    * @category struct transformations
    * @since 3.10.0
    */
-  <A, I, K extends keyof A & keyof I>(key: K): <R>(schema: Schema<A, I, R>) => Schema<A[K], Simplify<Pick<I, K>>, R>
+  <A, I, K extends keyof A & keyof I>(key: K): <R>(schema: Schema<A, I, R>) => SchemaClass<A[K], Simplify<Pick<I, K>>, R>
   /**
    * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
    * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
@@ -3125,7 +3187,7 @@ export const pluck: {
    * @category struct transformations
    * @since 3.10.0
    */
-  <A, I, R, K extends keyof A & keyof I>(schema: Schema<A, I, R>, key: K): Schema<A[K], Simplify<Pick<I, K>>, R>
+  <A, I, R, K extends keyof A & keyof I>(schema: Schema<A, I, R>, key: K): SchemaClass<A[K], Simplify<Pick<I, K>>, R>
 } = dual(
   2,
   <A, I, R, K extends keyof A & keyof I>(
@@ -3133,108 +3195,107 @@ export const pluck: {
     key: K
   ): Schema<A[K], Pick<I, K>, R> => {
     const ps = AST.getPropertyKeyIndexedAccess(AST.typeAST(schema.ast), key)
-    const value = make<
-      /**
-       * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
-       * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
-       *
-       * @example
-       * ```ts
-       * import * as Schema from "effect/Schema"
-       *
-       * // ---------------------------------------------
-       * // use case: pull out a single field from a
-       * // struct through a transformation
-       * // ---------------------------------------------
-       *
-       * const mytable = Schema.Struct({
-       *   column1: Schema.NumberFromString,
-       *   column2: Schema.Number
-       * })
-       *
-       * // const pullOutColumn: S.Schema<number, {
-       * //     readonly column1: string;
-       * // }, never>
-       * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
-       *
-       * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
-       * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
-       * ```
-       *
-       * @category struct transformations
-       * @since 3.10.0
-       */
-      A[K], /**
-       * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
-       * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
-       *
-       * @example
-       * ```ts
-       * import * as Schema from "effect/Schema"
-       *
-       * // ---------------------------------------------
-       * // use case: pull out a single field from a
-       * // struct through a transformation
-       * // ---------------------------------------------
-       *
-       * const mytable = Schema.Struct({
-       *   column1: Schema.NumberFromString,
-       *   column2: Schema.Number
-       * })
-       *
-       * // const pullOutColumn: S.Schema<number, {
-       * //     readonly column1: string;
-       * // }, never>
-       * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
-       *
-       * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
-       * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
-       * ```
-       *
-       * @category struct transformations
-       * @since 3.10.0
-       */
-      A[K], /**
-       * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
-       * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
-       *
-       * @example
-       * ```ts
-       * import * as Schema from "effect/Schema"
-       *
-       * // ---------------------------------------------
-       * // use case: pull out a single field from a
-       * // struct through a transformation
-       * // ---------------------------------------------
-       *
-       * const mytable = Schema.Struct({
-       *   column1: Schema.NumberFromString,
-       *   column2: Schema.Number
-       * })
-       *
-       * // const pullOutColumn: S.Schema<number, {
-       * //     readonly column1: string;
-       * // }, never>
-       * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
-       *
-       * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
-       * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
-       * ```
-       *
-       * @category struct transformations
-       * @since 3.10.0
-       */
-      R
-    >(ps.isOptional ? AST.orUndefined(ps.type) : ps.type)
-    return transform(
+    const value = make</**
+     * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
+     * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
+     *
+     * @example
+     * ```ts
+     * import * as Schema from "effect/Schema"
+     *
+     * // ---------------------------------------------
+     * // use case: pull out a single field from a
+     * // struct through a transformation
+     * // ---------------------------------------------
+     *
+     * const mytable = Schema.Struct({
+     *   column1: Schema.NumberFromString,
+     *   column2: Schema.Number
+     * })
+     *
+     * // const pullOutColumn: S.Schema<number, {
+     * //     readonly column1: string;
+     * // }, never>
+     * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
+     *
+     * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
+     * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
+     * ```
+     *
+     * @category struct transformations
+     * @since 3.10.0
+     */
+    A[K], /**
+     * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
+     * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
+     *
+     * @example
+     * ```ts
+     * import * as Schema from "effect/Schema"
+     *
+     * // ---------------------------------------------
+     * // use case: pull out a single field from a
+     * // struct through a transformation
+     * // ---------------------------------------------
+     *
+     * const mytable = Schema.Struct({
+     *   column1: Schema.NumberFromString,
+     *   column2: Schema.Number
+     * })
+     *
+     * // const pullOutColumn: S.Schema<number, {
+     * //     readonly column1: string;
+     * // }, never>
+     * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
+     *
+     * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
+     * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
+     * ```
+     *
+     * @category struct transformations
+     * @since 3.10.0
+     */
+    A[K], /**
+     * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
+     * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
+     *
+     * @example
+     * ```ts
+     * import * as Schema from "effect/Schema"
+     *
+     * // ---------------------------------------------
+     * // use case: pull out a single field from a
+     * // struct through a transformation
+     * // ---------------------------------------------
+     *
+     * const mytable = Schema.Struct({
+     *   column1: Schema.NumberFromString,
+     *   column2: Schema.Number
+     * })
+     *
+     * // const pullOutColumn: S.Schema<number, {
+     * //     readonly column1: string;
+     * // }, never>
+     * const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
+     *
+     * console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
+     * // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
+     * ```
+     *
+     * @category struct transformations
+     * @since 3.10.0
+     */
+    R>(ps.isOptional ? AST.orUndefined(ps.type) : ps.type)
+    const out = transform(
       schema.pipe(pick(key)),
       value,
       {
         strict: true,
-        decode: (a: any) => a[key],
-        encode: (ak) => ps.isOptional && ak === undefined ? {} : { [key]: ak } as any
+        decode: (i) => i[key],
+        encode: (a) => ps.isOptional && a === undefined ? {} : { [key]: a } as any
       }
     )
+    return out
   }
 )
 
@@ -3255,20 +3316,26 @@ export interface BrandSchema<A extends Brand<any>, I = A, R = never>
 export interface brand<S extends Schema.Any, B extends string | symbol>
   extends BrandSchema<Schema.Type<S> & Brand<B>, Schema.Encoded<S>, Schema.Context<S>>
 {
+  readonly from: S
   annotations(annotations: Annotations.Schema<Schema.Type<S> & Brand<B>>): brand<S, B>
 }
 
-const makeBrandClass = <S extends Schema.Any, B extends string | symbol>(
+function makeBrandClass<S extends Schema.Any, B extends string | symbol>(
+  from: S,
   ast: AST.AST
-): brand<S, B> => (class BrandClass extends make<Schema.Type<S> & Brand<B>, Schema.Encoded<S>, Schema.Context<S>>(ast) {
-  static override annotations(annotations: Annotations.Schema<Schema.Type<S> & Brand<B>>): brand<S, B> {
-    return makeBrandClass(mergeSchemaAnnotations(this.ast, annotations))
-  }
+): brand<S, B> {
+  return class BrandClass extends make<Schema.Type<S> & Brand<B>, Schema.Encoded<S>, Schema.Context<S>>(ast) {
+    static override annotations(annotations: Annotations.Schema<Schema.Type<S> & Brand<B>>): brand<S, B> {
+      return makeBrandClass(this.from, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static make = (a: Brand.Unbranded<Schema.Type<S> & Brand<B>>, options?: MakeOptions): Schema.Type<S> & Brand<B> => {
-    return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a)
+    static make = (a: Brand.Unbranded<Schema.Type<S> & Brand<B>>, options?: MakeOptions): Schema.Type<S> & Brand<B> => {
+      return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a)
+    }
+
+    static from = from
   }
-})
+}
 
 /**
  * Returns a nominal branded schema by applying a brand to a given schema.
@@ -3307,7 +3374,7 @@ export const brand = <S extends Schema.AnyNoContext, B extends string | symbol>(
       ...annotations
     })
   )
-  return makeBrandClass(ast)
+  return makeBrandClass(self, ast)
 }
 
 /**
@@ -3335,10 +3402,7 @@ export const partialWith: {
    * @category combinators
    * @since 3.10.0
    */
-  <A, I, R, const Options extends { readonly exact: true } | undefined>(
-    self: Schema<A, I, R>,
-    options: Options
-  ): SchemaClass<{ [K in keyof A]?: A[K] }, { [K in keyof I]?: I[K] }, R>
+  <A, I, R, const Options extends { readonly exact: true } | undefined>(self: Schema<A, I, R>, options: Options): SchemaClass<{ [K in keyof A]?: A[K] }, { [K in keyof I]?: I[K] }, R>
 } = dual((args) => isSchema(args[0]), <A, I, R>(
   self: Schema<A, I, R>,
   options: { readonly exact: true }
@@ -3710,61 +3774,55 @@ export const compose: {
    * @category combinators
    * @since 3.10.0
    */
-  <D, C extends B, R2, B>(to: Schema<D, C, R2>): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
+  <To extends Schema.Any, From extends Schema.Any, C extends Schema.Type<From>>(to: To & Schema<Schema.Type<To>, C, Schema.Context<To>>): (from: From) => transform<From, To>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <D, C, R2>(to: Schema<D, C, R2>): <B extends C, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
+  <To extends Schema.Any>(to: To): <From extends Schema.Any, B extends Schema.Encoded<To>>(
+    from: From & Schema<B, Schema.Encoded<From>, Schema.Context<From>>
+  ) => transform<From, To>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <C, B, R2>(
-    to: Schema<C, B, R2>,
-    options?: { readonly strict: true }
-  ): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<C, A, R1 | R2>
+  <To extends Schema.Any>(to: To, options?: { readonly strict: true }): <From extends Schema.Any>(
+    from: From & Schema<Schema.Encoded<To>, Schema.Encoded<From>, Schema.Context<From>>
+  ) => transform<From, To>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <D, C, R2>(
-    to: Schema<D, C, R2>,
-    options: { readonly strict: false }
-  ): <B, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
+  <To extends Schema.Any>(to: To, options: { readonly strict: false }): <From extends Schema.Any>(from: From) => transform<From, To>
 
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <B, A, R1, D, C extends B, R2>(from: Schema<B, A, R1>, to: Schema<D, C, R2>): SchemaClass<D, A, R1 | R2>
+  <From extends Schema.Any, To extends Schema.Any, C extends Schema.Type<From>>(from: From, to: To & Schema<Schema.Type<To>, C, Schema.Context<To>>): transform<From, To>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <B extends C, A, R1, D, C, R2>(from: Schema<B, A, R1>, to: Schema<D, C, R2>): SchemaClass<D, A, R1 | R2>
+  <From extends Schema.Any, B extends Schema.Encoded<To>, To extends Schema.Any>(from: From & Schema<B, Schema.Encoded<From>, Schema.Context<From>>, to: To): transform<From, To>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <B, A, R1, C, R2>(
-    from: Schema<B, A, R1>,
-    to: Schema<C, B, R2>,
+  <From extends Schema.Any, To extends Schema.Any>(
+    from: From & Schema<Schema.Encoded<To>, Schema.Encoded<From>, Schema.Context<From>>,
+    to: To,
     options?: { readonly strict: true }
-  ): SchemaClass<C, A, R1 | R2>
+  ): transform<From, To>
   /**
    * @category combinators
    * @since 3.10.0
    */
-  <B, A, R1, D, C, R2>(
-    from: Schema<B, A, R1>,
-    to: Schema<D, C, R2>,
-    options: { readonly strict: false }
-  ): SchemaClass<D, A, R1 | R2>
+  <From extends Schema.Any, To extends Schema.Any>(from: From, to: To, options: { readonly strict: false }): transform<From, To>
 } = dual(
   (args) => isSchema(args[1]),
   <B, A, R1, D, C, R2>(from: Schema<B, A, R1>, to: Schema<D, C, R2>): SchemaClass<D, A, R1 | R2> =>
-    make(AST.compose(from.ast, to.ast))
+    makeTransformationClass(from, to, AST.compose(from.ast, to.ast))
 )
 
 /**
@@ -3809,29 +3867,27 @@ export interface refine<A, From extends Schema.Any>
   make(a: Schema.Type<From>, options?: MakeOptions): A
 }
 
-const makeRefineClass = <From extends Schema.Any, A>(
+function makeRefineClass<From extends Schema.Any, A>(
   from: From,
-  filter: (
-    a: Schema.Type<From>,
-    options: ParseOptions,
-    self: AST.Refinement
-  ) => option_.Option<ParseResult.ParseIssue>,
+  filter: (a: Schema.Type<From>, options: ParseOptions, self: AST.Refinement) => option_.Option<ParseResult.ParseIssue>,
   ast: AST.AST
-): refine<A, From> => (class RefineClass extends make<A, Schema.Encoded<From>, Schema.Context<From>>(ast) {
-  static override annotations(annotations: Annotations.Schema<A>): refine<A, From> {
-    return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations))
-  }
+): refine<A, From> {
+  return class RefineClass extends make<A, Schema.Encoded<From>, Schema.Context<From>>(ast) {
+    static override annotations(annotations: Annotations.Schema<A>): refine<A, From> {
+      return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static [RefineSchemaId] = from
+    static [RefineSchemaId] = from
 
-  static from = from
+    static from = from
 
-  static filter = filter
+    static filter = filter
 
-  static make = (a: Schema.Type<From>, options?: MakeOptions): A => {
-    return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a)
+    static make = (a: Schema.Type<From>, options?: MakeOptions): A => {
+      return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a)
+    }
   }
-})
+}
 
 /**
  * @category api interface
@@ -3988,16 +4044,16 @@ export const filterEffect: {
     typeSchema(self),
     {
       strict: true,
-      decode: (a, options, ast) =>
+      decode: (i, options, ast) =>
         ParseResult.flatMap(
-          f(a, options, ast),
+          f(i, options, ast),
           (filterReturnType) =>
-            option_.match(toFilterParseIssue(filterReturnType, ast, a), {
-              onNone: () => ParseResult.succeed(a),
+            option_.match(toFilterParseIssue(filterReturnType, ast, i), {
+              onNone: () => ParseResult.succeed(i),
               onSome: ParseResult.fail
             })
         ),
-      encode: ParseResult.succeed
+      encode: (a) => ParseResult.succeed(a)
     }
   ))
 
@@ -4005,7 +4061,7 @@ export const filterEffect: {
  * @category api interface
  * @since 3.10.0
  */
-export interface transformOrFail<From extends Schema.Any, To extends Schema.Any, R = never> extends
+export interface transformOrFail<From extends Schema.All, To extends Schema.All, R = never> extends
   AnnotableClass<
     transformOrFail<From, To, R>,
     Schema.Type<To>,
@@ -4017,29 +4073,27 @@ export interface transformOrFail<From extends Schema.Any, To extends Schema.Any,
   readonly to: To
 }
 
-const makeTransformationClass = <From extends Schema.Any, To extends Schema.Any, R>(
+function makeTransformationClass<From extends Schema.Any, To extends Schema.Any, R>(
   from: From,
   to: To,
   ast: AST.AST
-): transformOrFail<
-  From,
-  To,
-  R
-> => (class TransformationClass
-  extends make<Schema.Type<To>, Schema.Encoded<From>, Schema.Context<From> | Schema.Context<To> | R>(ast)
-{
-  static override annotations(annotations: Annotations.Schema<Schema.Type<To>>) {
-    return makeTransformationClass<From, To, R>(
-      this.from,
-      this.to,
-      mergeSchemaAnnotations(this.ast, annotations)
-    )
-  }
+): transformOrFail<From, To, R> {
+  return class TransformationClass
+    extends make<Schema.Type<To>, Schema.Encoded<From>, Schema.Context<From> | Schema.Context<To> | R>(ast)
+  {
+    static override annotations(annotations: Annotations.Schema<Schema.Type<To>>) {
+      return makeTransformationClass<From, To, R>(
+        this.from,
+        this.to,
+        mergeSchemaAnnotations(this.ast, annotations)
+      )
+    }
 
-  static from = from
+    static from = from
 
-  static to = to
-})
+    static to = to
+  }
+}
 
 /**
  * Create a new `Schema` by transforming the input and output of an existing `Schema`
@@ -4160,7 +4214,7 @@ export const transformOrFail: {
  * @category api interface
  * @since 3.10.0
  */
-export interface transform<From extends Schema.Any, To extends Schema.Any> extends transformOrFail<From, To> {
+export interface transform<From extends Schema.All, To extends Schema.All> extends transformOrFail<From, To> {
   annotations(annotations: Annotations.Schema<Schema.Type<To>>): transform<From, To>
 }
 
@@ -4236,7 +4290,11 @@ export const transform: {
  * @category api interface
  * @since 3.10.0
  */
-export interface transformLiteral<Type, Encoded> extends Annotable<transformLiteral<Type, Encoded>, Type, Encoded> {}
+export interface transformLiteral<Type extends AST.LiteralValue, Encoded extends AST.LiteralValue>
+  extends transform<Literal<[Encoded]>, Literal<[Type]>>
+{
+  annotations(annotations: Annotations.Schema<Type>): transformLiteral<Type, Encoded>
+}
 
 /**
  * Creates a new `Schema` which transforms literal values.
@@ -4253,11 +4311,16 @@ export interface transformLiteral<Type, Encoded> extends Annotable<transformLite
  * @category constructors
  * @since 3.10.0
  */
-export const transformLiteral = <Encoded extends AST.LiteralValue, Type extends AST.LiteralValue>(
+export function transformLiteral<Encoded extends AST.LiteralValue, Type extends AST.LiteralValue>(
   from: Encoded,
   to: Type
-): transformLiteral<Type, Encoded> =>
-  transform(Literal(from), Literal(to), { strict: true, decode: () => to, encode: () => from })
+): transformLiteral<Type, Encoded> {
+  return transform(Literal(from), Literal(to), {
+    strict: true,
+    decode: () => to,
+    encode: () => from
+  })
+}
 
 /**
  * Creates a new `Schema` which maps between corresponding literal values.
@@ -4573,17 +4636,19 @@ export const TrimmedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Trimme
  * @category string filters
  * @since 3.10.0
  */
-export const trimmed =
-  <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
-    self.pipe(
-      filter((a) => a === a.trim(), {
-        schemaId: TrimmedSchemaId,
-        title: "trimmed",
-        description: "a string with no leading or trailing whitespace",
-        jsonSchema: { pattern: "^\\S[\\s\\S]*\\S$|^\\S$|^$" },
-        ...annotations
-      })
-    )
+export const trimmed = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+) =>
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
+  self.pipe(
+    filter((a) => a === a.trim(), {
+      schemaId: TrimmedSchemaId,
+      title: "trimmed",
+      description: "a string with no leading or trailing whitespace",
+      jsonSchema: { pattern: "^\\S[\\s\\S]*\\S$|^\\S$|^$" },
+      ...annotations
+    })
+  )
 
 /**
  * @category schema id
@@ -4601,23 +4666,21 @@ export type MaxLengthSchemaId = typeof MaxLengthSchemaId
  * @category string filters
  * @since 3.10.0
  */
-export const maxLength = <A extends string>(
-  maxLength: number,
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
-  self.pipe(
-    filter(
-      (a) => a.length <= maxLength,
-      {
-        schemaId: MaxLengthSchemaId,
-        title: `maxLength(${maxLength})`,
-        description: `a string at most ${maxLength} character(s) long`,
-        jsonSchema: { maxLength },
-        ...annotations
-      }
+export const maxLength =
+  <S extends Schema.Any>(maxLength: number, annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
+    self.pipe(
+      filter(
+        (a) => a.length <= maxLength,
+        {
+          schemaId: MaxLengthSchemaId,
+          title: `maxLength(${maxLength})`,
+          description: `a string at most ${maxLength} character(s) long`,
+          jsonSchema: { maxLength },
+          ...annotations
+        }
+      )
     )
-  )
 
 /**
  * @category schema id
@@ -4635,11 +4698,11 @@ export type MinLengthSchemaId = typeof MinLengthSchemaId
  * @category string filters
  * @since 3.10.0
  */
-export const minLength = <A extends string>(
+export const minLength = <S extends Schema.Any>(
   minLength: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter(
       (a) => a.length >= minLength,
@@ -4653,6 +4716,51 @@ export const minLength = <A extends string>(
     )
   )
 
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export const LengthSchemaId: unique symbol = schemaId_.LengthSchemaId
+
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export type LengthSchemaId = typeof LengthSchemaId
+
+/**
+ * @category string filters
+ * @since 3.10.0
+ */
+export const length = <S extends Schema.Any>(
+  length: number | { readonly min: number; readonly max: number },
+  annotations?: Annotations.Filter<Schema.Type<S>>
+) =>
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
+  const minLength = Predicate.isObject(length) ? Math.max(0, Math.floor(length.min)) : Math.max(0, Math.floor(length))
+  const maxLength = Predicate.isObject(length) ? Math.max(minLength, Math.floor(length.max)) : minLength
+  if (minLength !== maxLength) {
+    return self.pipe(
+      filter((a) => a.length >= minLength && a.length <= maxLength, {
+        schemaId: LengthSchemaId,
+        title: `length({ min: ${minLength}, max: ${maxLength})`,
+        description: `a string at least ${minLength} character(s) and at most ${maxLength} character(s) long`,
+        jsonSchema: { minLength, maxLength },
+        ...annotations
+      })
+    )
+  }
+  return self.pipe(
+    filter((a) => a.length === minLength, {
+      schemaId: LengthSchemaId,
+      title: `length(${minLength})`,
+      description: minLength === 1 ? `a single character` : `a string ${minLength} character(s) long`,
+      jsonSchema: { minLength, maxLength: minLength },
+      ...annotations
+    })
+  )
+}
+
 /**
  * @category schema id
  * @since 3.10.0
@@ -4663,15 +4771,15 @@ export const PatternSchemaId: unique symbol = Symbol.for("effect/SchemaId/Patter
  * @category string filters
  * @since 3.10.0
  */
-export const pattern = <A extends string>(
+export const pattern = <S extends Schema.Any>(
   regex: RegExp,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const source = regex.source
   return self.pipe(
     filter(
-      (a): a is A => {
+      (a) => {
         // The following line ensures that `lastIndex` is reset to `0` in case the user has specified the `g` flag
         regex.lastIndex = 0
         return regex.test(a)
@@ -4698,11 +4806,11 @@ export const StartsWithSchemaId: unique symbol = Symbol.for("effect/SchemaId/Sta
  * @category string filters
  * @since 3.10.0
  */
-export const startsWith = <A extends string>(
+export const startsWith = <S extends Schema.Any>(
   startsWith: string,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const formatted = JSON.stringify(startsWith)
   return self.pipe(
     filter(
@@ -4729,11 +4837,11 @@ export const EndsWithSchemaId: unique symbol = Symbol.for("effect/SchemaId/EndsW
  * @category string filters
  * @since 3.10.0
  */
-export const endsWith = <A extends string>(
+export const endsWith = <S extends Schema.Any>(
   endsWith: string,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const formatted = JSON.stringify(endsWith)
   return self.pipe(
     filter(
@@ -4760,11 +4868,11 @@ export const IncludesSchemaId: unique symbol = Symbol.for("effect/SchemaId/Inclu
  * @category string filters
  * @since 3.10.0
  */
-export const includes = <A extends string>(
+export const includes = <S extends Schema.Any>(
   searchString: string,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const formatted = JSON.stringify(searchString)
   return self.pipe(
     filter(
@@ -4794,7 +4902,8 @@ export const LowercasedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Low
  * @since 3.10.0
  */
 export const lowercased =
-  <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
       filter((a) => a === a.toLowerCase(), {
         schemaId: LowercasedSchemaId,
@@ -4817,22 +4926,23 @@ export class Lowercased extends String$.pipe(
  * @category schema id
  * @since 3.10.0
  */
-export const CapitalizedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Capitalized")
+export const UppercasedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Uppercased")
 
 /**
- * Verifies that a string is capitalized.
+ * Verifies that a string is uppercased.
  *
  * @category string filters
  * @since 3.10.0
  */
-export const capitalized =
-  <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+export const uppercased =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
-      filter((a) => a[0]?.toUpperCase() === a[0], {
-        schemaId: CapitalizedSchemaId,
-        title: "capitalized",
-        description: "a capitalized string",
-        jsonSchema: { pattern: "^[^a-z]?.*$" },
+      filter((a) => a === a.toUpperCase(), {
+        schemaId: UppercasedSchemaId,
+        title: "uppercased",
+        description: "an uppercase string",
+        jsonSchema: { pattern: "^[^a-z]*$" },
         ...annotations
       })
     )
@@ -4841,30 +4951,31 @@ export const capitalized =
  * @category string constructors
  * @since 3.10.0
  */
-export class Capitalized extends String$.pipe(
-  capitalized({ identifier: "Capitalized" })
+export class Uppercased extends String$.pipe(
+  uppercased({ identifier: "Uppercased" })
 ) {}
 
 /**
  * @category schema id
  * @since 3.10.0
  */
-export const UncapitalizedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Uncapitalized")
+export const CapitalizedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Capitalized")
 
 /**
- * Verifies that a string is uncapitalized.
+ * Verifies that a string is capitalized.
  *
  * @category string filters
  * @since 3.10.0
  */
-export const uncapitalized =
-  <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+export const capitalized =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
-      filter((a) => a[0]?.toLowerCase() === a[0], {
-        schemaId: UncapitalizedSchemaId,
-        title: "uncapitalized",
-        description: "a uncapitalized string",
-        jsonSchema: { pattern: "^[^A-Z]?.*$" },
+      filter((a) => a[0]?.toUpperCase() === a[0], {
+        schemaId: CapitalizedSchemaId,
+        title: "capitalized",
+        description: "a capitalized string",
+        jsonSchema: { pattern: "^[^a-z]?.*$" },
         ...annotations
       })
     )
@@ -4873,30 +4984,31 @@ export const uncapitalized =
  * @category string constructors
  * @since 3.10.0
  */
-export class Uncapitalized extends String$.pipe(
-  uncapitalized({ identifier: "Uncapitalized" })
+export class Capitalized extends String$.pipe(
+  capitalized({ identifier: "Capitalized" })
 ) {}
 
 /**
  * @category schema id
  * @since 3.10.0
  */
-export const UppercasedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Uppercased")
+export const UncapitalizedSchemaId: unique symbol = Symbol.for("effect/SchemaId/Uncapitalized")
 
 /**
- * Verifies that a string is uppercased.
+ * Verifies that a string is uncapitalized.
  *
  * @category string filters
  * @since 3.10.0
  */
-export const uppercased =
-  <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+export const uncapitalized =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
-      filter((a) => a === a.toUpperCase(), {
-        schemaId: UppercasedSchemaId,
-        title: "uppercased",
-        description: "an uppercase string",
-        jsonSchema: { pattern: "^[^a-z]*$" },
+      filter((a) => a[0]?.toLowerCase() === a[0], {
+        schemaId: UncapitalizedSchemaId,
+        title: "uncapitalized",
+        description: "a uncapitalized string",
+        jsonSchema: { pattern: "^[^A-Z]?.*$" },
         ...annotations
       })
     )
@@ -4905,55 +5017,10 @@ export const uppercased =
  * @category string constructors
  * @since 3.10.0
  */
-export class Uppercased extends String$.pipe(
-  uppercased({ identifier: "Uppercased" })
+export class Uncapitalized extends String$.pipe(
+  uncapitalized({ identifier: "Uncapitalized" })
 ) {}
 
-/**
- * @category schema id
- * @since 3.10.0
- */
-export const LengthSchemaId: unique symbol = schemaId_.LengthSchemaId
-
-/**
- * @category schema id
- * @since 3.10.0
- */
-export type LengthSchemaId = typeof LengthSchemaId
-
-/**
- * @category string filters
- * @since 3.10.0
- */
-export const length = <A extends string>(
-  length: number | { readonly min: number; readonly max: number },
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
-  const minLength = Predicate.isObject(length) ? Math.max(0, Math.floor(length.min)) : Math.max(0, Math.floor(length))
-  const maxLength = Predicate.isObject(length) ? Math.max(minLength, Math.floor(length.max)) : minLength
-  if (minLength !== maxLength) {
-    return self.pipe(
-      filter((a) => a.length >= minLength && a.length <= maxLength, {
-        schemaId: LengthSchemaId,
-        title: `length({ min: ${minLength}, max: ${maxLength})`,
-        description: `a string at least ${minLength} character(s) and at most ${maxLength} character(s) long`,
-        jsonSchema: { minLength, maxLength },
-        ...annotations
-      })
-    )
-  }
-  return self.pipe(
-    filter((a) => a.length === minLength, {
-      schemaId: LengthSchemaId,
-      title: `length(${minLength})`,
-      description: minLength === 1 ? `a single character` : `a string ${minLength} character(s) long`,
-      jsonSchema: { minLength, maxLength: minLength },
-      ...annotations
-    })
-  )
-}
-
 /**
  * A schema representing a single character.
  *
@@ -4966,9 +5033,9 @@ export class Char extends String$.pipe(length(1, { identifier: "Char" })) {}
  * @category string filters
  * @since 3.10.0
  */
-export const nonEmptyString = <A extends string>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const nonEmptyString = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   minLength(1, {
     title: "nonEmptyString",
     description: "a non empty string",
@@ -4984,7 +5051,11 @@ export const nonEmptyString = <A extends string>(
 export class Lowercase extends transform(
   String$.annotations({ description: "a string that will be converted to lowercase" }),
   Lowercased,
-  { strict: true, decode: (s) => s.toLowerCase(), encode: identity }
+  {
+    strict: true,
+    decode: (i) => i.toLowerCase(),
+    encode: identity
+  }
 ).annotations({ identifier: "Lowercase" }) {}
 
 /**
@@ -4996,7 +5067,11 @@ export class Lowercase extends transform(
 export class Uppercase extends transform(
   String$.annotations({ description: "a string that will be converted to uppercase" }),
   Uppercased,
-  { strict: true, decode: (s) => s.toUpperCase(), encode: identity }
+  {
+    strict: true,
+    decode: (i) => i.toUpperCase(),
+    encode: identity
+  }
 ).annotations({ identifier: "Uppercase" }) {}
 
 /**
@@ -5008,7 +5083,11 @@ export class Uppercase extends transform(
 export class Capitalize extends transform(
   String$.annotations({ description: "a string that will be converted to a capitalized format" }),
   Capitalized,
-  { strict: true, decode: (s) => string_.capitalize(s), encode: identity }
+  {
+    strict: true,
+    decode: (i) => string_.capitalize(i),
+    encode: identity
+  }
 ).annotations({ identifier: "Capitalize" }) {}
 
 /**
@@ -5020,7 +5099,11 @@ export class Capitalize extends transform(
 export class Uncapitalize extends transform(
   String$.annotations({ description: "a string that will be converted to an uncapitalized format" }),
   Uncapitalized,
-  { strict: true, decode: (s) => string_.uncapitalize(s), encode: identity }
+  {
+    strict: true,
+    decode: (i) => string_.uncapitalize(i),
+    encode: identity
+  }
 ).annotations({ identifier: "Uncapitalize" }) {}
 
 /**
@@ -5060,7 +5143,11 @@ export class NonEmptyTrimmedString extends Trimmed.pipe(
 export class Trim extends transform(
   String$.annotations({ description: "a string that will be trimmed" }),
   Trimmed,
-  { strict: true, decode: (s) => s.trim(), encode: identity }
+  {
+    strict: true,
+    decode: (i) => i.trim(),
+    encode: identity
+  }
 ).annotations({ identifier: "Trim" }) {}
 
 /**
@@ -5069,11 +5156,15 @@ export class Trim extends transform(
  * @category string transformations
  * @since 3.10.0
  */
-export const split = (separator: string): transform<typeof String$, Array$<typeof String$>> =>
+export const split = (separator: string): transform<SchemaClass<string>, Array$<typeof String$>> =>
   transform(
     String$.annotations({ description: "a string that will be split" }),
     Array$(String$),
-    { strict: true, decode: string_.split(separator), encode: array_.join(separator) }
+    {
+      strict: true,
+      decode: (i) => i.split(separator),
+      encode: (a) => a.join(separator)
+    }
   )
 
 /**
@@ -5087,23 +5178,21 @@ export type ParseJsonOptions = {
 
 const getErrorMessage = (e: unknown): string => e instanceof Error ? e.message : String(e)
 
-const getParseJsonTransformation = (options?: ParseJsonOptions) =>
+const getParseJsonTransformation = (options?: ParseJsonOptions): SchemaClass<unknown, string> =>
   transformOrFail(
-    String$.annotations({
-      [AST.DescriptionAnnotationId]: "a string to be decoded into JSON"
-    }),
+    String$.annotations({ description: "a string to be decoded into JSON" }),
     Unknown,
     {
       strict: true,
-      decode: (s, _, ast) =>
+      decode: (i, _, ast) =>
         ParseResult.try({
-          try: () => JSON.parse(s, options?.reviver),
-          catch: (e) => new ParseResult.Type(ast, s, getErrorMessage(e))
+          try: () => JSON.parse(i, options?.reviver),
+          catch: (e) => new ParseResult.Type(ast, i, getErrorMessage(e))
         }),
-      encode: (u, _, ast) =>
+      encode: (a, _, ast) =>
         ParseResult.try({
-          try: () => JSON.stringify(u, options?.replacer, options?.space),
-          catch: (e) => new ParseResult.Type(ast, u, getErrorMessage(e))
+          try: () => JSON.stringify(a, options?.replacer, options?.space),
+          catch: (e) => new ParseResult.Type(ast, a, getErrorMessage(e))
         })
     }
   ).annotations({
@@ -5150,7 +5239,7 @@ export const parseJson: {
    * @category string transformations
    * @since 3.10.0
    */
-  <A, I, R>(schema: Schema<A, I, R>, options?: ParseJsonOptions): SchemaClass<A, string, R>
+  <S extends Schema.Any>(schema: S, options?: ParseJsonOptions): transform<SchemaClass<unknown, string>, S>
   /**
    * The `ParseJson` combinator provides a method to convert JSON strings into the `unknown` type using the underlying
    * functionality of `JSON.parse`. It also utilizes `JSON.stringify` for encoding.
@@ -5257,17 +5346,17 @@ class URL$ extends transformOrFail(
   URLFromSelf,
   {
     strict: true,
-    decode: (s, _, ast) =>
+    decode: (i, _, ast) =>
       ParseResult.try({
-        try: () => new URL(s),
+        try: () => new URL(i),
         catch: (e) =>
           new ParseResult.Type(
             ast,
-            s,
-            `Unable to decode ${JSON.stringify(s)} into a URL. ${getErrorMessage(e)}`
+            i,
+            `Unable to decode ${JSON.stringify(i)} into a URL. ${getErrorMessage(e)}`
           )
       }),
-    encode: (url) => ParseResult.succeed(url.toString())
+    encode: (a) => ParseResult.succeed(a.toString())
   }
 ).annotations({
   identifier: "URL",
@@ -5304,7 +5393,8 @@ export type FiniteSchemaId = typeof FiniteSchemaId
  * @since 3.10.0
  */
 export const finite =
-  <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
       filter(Number.isFinite, {
         schemaId: FiniteSchemaId,
@@ -5333,11 +5423,11 @@ export type GreaterThanSchemaId = typeof GreaterThanSchemaId
  * @category number filters
  * @since 3.10.0
  */
-export const greaterThan = <A extends number>(
+export const greaterThan = <S extends Schema.Any>(
   exclusiveMinimum: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a > exclusiveMinimum, {
       schemaId: GreaterThanSchemaId,
@@ -5366,11 +5456,11 @@ export type GreaterThanOrEqualToSchemaId = typeof GreaterThanOrEqualToSchemaId
  * @category number filters
  * @since 3.10.0
  */
-export const greaterThanOrEqualTo = <A extends number>(
+export const greaterThanOrEqualTo = <S extends Schema.Any>(
   minimum: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a >= minimum, {
       schemaId: GreaterThanOrEqualToSchemaId,
@@ -5391,11 +5481,11 @@ export const MultipleOfSchemaId: unique symbol = Symbol.for("effect/SchemaId/Mul
  * @category number filters
  * @since 3.10.0
  */
-export const multipleOf = <A extends number>(
+export const multipleOf = <S extends Schema.Any>(
   divisor: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const positiveDivisor = Math.abs(divisor) // spec requires positive divisor
   return self.pipe(
     filter((a) => number_.remainder(a, divisor) === 0, {
@@ -5427,7 +5517,8 @@ export type IntSchemaId = typeof IntSchemaId
  * @since 3.10.0
  */
 export const int =
-  <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
       filter((a) => Number.isSafeInteger(a), {
         schemaId: IntSchemaId,
@@ -5457,8 +5548,8 @@ export type LessThanSchemaId = typeof LessThanSchemaId
  * @since 3.10.0
  */
 export const lessThan =
-  <A extends number>(exclusiveMaximum: number, annotations?: Annotations.Filter<A>) =>
-  <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+  <S extends Schema.Any>(exclusiveMaximum: number, annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
       filter((a) => a < exclusiveMaximum, {
         schemaId: LessThanSchemaId,
@@ -5487,11 +5578,11 @@ export type LessThanOrEqualToSchemaId = typeof LessThanOrEqualToSchemaId
  * @category number filters
  * @since 3.10.0
  */
-export const lessThanOrEqualTo = <A extends number>(
+export const lessThanOrEqualTo = <S extends Schema.Any>(
   maximum: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a <= maximum, {
       schemaId: LessThanOrEqualToSchemaId,
@@ -5520,12 +5611,12 @@ export type BetweenSchemaId = typeof BetweenSchemaId
  * @category number filters
  * @since 3.10.0
  */
-export const between = <A extends number>(
+export const between = <S extends Schema.Any>(
   minimum: number,
   maximum: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a >= minimum && a <= maximum, {
       schemaId: BetweenSchemaId,
@@ -5553,7 +5644,8 @@ export type NonNaNSchemaId = typeof NonNaNSchemaId
  * @since 3.10.0
  */
 export const nonNaN =
-  <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
       filter((a) => !Number.isNaN(a), {
         schemaId: NonNaNSchemaId,
@@ -5567,34 +5659,36 @@ export const nonNaN =
  * @category number filters
  * @since 3.10.0
  */
-export const positive = <A extends number>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> => greaterThan(0, { title: "positive", ...annotations })
+export const positive = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
+  greaterThan(0, { title: "positive", ...annotations })
 
 /**
  * @category number filters
  * @since 3.10.0
  */
-export const negative = <A extends number>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> => lessThan(0, { title: "negative", ...annotations })
+export const negative = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
+  lessThan(0, { title: "negative", ...annotations })
 
 /**
  * @category number filters
  * @since 3.10.0
  */
-export const nonPositive = <A extends number>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const nonPositive = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   lessThanOrEqualTo(0, { title: "nonPositive", ...annotations })
 
 /**
  * @category number filters
  * @since 3.10.0
  */
-export const nonNegative = <A extends number>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const nonNegative = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   greaterThanOrEqualTo(0, { title: "nonNegative", ...annotations })
 
 /**
@@ -5603,40 +5697,51 @@ export const nonNegative = <A extends number>(
  * @category number transformations
  * @since 3.10.0
  */
-export const clamp =
-  (minimum: number, maximum: number) =>
-  <A extends number, I, R>(self: Schema<A, I, R>): transform<Schema<A, I, R>, filter<Schema<A>>> =>
-    transform(
-      self,
-      self.pipe(typeSchema, between(minimum, maximum)),
-      { strict: false, decode: (self) => number_.clamp(self, { minimum, maximum }), encode: identity }
-    )
+export const clamp = (minimum: number, maximum: number) =>
+<S extends Schema.Any, A extends number>(
+  self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+): transform<S, filter<SchemaClass<A>>> => {
+  return transform(
+    self,
+    typeSchema(self).pipe(between(minimum, maximum)),
+    {
+      strict: false,
+      decode: (i) => number_.clamp(i, { minimum, maximum }),
+      encode: identity
+    }
+  )
+}
 
 /**
- * Transforms a `string` into a `number` by parsing the string using the `parse` function of the `effect/Number` module.
+ * Transforms a `string` into a `number` by parsing the string using the `parse`
+ * function of the `effect/Number` module.
  *
- * It returns an error if the value can't be converted (for example when non-numeric characters are provided).
+ * It returns an error if the value can't be converted (for example when
+ * non-numeric characters are provided).
  *
- * The following special string values are supported: "NaN", "Infinity", "-Infinity".
+ * The following special string values are supported: "NaN", "Infinity",
+ * "-Infinity".
  *
  * @category number transformations
  * @since 3.10.0
  */
-export const parseNumber = <A extends string, I, R>(
-  self: Schema<A, I, R>
-): transformOrFail<Schema<A, I, R>, typeof Number$> =>
-  transformOrFail(
+export function parseNumber<S extends Schema.Any, A extends string>(
+  self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+): transformOrFail<S, typeof Number$> {
+  return transformOrFail(
     self,
     Number$,
     {
       strict: false,
-      decode: (s, _, ast) =>
-        ParseResult.fromOption(number_.parse(s), () =>
-          new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a number`)),
-      encode: (n) =>
-        ParseResult.succeed(String(n))
+      decode: (i, _, ast) =>
+        ParseResult.fromOption(
+          number_.parse(i),
+          () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a number`)
+        ),
+      encode: (a) => ParseResult.succeed(String(a))
     }
   )
+}
 
 /**
  * This schema transforms a `string` into a `number` by parsing the string using the `parse` function of the `effect/Number` module.
@@ -5747,11 +5852,11 @@ export class JsonNumber extends Number$.pipe(
  */
 export class Not extends transform(Boolean$.annotations({ description: "a boolean that will be negated" }), Boolean$, {
   strict: true,
-  decode: boolean_.not,
-  encode: boolean_.not
+  decode: (i) => boolean_.not(i),
+  encode: (a) => boolean_.not(a)
 }) {}
 
-const encodeSymbol = (sym: symbol, _: AST.ParseOptions, ast: AST.AST) => {
+const encodeSymbol = (sym: symbol, ast: AST.AST) => {
   const key = Symbol.keyFor(sym)
   return key === undefined
     ? ParseResult.fail(
@@ -5768,8 +5873,8 @@ class Symbol$ extends transformOrFail(
   SymbolFromSelf,
   {
     strict: false,
-    decode: decodeSymbol,
-    encode: encodeSymbol
+    decode: (i) => decodeSymbol(i),
+    encode: (a, _, ast) => encodeSymbol(a, ast)
   }
 ).annotations({ identifier: "Symbol" }) {}
 
@@ -5783,20 +5888,6 @@ export {
   Symbol$ as Symbol
 }
 
-const SymbolStruct = TaggedStruct("symbol", {
-  key: String$
-}).annotations({ description: "an object to be decoded into a globally shared symbol" })
-
-const SymbolFromStruct = transformOrFail(
-  SymbolStruct,
-  SymbolFromSelf,
-  {
-    strict: true,
-    decode: ({ key }) => decodeSymbol(key),
-    encode: (sym, _, ast) => ParseResult.map(encodeSymbol(sym, _, ast), (key) => SymbolStruct.make({ key }))
-  }
-)
-
 /**
  * @category schema id
  * @since 3.10.0
@@ -5813,11 +5904,11 @@ export type GreaterThanBigIntSchemaId = typeof GreaterThanBigIntSchemaId
  * @category bigint filters
  * @since 3.10.0
  */
-export const greaterThanBigInt = <A extends bigint>(
+export const greaterThanBigInt = <S extends Schema.Any>(
   min: bigint,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a > min, {
       schemaId: GreaterThanBigIntSchemaId,
@@ -5844,11 +5935,11 @@ export type GreaterThanOrEqualToBigIntSchemaId = typeof GreaterThanOrEqualToBigI
  * @category bigint filters
  * @since 3.10.0
  */
-export const greaterThanOrEqualToBigInt = <A extends bigint>(
+export const greaterThanOrEqualToBigInt = <S extends Schema.Any>(
   min: bigint,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a >= min, {
       schemaId: GreaterThanOrEqualToBigIntSchemaId,
@@ -5877,11 +5968,11 @@ export type LessThanBigIntSchemaId = typeof LessThanBigIntSchemaId
  * @category bigint filters
  * @since 3.10.0
  */
-export const lessThanBigInt = <A extends bigint>(
+export const lessThanBigInt = <S extends Schema.Any>(
   max: bigint,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a < max, {
       schemaId: LessThanBigIntSchemaId,
@@ -5908,11 +5999,11 @@ export type LessThanOrEqualToBigIntSchemaId = typeof LessThanOrEqualToBigIntSche
  * @category bigint filters
  * @since 3.10.0
  */
-export const lessThanOrEqualToBigInt = <A extends bigint>(
+export const lessThanOrEqualToBigInt = <S extends Schema.Any>(
   max: bigint,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a <= max, {
       schemaId: LessThanOrEqualToBigIntSchemaId,
@@ -5939,12 +6030,12 @@ export type BetweenBigIntSchemaId = typeof BetweenBigIntSchemaId
  * @category bigint filters
  * @since 3.10.0
  */
-export const betweenBigInt = <A extends bigint>(
+export const betweenBigInt = <S extends Schema.Any>(
   min: bigint,
   max: bigint,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => a >= min && a <= max, {
       schemaId: BetweenBigIntSchemaId,
@@ -5959,36 +6050,36 @@ export const betweenBigInt = <A extends bigint>(
  * @category bigint filters
  * @since 3.10.0
  */
-export const positiveBigInt = <A extends bigint>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const positiveBigInt = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   greaterThanBigInt(0n, { title: "positiveBigInt", ...annotations })
 
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export const negativeBigInt = <A extends bigint>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const negativeBigInt = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   lessThanBigInt(0n, { title: "negativeBigInt", ...annotations })
 
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export const nonNegativeBigInt = <A extends bigint>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const nonNegativeBigInt = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   greaterThanOrEqualToBigInt(0n, { title: "nonNegativeBigInt", ...annotations })
 
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export const nonPositiveBigInt = <A extends bigint>(
-  annotations?: Annotations.Filter<A>
-): <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>> =>
+export const nonPositiveBigInt = <S extends Schema.Any>(
+  annotations?: Annotations.Filter<Schema.Type<S>>
+): <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S> =>
   lessThanOrEqualToBigInt(0n, { title: "nonPositiveBigInt", ...annotations })
 
 /**
@@ -5997,14 +6088,19 @@ export const nonPositiveBigInt = <A extends bigint>(
  * @category bigint transformations
  * @since 3.10.0
  */
-export const clampBigInt =
-  (minimum: bigint, maximum: bigint) =>
-  <A extends bigint, I, R>(self: Schema<A, I, R>): transform<Schema<A, I, R>, filter<Schema<A>>> =>
-    transform(
-      self,
-      self.pipe(typeSchema, betweenBigInt(minimum, maximum)),
-      { strict: false, decode: (self) => bigInt_.clamp(self, { minimum, maximum }), encode: identity }
-    )
+export const clampBigInt = (minimum: bigint, maximum: bigint) =>
+<S extends Schema.Any, A extends bigint>(
+  self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+): transform<S, filter<SchemaClass<A>>> =>
+  transform(
+    self,
+    self.pipe(typeSchema, betweenBigInt(minimum, maximum)),
+    {
+      strict: false,
+      decode: (i) => bigInt_.clamp(i, { minimum, maximum }),
+      encode: identity
+    }
+  )
 
 /** @ignore */
 class BigInt$ extends transformOrFail(
@@ -6012,12 +6108,12 @@ class BigInt$ extends transformOrFail(
   BigIntFromSelf,
   {
     strict: true,
-    decode: (s, _, ast) =>
+    decode: (i, _, ast) =>
       ParseResult.fromOption(
-        bigInt_.fromString(s),
-        () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a bigint`)
+        bigInt_.fromString(i),
+        () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a bigint`)
       ),
-    encode: (n) => ParseResult.succeed(String(n))
+    encode: (a) => ParseResult.succeed(String(a))
   }
 ).annotations({ identifier: "BigInt" }) {}
 
@@ -6110,15 +6206,15 @@ export class BigIntFromNumber extends transformOrFail(
   BigIntFromSelf.pipe(betweenBigInt(BigInt(Number.MIN_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER))),
   {
     strict: true,
-    decode: (n, _, ast) =>
+    decode: (i, _, ast) =>
       ParseResult.fromOption(
-        bigInt_.fromNumber(n),
-        () => new ParseResult.Type(ast, n, `Unable to decode ${n} into a bigint`)
+        bigInt_.fromNumber(i),
+        () => new ParseResult.Type(ast, i, `Unable to decode ${i} into a bigint`)
       ),
-    encode: (b, _, ast) =>
+    encode: (a, _, ast) =>
       ParseResult.fromOption(
-        bigInt_.toNumber(b),
-        () => new ParseResult.Type(ast, b, `Unable to encode ${b}n into a number`)
+        bigInt_.toNumber(a),
+        () => new ParseResult.Type(ast, a, `Unable to encode ${a}n into a number`)
       )
   }
 ).annotations({ identifier: "BigIntFromNumber" }) {}
@@ -6150,11 +6246,11 @@ const redactedParse = <A, R>(
  * @since 3.10.0
  */
 export interface RedactedFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     RedactedFromSelf<Value>,
     redacted_.Redacted<Schema.Type<Value>>,
     redacted_.Redacted<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -6162,9 +6258,7 @@ export interface RedactedFromSelf<Value extends Schema.Any> extends
  * @category Redacted constructors
  * @since 3.10.0
  */
-export const RedactedFromSelf = <Value extends Schema.Any>(
-  value: Value
-): RedactedFromSelf<Value> =>
+export const RedactedFromSelf = <Value extends Schema.Any>(value: Value): RedactedFromSelf<Value> =>
   declare(
     [value],
     {
@@ -6183,31 +6277,25 @@ export const RedactedFromSelf = <Value extends Schema.Any>(
  * @category api interface
  * @since 3.10.0
  */
-export interface Redacted<Value extends Schema.Any> extends
-  AnnotableClass<
-    Redacted<Value>,
-    redacted_.Redacted<Schema.Type<Value>>,
-    Schema.Encoded<Value>,
-    Schema.Context<Value>
-  >
+export interface Redacted<Value extends Schema.Any>
+  extends transform<Value, RedactedFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
- * A schema that transforms any type `A` into a `Redacted<A>`.
+ * A transformation that transform a `Schema<A, I, R>` into a
+ * `RedactedFromSelf<A>`.
  *
  * @category Redacted transformations
  * @since 3.10.0
  */
-export const Redacted = <Value extends Schema.Any>(
-  value: Value
-): Redacted<Value> => {
+export function Redacted<Value extends Schema.Any>(value: Value): Redacted<Value> {
   return transform(
     value,
-    RedactedFromSelf(typeSchema(value)),
+    RedactedFromSelf(typeSchema(asSchema(value))),
     {
       strict: true,
-      decode: (value) => redacted_.make(value),
-      encode: (value) => redacted_.value(value)
+      decode: (i) => redacted_.make(i),
+      encode: (a) => redacted_.value(a)
     }
   )
 }
@@ -6243,11 +6331,10 @@ export class DurationFromNanos extends transformOrFail(
   DurationFromSelf.pipe(filter((duration) => duration_.isFinite(duration), { description: "a finite duration" })),
   {
     strict: true,
-    decode: (nanos) => ParseResult.succeed(duration_.nanos(nanos)),
-    encode: (duration, _, ast) =>
-      option_.match(duration_.toNanos(duration), {
-        onNone: () =>
-          ParseResult.fail(new ParseResult.Type(ast, duration, `Unable to encode ${duration} into a bigint`)),
+    decode: (i) => ParseResult.succeed(duration_.nanos(i)),
+    encode: (a, _, ast) =>
+      option_.match(duration_.toNanos(a), {
+        onNone: () => ParseResult.fail(new ParseResult.Type(ast, a, `Unable to encode ${a} into a bigint`)),
         onSome: (nanos) => ParseResult.succeed(nanos)
       })
   }
@@ -6275,8 +6362,8 @@ export class DurationFromMillis extends transform(
   DurationFromSelf,
   {
     strict: true,
-    decode: (ms) => duration_.millis(ms),
-    encode: (duration) => duration_.toMillis(duration)
+    decode: (i) => duration_.millis(i),
+    encode: (a) => duration_.toMillis(a)
   }
 ).annotations({ identifier: "DurationFromMillis" }) {}
 
@@ -6338,26 +6425,26 @@ export class Duration extends transform(
   DurationFromSelf,
   {
     strict: true,
-    decode: (input) => {
-      if (isDurationValue(input)) {
-        switch (input._tag) {
+    decode: (i) => {
+      if (isDurationValue(i)) {
+        switch (i._tag) {
           case "Millis":
-            return duration_.millis(input.millis)
+            return duration_.millis(i.millis)
           case "Nanos":
-            return duration_.nanos(input.nanos)
+            return duration_.nanos(i.nanos)
           case "Infinity":
             return duration_.infinity
         }
       }
-      const [seconds, nanos] = input
+      const [seconds, nanos] = i
       return seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos))
     },
-    encode: (duration) => {
-      switch (duration.value._tag) {
+    encode: (a) => {
+      switch (a.value._tag) {
         case "Millis":
-          return DurationValueMillis.make({ millis: duration.value.millis })
+          return DurationValueMillis.make({ millis: a.value.millis })
         case "Nanos":
-          return DurationValueNanos.make({ nanos: duration.value.nanos })
+          return DurationValueNanos.make({ nanos: a.value.nanos })
         case "Infinity":
           return durationValueInfinity
       }
@@ -6373,11 +6460,17 @@ export class Duration extends transform(
  */
 export const clampDuration =
   (minimum: duration_.DurationInput, maximum: duration_.DurationInput) =>
-  <A extends duration_.Duration, I, R>(self: Schema<A, I, R>): transform<Schema<A, I, R>, filter<Schema<A>>> =>
+  <S extends Schema.Any, A extends duration_.Duration>(
+    self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+  ): transform<S, filter<SchemaClass<A>>> =>
     transform(
       self,
       self.pipe(typeSchema, betweenDuration(minimum, maximum)),
-      { strict: false, decode: (self) => duration_.clamp(self, { minimum, maximum }), encode: identity }
+      {
+        strict: false,
+        decode: (i) => duration_.clamp(i, { minimum, maximum }),
+        encode: identity
+      }
     )
 
 /**
@@ -6390,11 +6483,11 @@ export const LessThanDurationSchemaId: unique symbol = Symbol.for("effect/Schema
  * @category Duration filters
  * @since 3.10.0
  */
-export const lessThanDuration = <A extends duration_.Duration>(
+export const lessThanDuration = <S extends Schema.Any>(
   max: duration_.DurationInput,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => duration_.lessThan(a, max), {
       schemaId: LessThanDurationSchemaId,
@@ -6417,11 +6510,11 @@ export const LessThanOrEqualToDurationSchemaId: unique symbol = Symbol.for(
  * @category Duration filters
  * @since 3.10.0
  */
-export const lessThanOrEqualToDuration = <A extends duration_.Duration>(
+export const lessThanOrEqualToDuration = <S extends Schema.Any>(
   max: duration_.DurationInput,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => duration_.lessThanOrEqualTo(a, max), {
       schemaId: LessThanDurationSchemaId,
@@ -6442,11 +6535,11 @@ export const GreaterThanDurationSchemaId: unique symbol = Symbol.for("effect/Sch
  * @category Duration filters
  * @since 3.10.0
  */
-export const greaterThanDuration = <A extends duration_.Duration>(
+export const greaterThanDuration = <S extends Schema.Any>(
   min: duration_.DurationInput,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => duration_.greaterThan(a, min), {
       schemaId: GreaterThanDurationSchemaId,
@@ -6469,11 +6562,11 @@ export const GreaterThanOrEqualToDurationSchemaId: unique symbol = Symbol.for(
  * @category Duration filters
  * @since 3.10.0
  */
-export const greaterThanOrEqualToDuration = <A extends duration_.Duration>(
+export const greaterThanOrEqualToDuration = <S extends Schema.Any>(
   min: duration_.DurationInput,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => duration_.greaterThanOrEqualTo(a, min), {
       schemaId: GreaterThanOrEqualToDurationSchemaId,
@@ -6494,12 +6587,12 @@ export const BetweenDurationSchemaId: unique symbol = Symbol.for("effect/SchemaI
  * @category Duration filters
  * @since 3.10.0
  */
-export const betweenDuration = <A extends duration_.Duration>(
+export const betweenDuration = <S extends Schema.Any>(
   minimum: duration_.DurationInput,
   maximum: duration_.DurationInput,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a) => duration_.between(a, { minimum, maximum }), {
       schemaId: BetweenDurationSchemaId,
@@ -6514,7 +6607,7 @@ export const betweenDuration = <A extends duration_.Duration>(
  * @category Uint8Array constructors
  * @since 3.10.0
  */
-export const Uint8ArrayFromSelf: Schema<Uint8Array> = declare(
+export class Uint8ArrayFromSelf extends declare(
   Predicate.isUint8Array,
   {
     identifier: "Uint8ArrayFromSelf",
@@ -6522,26 +6615,31 @@ export const Uint8ArrayFromSelf: Schema<Uint8Array> = declare(
     arbitrary: (): LazyArbitrary<Uint8Array> => (fc) => fc.uint8Array(),
     equivalence: (): Equivalence.Equivalence<Uint8Array> => array_.getEquivalence(Equal.equals) as any
   }
-)
+) {}
 
 /**
  * @category number constructors
  * @since 3.11.10
  */
-export const Uint8 = Number$.pipe(
+export class Uint8 extends Number$.pipe(
   between(0, 255, {
     identifier: "Uint8",
     description: "a 8-bit unsigned integer"
   })
-)
+) {}
 
-const Uint8Array$: Schema<Uint8Array, ReadonlyArray<number>> = transform(
+/** @ignore */
+class Uint8Array$ extends transform(
   Array$(Uint8).annotations({
     description: "an array of 8-bit unsigned integers to be decoded into a Uint8Array"
   }),
   Uint8ArrayFromSelf,
-  { strict: true, decode: (numbers) => Uint8Array.from(numbers), encode: (uint8Array) => Array.from(uint8Array) }
-).annotations({ identifier: "Uint8Array" })
+  {
+    strict: true,
+    decode: (i) => Uint8Array.from(i),
+    encode: (a) => Array.from(a)
+  }
+).annotations({ identifier: "Uint8Array" }) {}
 
 export {
   /**
@@ -6563,12 +6661,12 @@ const makeUint8ArrayTransformation = (
     Uint8ArrayFromSelf,
     {
       strict: true,
-      decode: (s, _, ast) =>
+      decode: (i, _, ast) =>
         either_.mapLeft(
-          decode(s),
-          (decodeException) => new ParseResult.Type(ast, s, decodeException.message)
+          decode(i),
+          (decodeException) => new ParseResult.Type(ast, i, decodeException.message)
         ),
-      encode: (u) => ParseResult.succeed(encode(u))
+      encode: (a) => ParseResult.succeed(encode(a))
     }
   ).annotations({ identifier: id })
 
@@ -6620,12 +6718,12 @@ const makeEncodingTransformation = (
     String$,
     {
       strict: true,
-      decode: (s, _, ast) =>
+      decode: (i, _, ast) =>
         either_.mapLeft(
-          decode(s),
-          (decodeException) => new ParseResult.Type(ast, s, decodeException.message)
+          decode(i),
+          (decodeException) => new ParseResult.Type(ast, i, decodeException.message)
         ),
-      encode: (u) => ParseResult.succeed(encode(u))
+      encode: (a) => ParseResult.succeed(encode(a))
     }
   ).annotations({ identifier: `StringFrom${id}` })
 
@@ -6694,15 +6792,15 @@ export const StringFromUriComponent = transformOrFail(
   String$,
   {
     strict: true,
-    decode: (s, _, ast) =>
+    decode: (i, _, ast) =>
       either_.mapLeft(
-        Encoding.decodeUriComponent(s),
-        (decodeException) => new ParseResult.Type(ast, s, decodeException.message)
+        Encoding.decodeUriComponent(i),
+        (decodeException) => new ParseResult.Type(ast, i, decodeException.message)
       ),
-    encode: (u, _, ast) =>
+    encode: (a, _, ast) =>
       either_.mapLeft(
-        Encoding.encodeUriComponent(u),
-        (encodeException) => new ParseResult.Type(ast, u, encodeException.message)
+        Encoding.encodeUriComponent(a),
+        (encodeException) => new ParseResult.Type(ast, a, encodeException.message)
       )
   }
 ).annotations({ identifier: `StringFromUriComponent` })
@@ -6723,11 +6821,11 @@ export type MinItemsSchemaId = typeof MinItemsSchemaId
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export const minItems = <A extends ReadonlyArray<any>>(
+export const minItems = <S extends Schema.Any>(
   n: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends ReadonlyArray<any>>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const minItems = Math.floor(n)
   if (minItems < 1) {
     throw new Error(
@@ -6765,11 +6863,11 @@ export type MaxItemsSchemaId = typeof MaxItemsSchemaId
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export const maxItems = <A extends ReadonlyArray<any>>(
+export const maxItems = <S extends Schema.Any>(
   n: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends ReadonlyArray<any>>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const maxItems = Math.floor(n)
   if (maxItems < 1) {
     throw new Error(
@@ -6804,11 +6902,11 @@ export type ItemsCountSchemaId = typeof ItemsCountSchemaId
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export const itemsCount = <A extends ReadonlyArray<any>>(
+export const itemsCount = <S extends Schema.Any>(
   n: number,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends ReadonlyArray<any>>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const itemsCount = Math.floor(n)
   if (itemsCount < 0) {
     throw new Error(
@@ -6841,12 +6939,23 @@ export const getNumberIndexedAccess = <A extends ReadonlyArray<any>, I extends R
  * @category ReadonlyArray transformations
  * @since 3.10.0
  */
-export const head = <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>): SchemaClass<option_.Option<A>, I, R> =>
-  transform(
+export function head<S extends Schema.Any, A extends ReadonlyArray<unknown>>(
+  self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+): transform<S, OptionFromSelf<SchemaClass<A[number]>>> {
+  return transform(
     self,
     OptionFromSelf(getNumberIndexedAccess(typeSchema(self))),
-    { strict: true, decode: array_.head, encode: option_.match({ onNone: () => [], onSome: array_.of }) }
+    {
+      strict: false,
+      decode: (i) => array_.head(i),
+      encode: (a) =>
+        option_.match(a, {
+          onNone: () => [],
+          onSome: array_.of
+        })
+    }
   )
+}
 
 /**
  * Get the first element of a `NonEmptyReadonlyArray`.
@@ -6854,12 +6963,19 @@ export const head = <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>): SchemaClass
  * @category NonEmptyReadonlyArray transformations
  * @since 3.12.0
  */
-export const headNonEmpty = <A, I, R>(self: Schema<array_.NonEmptyReadonlyArray<A>, I, R>): SchemaClass<A, I, R> =>
-  transform(
+export function headNonEmpty<S extends Schema.Any, A extends array_.NonEmptyReadonlyArray<unknown>>(
+  self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+): transform<S, SchemaClass<A[number]>> {
+  return transform(
     self,
     getNumberIndexedAccess(typeSchema(self)),
-    { strict: true, decode: array_.headNonEmpty, encode: array_.of }
+    {
+      strict: false,
+      decode: (i) => array_.headNonEmpty(i),
+      encode: (a) => array_.of(a)
+    }
   )
+}
 
 /**
  * Retrieves the first element of a `ReadonlyArray`.
@@ -6878,7 +6994,9 @@ export const headOrElse: {
    * @category ReadonlyArray transformations
    * @since 3.10.0
    */
-  <A>(fallback?: LazyArg<A>): <I, R>(self: Schema<ReadonlyArray<A>, I, R>) => SchemaClass<A, I, R>
+  <S extends Schema.Any, A extends ReadonlyArray<unknown>>(fallback?: LazyArg<A[number]>): (
+    self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+  ) => transform<S, SchemaClass<A[number]>>
   /**
    * Retrieves the first element of a `ReadonlyArray`.
    *
@@ -6887,21 +7005,27 @@ export const headOrElse: {
    * @category ReadonlyArray transformations
    * @since 3.10.0
    */
-  <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>, fallback?: LazyArg<A>): SchemaClass<A, I, R>
+  <S extends Schema.Any, A extends ReadonlyArray<unknown>>(
+    self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>,
+    fallback?: LazyArg<A[number]>
+  ): transform<S, SchemaClass<A[number]>>
 } = dual(
   (args) => isSchema(args[0]),
-  <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>, fallback?: LazyArg<A>): SchemaClass<A, I, R> =>
+  <A, I, R>(
+    self: Schema<ReadonlyArray<A>, I, R>,
+    fallback?: LazyArg<A>
+  ): transform<Schema<ReadonlyArray<A>, I, R>, SchemaClass<A>> =>
     transformOrFail(
       self,
       getNumberIndexedAccess(typeSchema(self)),
       {
         strict: true,
-        decode: (as, _, ast) =>
-          as.length > 0
-            ? ParseResult.succeed(as[0])
+        decode: (i, _, ast) =>
+          i.length > 0
+            ? ParseResult.succeed(i[0])
             : fallback
             ? ParseResult.succeed(fallback())
-            : ParseResult.fail(new ParseResult.Type(ast, as, "Unable to retrieve the first element of an empty array")),
+            : ParseResult.fail(new ParseResult.Type(ast, i, "Unable to retrieve the first element of an empty array")),
         encode: (a) => ParseResult.succeed(array_.of(a))
       }
     )
@@ -6923,7 +7047,8 @@ export const ValidDateSchemaId: unique symbol = Symbol.for("effect/SchemaId/Vali
  * @since 3.10.0
  */
 export const validDate =
-  (annotations?: Annotations.Filter<Date>) => <I, R>(self: Schema<Date, I, R>): filter<Schema<Date, I, R>> =>
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
     self.pipe(
       filter((a) => !Number.isNaN(a.getTime()), {
         schemaId: ValidDateSchemaId,
@@ -6944,13 +7069,13 @@ export const LessThanDateSchemaId: unique symbol = Symbol.for("effect/SchemaId/L
  * @category Date filters
  * @since 3.10.0
  */
-export const lessThanDate = <A extends Date>(
+export const lessThanDate = <S extends Schema.Any>(
   max: Date,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
-    filter((a) => a < max, {
+    filter((a: Date) => a < max, {
       schemaId: LessThanDateSchemaId,
       [LessThanDateSchemaId]: { max },
       title: `lessThanDate(${util_.formatDate(max)})`,
@@ -6971,13 +7096,13 @@ export const LessThanOrEqualToDateSchemaId: unique symbol = Symbol.for(
  * @category Date filters
  * @since 3.10.0
  */
-export const lessThanOrEqualToDate = <A extends Date>(
+export const lessThanOrEqualToDate = <S extends Schema.Any>(
   max: Date,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
-    filter((a) => a <= max, {
+    filter((a: Date) => a <= max, {
       schemaId: LessThanDateSchemaId,
       [LessThanDateSchemaId]: { max },
       title: `lessThanOrEqualToDate(${util_.formatDate(max)})`,
@@ -6996,13 +7121,13 @@ export const GreaterThanDateSchemaId: unique symbol = Symbol.for("effect/SchemaI
  * @category Date filters
  * @since 3.10.0
  */
-export const greaterThanDate = <A extends Date>(
+export const greaterThanDate = <S extends Schema.Any>(
   min: Date,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
-    filter((a) => a > min, {
+    filter((a: Date) => a > min, {
       schemaId: GreaterThanDateSchemaId,
       [GreaterThanDateSchemaId]: { min },
       title: `greaterThanDate(${util_.formatDate(min)})`,
@@ -7023,13 +7148,13 @@ export const GreaterThanOrEqualToDateSchemaId: unique symbol = Symbol.for(
  * @category Date filters
  * @since 3.10.0
  */
-export const greaterThanOrEqualToDate = <A extends Date>(
+export const greaterThanOrEqualToDate = <S extends Schema.Any>(
   min: Date,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
-    filter((a) => a >= min, {
+    filter((a: Date) => a >= min, {
       schemaId: GreaterThanOrEqualToDateSchemaId,
       [GreaterThanOrEqualToDateSchemaId]: { min },
       title: `greaterThanOrEqualToDate(${util_.formatDate(min)})`,
@@ -7048,14 +7173,14 @@ export const BetweenDateSchemaId: unique symbol = Symbol.for("effect/SchemaId/Be
  * @category Date filters
  * @since 3.10.0
  */
-export const betweenDate = <A extends Date>(
+export const betweenDate = <S extends Schema.Any>(
   min: Date,
   max: Date,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
+<A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
-    filter((a) => a <= max && a >= min, {
+    filter((a: Date) => a <= max && a >= min, {
       schemaId: BetweenDateSchemaId,
       [BetweenDateSchemaId]: { max, min },
       title: `betweenDate(${util_.formatDate(min)}, ${util_.formatDate(max)})`,
@@ -7125,7 +7250,11 @@ export class ValidDateFromSelf extends DateFromSelf.pipe(
 export class DateFromString extends transform(
   String$.annotations({ description: "a string to be decoded into a Date" }),
   DateFromSelf,
-  { strict: true, decode: (s) => new Date(s), encode: (d) => util_.formatDate(d) }
+  {
+    strict: true,
+    decode: (i) => new Date(i),
+    encode: (a) => util_.formatDate(a)
+  }
 ).annotations({ identifier: "DateFromString" }) {}
 
 /** @ignore */
@@ -7159,7 +7288,11 @@ export {
 export class DateFromNumber extends transform(
   Number$.annotations({ description: "a number to be decoded into a Date" }),
   DateFromSelf,
-  { strict: true, decode: (n) => new Date(n), encode: (d) => d.getTime() }
+  {
+    strict: true,
+    decode: (i) => new Date(i),
+    encode: (a) => a.getTime()
+  }
 ).annotations({ identifier: "DateFromNumber" }) {}
 
 /**
@@ -7180,7 +7313,7 @@ export class DateTimeUtcFromSelf extends declare(
   }
 ) {}
 
-const decodeDateTimeUtc = <A extends dateTime.DateTime.Input>(input: A, _: ParseOptions, ast: AST.AST) =>
+const decodeDateTimeUtc = <A extends dateTime.DateTime.Input>(input: A, ast: AST.AST) =>
   ParseResult.try({
     try: () => dateTime.unsafeMake(input),
     catch: () => new ParseResult.Type(ast, input, `Unable to decode ${util_.formatUnknown(input)} into a DateTime.Utc`)
@@ -7197,8 +7330,8 @@ export class DateTimeUtcFromNumber extends transformOrFail(
   DateTimeUtcFromSelf,
   {
     strict: true,
-    decode: decodeDateTimeUtc,
-    encode: (dt) => ParseResult.succeed(dateTime.toEpochMillis(dt))
+    decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
+    encode: (a) => ParseResult.succeed(dateTime.toEpochMillis(a))
   }
 ).annotations({ identifier: "DateTimeUtcFromNumber" }) {}
 
@@ -7213,8 +7346,8 @@ export class DateTimeUtcFromDate extends transformOrFail(
   DateTimeUtcFromSelf,
   {
     strict: true,
-    decode: decodeDateTimeUtc,
-    encode: (dt) => ParseResult.succeed(dateTime.toDateUtc(dt))
+    decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
+    encode: (a) => ParseResult.succeed(dateTime.toDateUtc(a))
   }
 ).annotations({ identifier: "DateTimeUtcFromDate" }) {}
 
@@ -7229,8 +7362,8 @@ export class DateTimeUtc extends transformOrFail(
   DateTimeUtcFromSelf,
   {
     strict: true,
-    decode: decodeDateTimeUtc,
-    encode: (dt) => ParseResult.succeed(dateTime.formatIso(dt))
+    decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
+    encode: (a) => ParseResult.succeed(dateTime.formatIso(a))
   }
 ).annotations({ identifier: "DateTimeUtc" }) {}
 
@@ -7262,7 +7395,11 @@ export class TimeZoneOffsetFromSelf extends declare(
 export class TimeZoneOffset extends transform(
   Number$.annotations({ description: "a number to be decoded into a TimeZone.Offset" }),
   TimeZoneOffsetFromSelf,
-  { strict: true, decode: dateTime.zoneMakeOffset, encode: (tz) => tz.offset }
+  {
+    strict: true,
+    decode: (i) => dateTime.zoneMakeOffset(i),
+    encode: (a) => a.offset
+  }
 ).annotations({ identifier: "TimeZoneOffset" }) {}
 
 const timeZoneNamedArbitrary = (): LazyArbitrary<dateTime.TimeZone.Named> => (fc) =>
@@ -7295,12 +7432,12 @@ export class TimeZoneNamed extends transformOrFail(
   TimeZoneNamedFromSelf,
   {
     strict: true,
-    decode: (s, _, ast) =>
+    decode: (i, _, ast) =>
       ParseResult.try({
-        try: () => dateTime.zoneUnsafeMakeNamed(s),
-        catch: () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a TimeZone.Named`)
+        try: () => dateTime.zoneUnsafeMakeNamed(i),
+        catch: () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a TimeZone.Named`)
       }),
-    encode: (tz) => ParseResult.succeed(tz.id)
+    encode: (a) => ParseResult.succeed(a.id)
   }
 ).annotations({ identifier: "TimeZoneNamed" }) {}
 
@@ -7321,13 +7458,13 @@ export class TimeZone extends transformOrFail(
   TimeZoneFromSelf,
   {
     strict: true,
-    decode: (s, _, ast) =>
-      option_.match(dateTime.zoneFromString(s), {
+    decode: (i, _, ast) =>
+      option_.match(dateTime.zoneFromString(i), {
         onNone: () =>
-          ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a TimeZone`)),
+          ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a TimeZone`)),
         onSome: ParseResult.succeed
       }),
-    encode: (tz) => ParseResult.succeed(dateTime.zoneToString(tz))
+    encode: (a) => ParseResult.succeed(dateTime.zoneToString(a))
   }
 ).annotations({ identifier: "TimeZone" }) {}
 
@@ -7373,13 +7510,13 @@ export class DateTimeZoned extends transformOrFail(
   DateTimeZonedFromSelf,
   {
     strict: true,
-    decode: (s, _, ast) =>
-      option_.match(dateTime.makeZonedFromString(s), {
+    decode: (i, _, ast) =>
+      option_.match(dateTime.makeZonedFromString(i), {
         onNone: () =>
-          ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a DateTime.Zoned`)),
+          ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a DateTime.Zoned`)),
         onSome: ParseResult.succeed
       }),
-    encode: (dt) => ParseResult.succeed(dateTime.formatIsoZoned(dt))
+    encode: (a) => ParseResult.succeed(dateTime.formatIsoZoned(a))
   }
 ).annotations({ identifier: "DateTimeZoned" }) {}
 
@@ -7400,13 +7537,13 @@ const OptionNoneEncoded = Struct({
   _tag: Literal("None")
 }).annotations({ description: "NoneEncoded" })
 
-const optionSomeEncoded = <A, I, R>(value: Schema<A, I, R>) =>
+const optionSomeEncoded = <Value extends Schema.Any>(value: Value) =>
   Struct({
     _tag: Literal("Some"),
     value
   }).annotations({ description: `SomeEncoded<${format(value)}>` })
 
-const optionEncoded = <A, I, R>(value: Schema<A, I, R>) =>
+const optionEncoded = <Value extends Schema.Any>(value: Value) =>
   Union(
     OptionNoneEncoded,
     optionSomeEncoded(value)
@@ -7445,11 +7582,11 @@ const optionParse =
  * @since 3.10.0
  */
 export interface OptionFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     OptionFromSelf<Value>,
     option_.Option<Schema.Type<Value>>,
     option_.Option<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -7457,9 +7594,7 @@ export interface OptionFromSelf<Value extends Schema.Any> extends
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromSelf = <Value extends Schema.Any>(
-  value: Value
-): OptionFromSelf<Value> => {
+export const OptionFromSelf = <Value extends Schema.Any>(value: Value): OptionFromSelf<Value> => {
   return declare(
     [value],
     {
@@ -7475,72 +7610,68 @@ export const OptionFromSelf = <Value extends Schema.Any>(
   )
 }
 
-const makeNoneEncoded = {
-  _tag: "None"
-} as const
-const makeSomeEncoded = <A>(value: A) => ({
-  _tag: "Some",
-  value
-} as const)
-
 /**
  * @category api interface
  * @since 3.10.0
  */
 export interface Option<Value extends Schema.Any> extends
-  AnnotableClass<
-    Option<Value>,
-    option_.Option<Schema.Type<Value>>,
-    OptionEncoded<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+  transform<
+    Union<[
+      Struct<{ _tag: Literal<["None"]> }>,
+      Struct<{ _tag: Literal<["Some"]>; value: Value }>
+    ]>,
+    OptionFromSelf<SchemaClass<Schema.Type<Value>>>
   >
 {}
 
+const makeNoneEncoded = {
+  _tag: "None"
+} as const
+
+const makeSomeEncoded = <A>(value: A) => ({
+  _tag: "Some",
+  value
+} as const)
+
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const Option = <Value extends Schema.Any>(value: Value): Option<Value> => {
+export function Option<Value extends Schema.Any>(value: Value): Option<Value> {
   const value_ = asSchema(value)
-  return transform(
+  const out = transform(
     optionEncoded(value_),
     OptionFromSelf(typeSchema(value_)),
     {
       strict: true,
-      decode: optionDecode,
-      encode: option_.match({
-        onNone: () => makeNoneEncoded,
-        onSome: makeSomeEncoded
-      })
+      decode: (i) => optionDecode(i),
+      encode: (a) =>
+        option_.match(a, {
+          onNone: () => makeNoneEncoded,
+          onSome: makeSomeEncoded
+        })
     }
   )
+  return out as any
 }
 
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface OptionFromNullOr<Value extends Schema.Any> extends
-  AnnotableClass<
-    OptionFromNullOr<Value>,
-    option_.Option<Schema.Type<Value>>,
-    Schema.Encoded<Value> | null,
-    Schema.Context<Value>
-  >
+export interface OptionFromNullOr<Value extends Schema.Any>
+  extends transform<NullOr<Value>, OptionFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromNullOr = <Value extends Schema.Any>(
-  value: Value
-): OptionFromNullOr<Value> => {
-  const value_ = asSchema(value)
-  return transform(NullOr(value_), OptionFromSelf(typeSchema(value_)), {
+export function OptionFromNullOr<Value extends Schema.Any>(value: Value): OptionFromNullOr<Value> {
+  return transform(NullOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: option_.fromNullable,
-    encode: option_.getOrNull
+    decode: (i) => option_.fromNullable(i),
+    encode: (a) => option_.getOrNull(a)
   })
 }
 
@@ -7548,31 +7679,27 @@ export const OptionFromNullOr = <Value extends Schema.Any>(
  * @category api interface
  * @since 3.10.0
  */
-export interface OptionFromNullishOr<Value extends Schema.Any> extends
-  AnnotableClass<
-    OptionFromNullishOr<Value>,
-    option_.Option<Schema.Type<Value>>,
-    Schema.Encoded<Value> | null | undefined,
-    Schema.Context<Value>
-  >
+export interface OptionFromNullishOr<Value extends Schema.Any>
+  extends transform<NullishOr<Value>, OptionFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromNullishOr = <Value extends Schema.Any>(
+export function OptionFromNullishOr<Value extends Schema.Any>(
   value: Value,
   onNoneEncoding: null | undefined
-): OptionFromNullishOr<Value> => {
-  const value_ = asSchema(value)
+): OptionFromNullishOr<Value> {
   return transform(
-    NullishOr(value_),
-    OptionFromSelf(typeSchema(value_)),
+    NullishOr(value),
+    OptionFromSelf(typeSchema(asSchema(value))),
     {
       strict: true,
-      decode: option_.fromNullable,
-      encode: onNoneEncoding === null ? option_.getOrNull : option_.getOrUndefined
+      decode: (i) => option_.fromNullable(i),
+      encode: onNoneEncoding === null ?
+        (a) => option_.getOrNull(a) :
+        (a) => option_.getOrUndefined(a)
     }
   )
 }
@@ -7581,27 +7708,19 @@ export const OptionFromNullishOr = <Value extends Schema.Any>(
  * @category api interface
  * @since 3.10.0
  */
-export interface OptionFromUndefinedOr<Value extends Schema.Any> extends
-  AnnotableClass<
-    OptionFromUndefinedOr<Value>,
-    option_.Option<Schema.Type<Value>>,
-    Schema.Encoded<Value> | undefined,
-    Schema.Context<Value>
-  >
+export interface OptionFromUndefinedOr<Value extends Schema.Any>
+  extends transform<UndefinedOr<Value>, OptionFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromUndefinedOr = <Value extends Schema.Any>(
-  value: Value
-): OptionFromUndefinedOr<Value> => {
-  const value_ = asSchema(value)
-  return transform(UndefinedOr(value_), OptionFromSelf(typeSchema(value_)), {
+export function OptionFromUndefinedOr<Value extends Schema.Any>(value: Value): OptionFromUndefinedOr<Value> {
+  return transform(UndefinedOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: option_.fromNullable,
-    encode: option_.getOrUndefined
+    decode: (i) => option_.fromNullable(i),
+    encode: (a) => option_.getOrUndefined(a)
   })
 }
 
@@ -7622,11 +7741,11 @@ export const OptionFromUndefinedOr = <Value extends Schema.Any>(
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromNonEmptyTrimmedString = transform(String$, OptionFromSelf(NonEmptyTrimmedString), {
+export class OptionFromNonEmptyTrimmedString extends transform(String$, OptionFromSelf(NonEmptyTrimmedString), {
   strict: true,
-  decode: (s) => option_.filter(option_.some(s.trim()), string_.isNonEmpty),
-  encode: option_.getOrElse(() => "")
-})
+  decode: (i) => option_.filter(option_.some(i.trim()), string_.isNonEmpty),
+  encode: (a) => option_.getOrElse(a, () => "")
+}) {}
 
 /**
  * @category Either utils
@@ -7652,21 +7771,21 @@ export type LeftEncoded<IE> = {
  */
 export type EitherEncoded<IR, IL> = RightEncoded<IR> | LeftEncoded<IL>
 
-const rightEncoded = <RA, RI, RR>(right: Schema<RA, RI, RR>): Schema<RightEncoded<RA>, RightEncoded<RI>, RR> =>
+const rightEncoded = <Right extends Schema.All>(right: Right) =>
   Struct({
     _tag: Literal("Right"),
     right
   }).annotations({ description: `RightEncoded<${format(right)}>` })
 
-const leftEncoded = <LA, LI, LR>(left: Schema<LA, LI, LR>): Schema<LeftEncoded<LA>, LeftEncoded<LI>, LR> =>
+const leftEncoded = <Left extends Schema.All>(left: Left) =>
   Struct({
     _tag: Literal("Left"),
     left
   }).annotations({ description: `LeftEncoded<${format(left)}>` })
 
-const eitherEncoded = <RA, RI, RR, LA, LI, LR>(
-  right: Schema<RA, RI, RR>,
-  left: Schema<LA, LI, LR>
+const eitherEncoded = <Right extends Schema.All, Left extends Schema.All>(
+  right: Right,
+  left: Left
 ) =>
   Union(rightEncoded(right), leftEncoded(left)).annotations({
     description: `EitherEncoded<${format(left)}, ${format(right)}>`
@@ -7711,11 +7830,11 @@ const eitherParse = <RR, R, LR, L>(
  * @since 3.10.0
  */
 export interface EitherFromSelf<R extends Schema.All, L extends Schema.All> extends
-  AnnotableClass<
+  AnnotableDeclare<
     EitherFromSelf<R, L>,
     either_.Either<Schema.Type<R>, Schema.Type<L>>,
     either_.Either<Schema.Encoded<R>, Schema.Encoded<L>>,
-    Schema.Context<R> | Schema.Context<L>
+    [R, L]
   >
 {}
 
@@ -7755,12 +7874,19 @@ const makeRightEncoded = <A>(right: A) => (({
  * @category api interface
  * @since 3.10.0
  */
-export interface Either<R extends Schema.All, L extends Schema.All> extends
-  AnnotableClass<
-    Either<R, L>,
-    either_.Either<Schema.Type<R>, Schema.Type<L>>,
-    EitherEncoded<Schema.Encoded<R>, Schema.Encoded<L>>,
-    Schema.Context<R> | Schema.Context<L>
+export interface Either<Right extends Schema.All, Left extends Schema.All> extends
+  transform<
+    Union<[
+      Struct<{
+        _tag: Literal<["Right"]>
+        right: Right
+      }>,
+      Struct<{
+        _tag: Literal<["Left"]>
+        left: Left
+      }>
+    ]>,
+    EitherFromSelf<SchemaClass<Schema.Type<Right>>, SchemaClass<Schema.Type<Left>>>
   >
 {}
 
@@ -7774,27 +7900,33 @@ export const Either = <R extends Schema.All, L extends Schema.All>({ left, right
 }): Either<R, L> => {
   const right_ = asSchema(right)
   const left_ = asSchema(left)
-  return transform(
+  const out = transform(
     eitherEncoded(right_, left_),
     EitherFromSelf({ left: typeSchema(left_), right: typeSchema(right_) }),
     {
       strict: true,
-      decode: eitherDecode,
-      encode: either_.match({ onLeft: makeLeftEncoded, onRight: makeRightEncoded })
+      decode: (i) => eitherDecode(i),
+      encode: (a) =>
+        either_.match(a, {
+          onLeft: makeLeftEncoded,
+          onRight: makeRightEncoded
+        })
     }
   )
+  return out as any
 }
 
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface EitherFromUnion<R extends Schema.All, L extends Schema.All> extends
-  AnnotableClass<
-    EitherFromUnion<R, L>,
-    either_.Either<Schema.Type<R>, Schema.Type<L>>,
-    Schema.Encoded<R> | Schema.Encoded<L>,
-    Schema.Context<R> | Schema.Context<L>
+export interface EitherFromUnion<Right extends Schema.All, Left extends Schema.All> extends
+  transform<
+    Union<[
+      transform<Right, Struct<{ _tag: Literal<["Right"]>; right: SchemaClass<Schema.Type<Right>> }>>,
+      transform<Left, Struct<{ _tag: Literal<["Left"]>; right: SchemaClass<Schema.Type<Left>> }>>
+    ]>,
+    EitherFromSelf<SchemaClass<Schema.Type<Right>>, SchemaClass<Schema.Type<Left>>>
   >
 {}
 
@@ -7810,33 +7942,38 @@ export interface EitherFromUnion<R extends Schema.All, L extends Schema.All> ext
  * @category Either transformations
  * @since 3.10.0
  */
-export const EitherFromUnion = <R extends Schema.All, L extends Schema.All>({ left, right }: {
-  readonly left: L
-  readonly right: R
-}): EitherFromUnion<R, L> => {
+export const EitherFromUnion = <Right extends Schema.All, Left extends Schema.All>({ left, right }: {
+  readonly left: Left
+  readonly right: Right
+}): EitherFromUnion<Right, Left> => {
   const right_ = asSchema(right)
   const left_ = asSchema(left)
   const toright = typeSchema(right_)
   const toleft = typeSchema(left_)
   const fromRight = transform(right_, rightEncoded(toright), {
     strict: true,
-    decode: makeRightEncoded,
-    encode: (r) => r.right
+    decode: (i) => makeRightEncoded(i),
+    encode: (a) => a.right
   })
   const fromLeft = transform(left_, leftEncoded(toleft), {
     strict: true,
-    decode: makeLeftEncoded,
-    encode: (l) => l.left
+    decode: (i) => makeLeftEncoded(i),
+    encode: (a) => a.left
   })
-  return transform(
+  const out = transform(
     Union(fromRight, fromLeft),
     EitherFromSelf({ left: toleft, right: toright }),
     {
       strict: true,
-      decode: (from) => from._tag === "Left" ? either_.left(from.left) : either_.right(from.right),
-      encode: either_.match({ onLeft: makeLeftEncoded, onRight: makeRightEncoded })
+      decode: (i) => i._tag === "Left" ? either_.left(i.left) : either_.right(i.right),
+      encode: (a) =>
+        either_.match(a, {
+          onLeft: makeLeftEncoded,
+          onRight: makeRightEncoded
+        })
     }
   )
+  return out as any
 }
 
 const mapArbitrary = <K, V>(
@@ -7884,11 +8021,11 @@ const readonlyMapParse = <R, K, V>(
  * @since 3.10.0
  */
 export interface ReadonlyMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     ReadonlyMapFromSelf<K, V>,
     ReadonlyMap<Schema.Type<K>, Schema.Type<V>>,
     ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>,
-    Schema.Context<K> | Schema.Context<V>
+    [K, V]
   >
 {}
 
@@ -7925,11 +8062,11 @@ export const ReadonlyMapFromSelf = <K extends Schema.Any, V extends Schema.Any>(
  * @since 3.10.0
  */
 export interface MapFromSelf<K extends Schema.Any, V extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     MapFromSelf<K, V>,
     Map<Schema.Type<K>, Schema.Type<V>>,
     ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>,
-    Schema.Context<K> | Schema.Context<V>
+    [K, V]
   >
 {}
 
@@ -7946,29 +8083,26 @@ export const MapFromSelf = <K extends Schema.Any, V extends Schema.Any>({ key, v
  * @category api interface
  * @since 3.10.0
  */
-export interface ReadonlyMap$<K extends Schema.Any, V extends Schema.Any> extends
-  AnnotableClass<
-    ReadonlyMap$<K, V>,
-    ReadonlyMap<Schema.Type<K>, Schema.Type<V>>,
-    ReadonlyArray<readonly [Schema.Encoded<K>, Schema.Encoded<V>]>,
-    Schema.Context<K> | Schema.Context<V>
-  >
+export interface ReadonlyMap$<K extends Schema.Any, V extends Schema.Any>
+  extends transform<Array$<Tuple2<K, V>>, ReadonlyMapFromSelf<SchemaClass<Schema.Type<K>>, SchemaClass<Schema.Type<V>>>>
 {}
 
 /**
  * @category ReadonlyMap transformations
  * @since 3.10.0
  */
-export const ReadonlyMap = <K extends Schema.Any, V extends Schema.Any>({ key, value }: {
+export function ReadonlyMap<K extends Schema.Any, V extends Schema.Any>({ key, value }: {
   readonly key: K
   readonly value: V
-}): ReadonlyMap$<K, V> => {
-  const key_ = asSchema(key)
-  const value_ = asSchema(value)
+}): ReadonlyMap$<K, V> {
   return transform(
-    Array$(Tuple(key_, value_)),
-    ReadonlyMapFromSelf({ key: typeSchema(key_), value: typeSchema(value_) }),
-    { strict: true, decode: (as) => new Map(as), encode: (map) => Array.from(map.entries()) }
+    Array$(Tuple(key, value)),
+    ReadonlyMapFromSelf({ key: typeSchema(asSchema(key)), value: typeSchema(asSchema(value)) }),
+    {
+      strict: true,
+      decode: (i) => new Map(i),
+      encode: (a) => Array.from(a.entries())
+    }
   )
 }
 
@@ -7976,25 +8110,23 @@ export const ReadonlyMap = <K extends Schema.Any, V extends Schema.Any>({ key, v
  * @category api interface
  * @since 3.10.0
  */
-export interface Map$<K extends Schema.Any, V extends Schema.Any> extends
-  AnnotableClass<
-    Map$<K, V>,
-    Map<Schema.Type<K>, Schema.Type<V>>,
-    ReadonlyArray<readonly [Schema.Encoded<K>, Schema.Encoded<V>]>,
-    Schema.Context<K> | Schema.Context<V>
-  >
+export interface Map$<K extends Schema.Any, V extends Schema.Any>
+  extends transform<Array$<Tuple2<K, V>>, MapFromSelf<SchemaClass<Schema.Type<K>>, SchemaClass<Schema.Type<V>>>>
 {}
 
-const map = <K extends Schema.Any, V extends Schema.Any>({ key, value }: {
+/** @ignore */
+function map<K extends Schema.Any, V extends Schema.Any>({ key, value }: {
   readonly key: K
   readonly value: V
-}): Map$<K, V> => {
-  const key_ = asSchema(key)
-  const value_ = asSchema(value)
+}): Map$<K, V> {
   return transform(
-    Array$(Tuple(key_, value_)),
-    MapFromSelf({ key: typeSchema(key_), value: typeSchema(value_) }),
-    { strict: true, decode: (as) => new Map(as), encode: (map) => Array.from(map.entries()) }
+    Array$(Tuple(key, value)),
+    MapFromSelf({ key: typeSchema(asSchema(key)), value: typeSchema(asSchema(value)) }),
+    {
+      strict: true,
+      decode: (i) => new Map(i),
+      encode: (a) => Array.from(a.entries())
+    }
   )
 }
 
@@ -8013,7 +8145,7 @@ export {
 export const ReadonlyMapFromRecord = <KA, KR, VA, VI, VR>({ key, value }: {
   key: Schema<KA, string, KR>
   value: Schema<VA, VI, VR>
-}): Schema<ReadonlyMap<KA, VA>, { readonly [x: string]: VI }, KR | VR> =>
+}): SchemaClass<ReadonlyMap<KA, VA>, { readonly [x: string]: VI }, KR | VR> =>
   transform(
     Record({ key: encodedBoundSchema(key), value }).annotations({
       description: "a record to be decoded into a ReadonlyMap"
@@ -8021,8 +8153,8 @@ export const ReadonlyMapFromRecord = <KA, KR, VA, VI, VR>({ key, value }: {
     ReadonlyMapFromSelf({ key, value: typeSchema(value) }),
     {
       strict: true,
-      decode: (record) => new Map(Object.entries(record)),
-      encode: record_.fromEntries
+      decode: (i) => new Map(Object.entries(i)),
+      encode: (a) => Object.fromEntries(a)
     }
   )
 
@@ -8033,7 +8165,7 @@ export const ReadonlyMapFromRecord = <KA, KR, VA, VI, VR>({ key, value }: {
 export const MapFromRecord = <KA, KR, VA, VI, VR>({ key, value }: {
   key: Schema<KA, string, KR>
   value: Schema<VA, VI, VR>
-}): Schema<Map<KA, VA>, { readonly [x: string]: VI }, KR | VR> =>
+}): SchemaClass<Map<KA, VA>, { readonly [x: string]: VI }, KR | VR> =>
   transform(
     Record({ key: encodedBoundSchema(key), value }).annotations({
       description: "a record to be decoded into a Map"
@@ -8041,8 +8173,8 @@ export const MapFromRecord = <KA, KR, VA, VI, VR>({ key, value }: {
     MapFromSelf({ key, value: typeSchema(value) }),
     {
       strict: true,
-      decode: (record) => new Map(Object.entries(record)),
-      encode: record_.fromEntries
+      decode: (i) => new Map(Object.entries(i)),
+      encode: (a) => Object.fromEntries(a)
     }
   )
 
@@ -8075,11 +8207,11 @@ const readonlySetParse = <A, R>(
  * @since 3.10.0
  */
 export interface ReadonlySetFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     ReadonlySetFromSelf<Value>,
     ReadonlySet<Schema.Type<Value>>,
     ReadonlySet<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -8110,11 +8242,11 @@ export const ReadonlySetFromSelf = <Value extends Schema.Any>(value: Value): Rea
  * @since 3.10.0
  */
 export interface SetFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     SetFromSelf<Value>,
     Set<Schema.Type<Value>>,
     ReadonlySet<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -8129,25 +8261,23 @@ export const SetFromSelf = <Value extends Schema.Any>(value: Value): SetFromSelf
  * @category api interface
  * @since 3.10.0
  */
-export interface ReadonlySet$<Value extends Schema.Any> extends
-  AnnotableClass<
-    ReadonlySet$<Value>,
-    ReadonlySet<Schema.Type<Value>>,
-    ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface ReadonlySet$<Value extends Schema.Any>
+  extends transform<Array$<Value>, ReadonlySetFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category ReadonlySet transformations
  * @since 3.10.0
  */
-export const ReadonlySet = <Value extends Schema.Any>(value: Value): ReadonlySet$<Value> => {
-  const value_ = asSchema(value)
+export function ReadonlySet<Value extends Schema.Any>(value: Value): ReadonlySet$<Value> {
   return transform(
-    Array$(value_),
-    ReadonlySetFromSelf(typeSchema(value_)),
-    { strict: true, decode: (as) => new Set(as), encode: (set) => Array.from(set) }
+    Array$(value),
+    ReadonlySetFromSelf(typeSchema(asSchema(value))),
+    {
+      strict: true,
+      decode: (i) => new Set(i),
+      encode: (a) => Array.from(a)
+    }
   )
 }
 
@@ -8155,21 +8285,20 @@ export const ReadonlySet = <Value extends Schema.Any>(value: Value): ReadonlySet
  * @category api interface
  * @since 3.10.0
  */
-export interface Set$<Value extends Schema.Any> extends
-  AnnotableClass<
-    Set$<Value>,
-    Set<Schema.Type<Value>>,
-    ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface Set$<Value extends Schema.Any>
+  extends transform<Array$<Value>, SetFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
-const set = <Value extends Schema.Any>(value: Value): Set$<Value> => {
-  const value_ = asSchema(value)
+/** @ignore */
+function set<Value extends Schema.Any>(value: Value): Set$<Value> {
   return transform(
-    Array$(value_),
-    SetFromSelf(typeSchema(value_)),
-    { strict: true, decode: (as) => new Set(as), encode: (set) => Array.from(set) }
+    Array$(value),
+    SetFromSelf(typeSchema(asSchema(value))),
+    {
+      strict: true,
+      decode: (i) => new Set(i),
+      encode: (a) => Array.from(a)
+    }
   )
 }
 
@@ -8211,13 +8340,13 @@ export class BigDecimal extends transformOrFail(
   BigDecimalFromSelf,
   {
     strict: true,
-    decode: (s, _, ast) =>
-      bigDecimal_.fromString(s).pipe(option_.match({
+    decode: (i, _, ast) =>
+      bigDecimal_.fromString(i).pipe(option_.match({
         onNone: () =>
-          ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a BigDecimal`)),
+          ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a BigDecimal`)),
         onSome: (val) => ParseResult.succeed(bigDecimal_.normalize(val))
       })),
-    encode: (val) => ParseResult.succeed(bigDecimal_.format(bigDecimal_.normalize(val)))
+    encode: (a) => ParseResult.succeed(bigDecimal_.format(bigDecimal_.normalize(a)))
   }
 ).annotations({ identifier: "BigDecimal" }) {}
 
@@ -8233,8 +8362,8 @@ export class BigDecimalFromNumber extends transform(
   BigDecimalFromSelf,
   {
     strict: true,
-    decode: bigDecimal_.unsafeFromNumber,
-    encode: bigDecimal_.unsafeToNumber
+    decode: (i) => bigDecimal_.unsafeFromNumber(i),
+    encode: (a) => bigDecimal_.unsafeToNumber(a)
   }
 ).annotations({ identifier: "BigDecimalFromNumber" }) {}
 
@@ -8248,22 +8377,20 @@ export const GreaterThanBigDecimalSchemaId: unique symbol = Symbol.for("effect/S
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const greaterThanBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  min: bigDecimal_.BigDecimal,
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
-  const formatted = bigDecimal_.format(min)
-  return self.pipe(
-    filter((a) => bigDecimal_.greaterThan(a, min), {
-      schemaId: GreaterThanBigDecimalSchemaId,
-      [GreaterThanBigDecimalSchemaId]: { min },
-      title: `greaterThanBigDecimal(${formatted})`,
-      description: `a BigDecimal greater than ${formatted}`,
-      ...annotations
-    })
-  )
-}
+export const greaterThanBigDecimal =
+  <S extends Schema.Any>(min: bigDecimal_.BigDecimal, annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
+    const formatted = bigDecimal_.format(min)
+    return self.pipe(
+      filter((a) => bigDecimal_.greaterThan(a, min), {
+        schemaId: GreaterThanBigDecimalSchemaId,
+        [GreaterThanBigDecimalSchemaId]: { min },
+        title: `greaterThanBigDecimal(${formatted})`,
+        description: `a BigDecimal greater than ${formatted}`,
+        ...annotations
+      })
+    )
+  }
 
 /**
  * @category schema id
@@ -8277,22 +8404,20 @@ export const GreaterThanOrEqualToBigDecimalSchemaId: unique symbol = Symbol.for(
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const greaterThanOrEqualToBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  min: bigDecimal_.BigDecimal,
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
-  const formatted = bigDecimal_.format(min)
-  return self.pipe(
-    filter((a) => bigDecimal_.greaterThanOrEqualTo(a, min), {
-      schemaId: GreaterThanOrEqualToBigDecimalSchemaId,
-      [GreaterThanOrEqualToBigDecimalSchemaId]: { min },
-      title: `greaterThanOrEqualToBigDecimal(${formatted})`,
-      description: `a BigDecimal greater than or equal to ${formatted}`,
-      ...annotations
-    })
-  )
-}
+export const greaterThanOrEqualToBigDecimal =
+  <S extends Schema.Any>(min: bigDecimal_.BigDecimal, annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
+    const formatted = bigDecimal_.format(min)
+    return self.pipe(
+      filter((a) => bigDecimal_.greaterThanOrEqualTo(a, min), {
+        schemaId: GreaterThanOrEqualToBigDecimalSchemaId,
+        [GreaterThanOrEqualToBigDecimalSchemaId]: { min },
+        title: `greaterThanOrEqualToBigDecimal(${formatted})`,
+        description: `a BigDecimal greater than or equal to ${formatted}`,
+        ...annotations
+      })
+    )
+  }
 
 /**
  * @category schema id
@@ -8304,22 +8429,20 @@ export const LessThanBigDecimalSchemaId: unique symbol = Symbol.for("effect/Sche
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const lessThanBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  max: bigDecimal_.BigDecimal,
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
-  const formatted = bigDecimal_.format(max)
-  return self.pipe(
-    filter((a) => bigDecimal_.lessThan(a, max), {
-      schemaId: LessThanBigDecimalSchemaId,
-      [LessThanBigDecimalSchemaId]: { max },
-      title: `lessThanBigDecimal(${formatted})`,
-      description: `a BigDecimal less than ${formatted}`,
-      ...annotations
-    })
-  )
-}
+export const lessThanBigDecimal =
+  <S extends Schema.Any>(max: bigDecimal_.BigDecimal, annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
+    const formatted = bigDecimal_.format(max)
+    return self.pipe(
+      filter((a) => bigDecimal_.lessThan(a, max), {
+        schemaId: LessThanBigDecimalSchemaId,
+        [LessThanBigDecimalSchemaId]: { max },
+        title: `lessThanBigDecimal(${formatted})`,
+        description: `a BigDecimal less than ${formatted}`,
+        ...annotations
+      })
+    )
+  }
 
 /**
  * @category schema id
@@ -8333,22 +8456,20 @@ export const LessThanOrEqualToBigDecimalSchemaId: unique symbol = Symbol.for(
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const lessThanOrEqualToBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  max: bigDecimal_.BigDecimal,
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
-  const formatted = bigDecimal_.format(max)
-  return self.pipe(
-    filter((a) => bigDecimal_.lessThanOrEqualTo(a, max), {
-      schemaId: LessThanOrEqualToBigDecimalSchemaId,
-      [LessThanOrEqualToBigDecimalSchemaId]: { max },
-      title: `lessThanOrEqualToBigDecimal(${formatted})`,
-      description: `a BigDecimal less than or equal to ${formatted}`,
-      ...annotations
-    })
-  )
-}
+export const lessThanOrEqualToBigDecimal =
+  <S extends Schema.Any>(max: bigDecimal_.BigDecimal, annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
+    const formatted = bigDecimal_.format(max)
+    return self.pipe(
+      filter((a) => bigDecimal_.lessThanOrEqualTo(a, max), {
+        schemaId: LessThanOrEqualToBigDecimalSchemaId,
+        [LessThanOrEqualToBigDecimalSchemaId]: { max },
+        title: `lessThanOrEqualToBigDecimal(${formatted})`,
+        description: `a BigDecimal less than or equal to ${formatted}`,
+        ...annotations
+      })
+    )
+  }
 
 /**
  * @category schema id
@@ -8362,18 +8483,17 @@ export const PositiveBigDecimalSchemaId: unique symbol = Symbol.for(
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const positiveBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
-  self.pipe(
-    filter((a) => bigDecimal_.isPositive(a), {
-      schemaId: PositiveBigDecimalSchemaId,
-      title: "positiveBigDecimal",
-      description: `a positive BigDecimal`,
-      ...annotations
-    })
-  )
+export const positiveBigDecimal =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
+    self.pipe(
+      filter((a) => bigDecimal_.isPositive(a), {
+        schemaId: PositiveBigDecimalSchemaId,
+        title: "positiveBigDecimal",
+        description: `a positive BigDecimal`,
+        ...annotations
+      })
+    )
 
 /**
  * @category BigDecimal constructors
@@ -8395,18 +8515,17 @@ export const NonNegativeBigDecimalSchemaId: unique symbol = Symbol.for(
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const nonNegativeBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
-  self.pipe(
-    filter((a) => a.value >= 0n, {
-      schemaId: NonNegativeBigDecimalSchemaId,
-      title: "nonNegativeBigDecimal",
-      description: `a non-negative BigDecimal`,
-      ...annotations
-    })
-  )
+export const nonNegativeBigDecimal =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
+    self.pipe(
+      filter((a) => a.value >= 0n, {
+        schemaId: NonNegativeBigDecimalSchemaId,
+        title: "nonNegativeBigDecimal",
+        description: `a non-negative BigDecimal`,
+        ...annotations
+      })
+    )
 
 /**
  * @category BigDecimal constructors
@@ -8428,18 +8547,17 @@ export const NegativeBigDecimalSchemaId: unique symbol = Symbol.for(
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const negativeBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
-  self.pipe(
-    filter((a) => bigDecimal_.isNegative(a), {
-      schemaId: NegativeBigDecimalSchemaId,
-      title: "negativeBigDecimal",
-      description: `a negative BigDecimal`,
-      ...annotations
-    })
-  )
+export const negativeBigDecimal =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
+    self.pipe(
+      filter((a) => bigDecimal_.isNegative(a), {
+        schemaId: NegativeBigDecimalSchemaId,
+        title: "negativeBigDecimal",
+        description: `a negative BigDecimal`,
+        ...annotations
+      })
+    )
 
 /**
  * @category BigDecimal constructors
@@ -8461,18 +8579,17 @@ export const NonPositiveBigDecimalSchemaId: unique symbol = Symbol.for(
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const nonPositiveBigDecimal = <A extends bigDecimal_.BigDecimal>(
-  annotations?: Annotations.Filter<A>
-) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
-  self.pipe(
-    filter((a) => a.value <= 0n, {
-      schemaId: NonPositiveBigDecimalSchemaId,
-      title: "nonPositiveBigDecimal",
-      description: `a non-positive BigDecimal`,
-      ...annotations
-    })
-  )
+export const nonPositiveBigDecimal =
+  <S extends Schema.Any>(annotations?: Annotations.Filter<Schema.Type<S>>) =>
+  <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
+    self.pipe(
+      filter((a) => a.value <= 0n, {
+        schemaId: NonPositiveBigDecimalSchemaId,
+        title: "nonPositiveBigDecimal",
+        description: `a non-positive BigDecimal`,
+        ...annotations
+      })
+    )
 
 /**
  * @category BigDecimal constructors
@@ -8492,12 +8609,12 @@ export const BetweenBigDecimalSchemaId: unique symbol = Symbol.for("effect/Schem
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export const betweenBigDecimal = <A extends bigDecimal_.BigDecimal>(
+export const betweenBigDecimal = <S extends Schema.Any>(
   minimum: bigDecimal_.BigDecimal,
   maximum: bigDecimal_.BigDecimal,
-  annotations?: Annotations.Filter<A>
+  annotations?: Annotations.Filter<Schema.Type<S>>
 ) =>
-<I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
+<A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> => {
   const formattedMinimum = bigDecimal_.format(minimum)
   const formattedMaximum = bigDecimal_.format(maximum)
   return self.pipe(
@@ -8519,11 +8636,17 @@ export const betweenBigDecimal = <A extends bigDecimal_.BigDecimal>(
  */
 export const clampBigDecimal =
   (minimum: bigDecimal_.BigDecimal, maximum: bigDecimal_.BigDecimal) =>
-  <A extends bigDecimal_.BigDecimal, I, R>(self: Schema<A, I, R>): transform<Schema<A, I, R>, filter<Schema<A>>> =>
+  <S extends Schema.Any, A extends bigDecimal_.BigDecimal>(
+    self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>
+  ): transform<S, filter<SchemaClass<A>>> =>
     transform(
       self,
       self.pipe(typeSchema, betweenBigDecimal(minimum, maximum)),
-      { strict: false, decode: (self) => bigDecimal_.clamp(self, { minimum, maximum }), encode: identity }
+      {
+        strict: false,
+        decode: (i) => bigDecimal_.clamp(i, { minimum, maximum }),
+        encode: identity
+      }
     )
 
 const chunkArbitrary =
@@ -8550,11 +8673,11 @@ const chunkParse = <A, R>(
  * @since 3.10.0
  */
 export interface ChunkFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     ChunkFromSelf<Value>,
     chunk_.Chunk<Schema.Type<Value>>,
     chunk_.Chunk<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -8582,28 +8705,22 @@ export const ChunkFromSelf = <Value extends Schema.Any>(value: Value): ChunkFrom
  * @category api interface
  * @since 3.10.0
  */
-export interface Chunk<Value extends Schema.Any> extends
-  AnnotableClass<
-    Chunk<Value>,
-    chunk_.Chunk<Schema.Type<Value>>,
-    ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface Chunk<Value extends Schema.Any>
+  extends transform<Array$<Value>, ChunkFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category Chunk transformations
  * @since 3.10.0
  */
-export const Chunk = <Value extends Schema.Any>(value: Value): Chunk<Value> => {
-  const value_ = asSchema(value)
+export function Chunk<Value extends Schema.Any>(value: Value): Chunk<Value> {
   return transform(
-    Array$(value_),
-    ChunkFromSelf(typeSchema(value_)),
+    Array$(value),
+    ChunkFromSelf(typeSchema(asSchema(value))),
     {
       strict: true,
-      decode: (as) => as.length === 0 ? chunk_.empty() : chunk_.fromIterable(as),
-      encode: chunk_.toReadonlyArray
+      decode: (i) => i.length === 0 ? chunk_.empty() : chunk_.fromIterable(i),
+      encode: (a) => chunk_.toReadonlyArray(a)
     }
   )
 }
@@ -8613,11 +8730,11 @@ export const Chunk = <Value extends Schema.Any>(value: Value): Chunk<Value> => {
  * @since 3.10.0
  */
 export interface NonEmptyChunkFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     NonEmptyChunkFromSelf<Value>,
     chunk_.NonEmptyChunk<Schema.Type<Value>>,
     chunk_.NonEmptyChunk<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -8659,89 +8776,116 @@ export const NonEmptyChunkFromSelf = <Value extends Schema.Any>(value: Value): N
  * @category api interface
  * @since 3.10.0
  */
-export interface NonEmptyChunk<Value extends Schema.Any> extends
-  AnnotableClass<
-    NonEmptyChunk<Value>,
-    chunk_.NonEmptyChunk<Schema.Type<Value>>,
-    array_.NonEmptyReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface NonEmptyChunk<Value extends Schema.Any>
+  extends transform<NonEmptyArray<Value>, NonEmptyChunkFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category Chunk transformations
  * @since 3.10.0
  */
-export const NonEmptyChunk = <Value extends Schema.Any>(value: Value): NonEmptyChunk<Value> => {
-  const value_ = asSchema(value)
+export function NonEmptyChunk<Value extends Schema.Any>(value: Value): NonEmptyChunk<Value> {
   return transform(
-    NonEmptyArray(value_),
-    NonEmptyChunkFromSelf(typeSchema(value_)),
-    { strict: true, decode: chunk_.unsafeFromNonEmptyArray, encode: chunk_.toReadonlyArray }
+    NonEmptyArray(value),
+    NonEmptyChunkFromSelf(typeSchema(asSchema(value))),
+    {
+      strict: true,
+      decode: (i) => chunk_.unsafeFromNonEmptyArray(i),
+      encode: (a) => chunk_.toReadonlyArray(a)
+    }
   )
 }
 
-const toData = <A extends Readonly<Record<string, any>> | ReadonlyArray<any>>(a: A): A =>
+const decodeData = <A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>>(a: A): A =>
   Array.isArray(a) ? data_.array(a) : data_.struct(a)
 
-const dataArbitrary = <A extends Readonly<Record<string, any>> | ReadonlyArray<any>>(
+const dataArbitrary = <A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>>(
   item: LazyArbitrary<A>
 ): LazyArbitrary<A> =>
-(fc) => item(fc).map(toData)
+(fc) => item(fc).map(decodeData)
 
-const dataPretty = <A extends Readonly<Record<string, any>> | ReadonlyArray<any>>(
+const dataPretty = <A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>>(
   item: pretty_.Pretty<A>
 ): pretty_.Pretty<A> =>
 (d) => `Data(${item(d)})`
 
-const dataParse = <R, A extends Readonly<Record<string, any>> | ReadonlyArray<any>>(
+const dataParse = <R, A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>>(
   decodeUnknown: ParseResult.DecodeUnknown<A, R>
 ): ParseResult.DeclarationDecodeUnknown<A, R> =>
 (u, options, ast) =>
   Equal.isEqual(u) ?
-    toComposite(decodeUnknown(u, options), toData, ast, u)
+    toComposite(decodeUnknown(u, options), decodeData, ast, u)
     : ParseResult.fail(new ParseResult.Type(ast, u))
 
 /**
+ * @category api interface
+ * @since 3.13.3
+ */
+export interface DataFromSelf<Value extends Schema.Any> extends
+  AnnotableDeclare<
+    DataFromSelf<Value>,
+    Schema.Type<Value>,
+    Schema.Encoded<Value>,
+    [Value]
+  >
+{}
+
+/**
+ * Type and Encoded must extend `Readonly<Record<string, any>> |
+ * ReadonlyArray<any>` to be compatible with this API.
+ *
  * @category Data transformations
  * @since 3.10.0
  */
 export const DataFromSelf = <
-  R,
-  I extends Readonly<Record<string, any>> | ReadonlyArray<any>,
-  A extends Readonly<Record<string, any>> | ReadonlyArray<any>
->(
-  item: Schema<A, I, R>
-): SchemaClass<A, I, R> =>
-  declare(
-    [item],
+  S extends Schema.Any,
+  A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>,
+  I extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>
+>(value: S & Schema<A & Schema.Type<S>, I & Schema.Encoded<S>, Schema.Context<S>>): DataFromSelf<S> => {
+  return declare(
+    [value],
     {
       decode: (item) => dataParse(ParseResult.decodeUnknown(item)),
       encode: (item) => dataParse(ParseResult.encodeUnknown(item))
     },
     {
-      description: `Data<${format(item)}>`,
+      description: `Data<${format(value)}>`,
       pretty: dataPretty,
       arbitrary: dataArbitrary
     }
   )
+}
 
 /**
+ * @category api interface
+ * @since 3.13.3
+ */
+export interface Data<Value extends Schema.Any>
+  extends transform<Value, DataFromSelf<SchemaClass<Schema.Type<Value>>>>
+{}
+
+/**
+ * Type and Encoded must extend `Readonly<Record<string, any>> |
+ * ReadonlyArray<any>` to be compatible with this API.
+ *
  * @category Data transformations
  * @since 3.10.0
  */
 export const Data = <
-  R,
-  I extends Readonly<Record<string, any>> | ReadonlyArray<any>,
-  A extends Readonly<Record<string, any>> | ReadonlyArray<any>
->(
-  item: Schema<A, I, R>
-): SchemaClass<A, I, R> =>
-  transform(
-    item,
-    DataFromSelf(typeSchema(item)),
-    { strict: false, decode: toData, encode: (a) => Array.isArray(a) ? Array.from(a) : Object.assign({}, a) }
+  S extends Schema.Any,
+  A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>,
+  I extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>
+>(value: S & Schema<A & Schema.Type<S>, I & Schema.Encoded<S>, Schema.Context<S>>): Data<S> => {
+  return transform(
+    value,
+    DataFromSelf(typeSchema(value)),
+    {
+      strict: false,
+      decode: (i) => decodeData(i),
+      encode: (a) => Array.isArray(a) ? Array.from(a) : Object.assign({}, a)
+    }
   )
+}
 
 type MissingSelfGeneric<Usage extends string, Params extends string = ""> =
   `Missing \`Self\` generic - use \`class Self extends ${Usage}<Self>()(${Params}{ ... })\``
@@ -8805,7 +8949,7 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
    */
   extend<Extended = never>(identifier: string): <NewFields extends Struct.Fields>(
     fields: NewFields | HasFields<NewFields>,
-    annotations?: ClassAnnotations<Extended, Struct.Type<Fields & NewFields>>
+    annotations?: ClassAnnotations<Extended, Simplify<Struct.Type<Fields & NewFields>>>
   ) => [Extended] extends [never] ? MissingSelfGeneric<"Base.extend">
     : Class<
       Extended,
@@ -8864,7 +9008,7 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
         ast: AST.Transformation
       ) => Effect.Effect<Struct.Type<Fields>, ParseResult.ParseIssue, R3>
     },
-    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
+    annotations?: ClassAnnotations<Transformed, Simplify<Struct.Type<Fields & NewFields>>>
   ) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFail">
     : Class<
       Transformed,
@@ -8923,7 +9067,7 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
         ast: AST.Transformation
       ) => Effect.Effect<I, ParseResult.ParseIssue, R3>
     },
-    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
+    annotations?: ClassAnnotations<Transformed, Simplify<Struct.Type<Fields & NewFields>>>
   ) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFailFrom">
     : Class<
       Transformed,
@@ -8974,7 +9118,7 @@ const getFieldsFromFieldsOr = <Fields extends Struct.Fields>(fieldsOr: Fields |
 export const Class = <Self = never>(identifier: string) =>
 <Fields extends Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self, Simplify<Struct.Type<Fields>>>
 ): [Self] extends [never] ? MissingSelfGeneric<"Class">
   : Class<
     Self,
@@ -9033,7 +9177,7 @@ export const TaggedClass = <Self = never>(identifier?: string) =>
 <Tag extends string, Fields extends Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<{ readonly _tag: tag<Tag> } & Fields>>
+  annotations?: ClassAnnotations<Self, Simplify<Struct.Type<{ readonly _tag: tag<Tag> } & Fields>>>
 ): [Self] extends [never] ? MissingSelfGeneric<"TaggedClass", `"Tag", `>
   : TaggedClass<Self, Tag, { readonly _tag: tag<Tag> } & Fields> =>
 {
@@ -9096,7 +9240,7 @@ export const TaggedError = <Self = never>(identifier?: string) =>
 <Tag extends string, Fields extends Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<{ readonly _tag: tag<Tag> } & Fields>>
+  annotations?: ClassAnnotations<Self, Simplify<Struct.Type<{ readonly _tag: tag<Tag> } & Fields>>>
 ): [Self] extends [never] ? MissingSelfGeneric<"TaggedError", `"Tag", `>
   : TaggedErrorClass<
     Self,
@@ -9140,7 +9284,8 @@ const extendFields = (a: Struct.Fields, b: Struct.Fields): Struct.Fields => {
   return out
 }
 
-type MakeOptions = boolean | {
+/** @internal */
+export type MakeOptions = boolean | {
   readonly disableValidation?: boolean
 }
 
@@ -9265,7 +9410,11 @@ const makeClass = <Fields extends Struct.Fields>(
       out = transform(
         encodedSide,
         declaration,
-        { strict: true, decode: (input) => new this(input, true), encode: identity }
+        {
+          strict: true,
+          decode: (i) => new this(i, true),
+          encode: identity
+        }
       ).annotations({
         [AST.SurrogateAnnotationId]: transformationSurrogate.ast,
         ...transformationAnnotations
@@ -9303,7 +9452,7 @@ const makeClass = <Fields extends Struct.Fields>(
     static extend<Extended, NewFields extends Struct.Fields>(identifier: string) {
       return (
         newFieldsOr: NewFields | HasFields<NewFields>,
-        annotations?: ClassAnnotations<Extended, Struct.Type<Fields & NewFields>>
+        annotations?: ClassAnnotations<Extended, Simplify<Struct.Type<Fields & NewFields>>>
       ) => {
         const newFields = getFieldsFromFieldsOr(newFieldsOr)
         const newSchema = getSchemaFromFieldsOr(newFieldsOr)
@@ -9323,7 +9472,7 @@ const makeClass = <Fields extends Struct.Fields>(
       return (
         newFieldsOr: NewFields,
         options: any,
-        annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
+        annotations?: ClassAnnotations<Transformed, Simplify<Struct.Type<Fields & NewFields>>>
       ) => {
         const transformedFields: Struct.Fields = extendFields(fields, newFieldsOr)
         return makeClass({
@@ -9345,7 +9494,7 @@ const makeClass = <Fields extends Struct.Fields>(
       return (
         newFields: NewFields,
         options: any,
-        annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
+        annotations?: ClassAnnotations<Transformed, Simplify<Struct.Type<Fields & NewFields>>>
       ) => {
         const transformedFields: Struct.Fields = extendFields(fields, newFields)
         return makeClass({
@@ -9491,7 +9640,11 @@ const fiberIdEncode = (input: fiberId_.FiberId): FiberIdEncoded => {
 export class FiberId extends transform(
   FiberIdEncoded,
   FiberIdFromSelf,
-  { strict: true, decode: fiberIdDecode, encode: fiberIdEncode }
+  {
+    strict: true,
+    decode: (i) => fiberIdDecode(i),
+    encode: (a) => fiberIdEncode(a)
+  }
 ).annotations({ identifier: "FiberId" }) {}
 
 /**
@@ -9525,7 +9678,7 @@ export type CauseEncoded<E, D> =
     readonly right: CauseEncoded<E, D>
   }
 
-const causeDieEncoded = <D, DI, R>(defect: Schema<D, DI, R>) =>
+const causeDieEncoded = <Defect extends Schema.Any>(defect: Defect) =>
   Struct({
     _tag: Literal("Die"),
     defect
@@ -9535,7 +9688,7 @@ const CauseEmptyEncoded = Struct({
   _tag: Literal("Empty")
 })
 
-const causeFailEncoded = <E, EI, R>(error: Schema<E, EI, R>) =>
+const causeFailEncoded = <E extends Schema.Any>(error: E) =>
   Struct({
     _tag: Literal("Fail"),
     error
@@ -9546,32 +9699,36 @@ const CauseInterruptEncoded = Struct({
   fiberId: FiberIdEncoded
 })
 
-const causeParallelEncoded = <E, EI, D, DI, R>(causeEncoded: Schema<CauseEncoded<E, D>, CauseEncoded<EI, DI>, R>) =>
-  Struct({
-    _tag: Literal("Parallel"),
-    left: causeEncoded,
-    right: causeEncoded
-  })
-
-const causeSequentialEncoded = <E, EI, D, DI, R>(causeEncoded: Schema<CauseEncoded<E, D>, CauseEncoded<EI, DI>, R>) =>
-  Struct({
-    _tag: Literal("Sequential"),
-    left: causeEncoded,
-    right: causeEncoded
-  })
-
-const causeEncoded = <E, EI, D, DI, R1, R2>(
-  error: Schema<E, EI, R1>,
-  defect: Schema<D, DI, R2>
-): Schema<CauseEncoded<E, D>, CauseEncoded<EI, DI>, R1 | R2> => {
-  const recur = suspend(() => out)
-  const out: Schema<CauseEncoded<E, D>, CauseEncoded<EI, DI>, R1 | R2> = Union(
+const causeEncoded = <E extends Schema.All, D extends Schema.All>(
+  error: E,
+  defect: D
+): SchemaClass<
+  CauseEncoded<Schema.Type<E>, Schema.Type<D>>,
+  CauseEncoded<Schema.Encoded<E>, Schema.Encoded<D>>,
+  Schema.Context<E> | Schema.Context<D>
+> => {
+  const error_ = asSchema(error)
+  const defect_ = asSchema(defect)
+  const suspended = suspend((): Schema<
+    CauseEncoded<Schema.Type<E>, Schema.Type<D>>,
+    CauseEncoded<Schema.Encoded<E>, Schema.Encoded<D>>,
+    Schema.Context<E> | Schema.Context<D>
+  > => out)
+  const out = Union(
     CauseEmptyEncoded,
-    causeFailEncoded(error),
-    causeDieEncoded(defect),
+    causeFailEncoded(error_),
+    causeDieEncoded(defect_),
     CauseInterruptEncoded,
-    causeSequentialEncoded(recur),
-    causeParallelEncoded(recur)
+    Struct({
+      _tag: Literal("Sequential"),
+      left: suspended,
+      right: suspended
+    }),
+    Struct({
+      _tag: Literal("Parallel"),
+      left: suspended,
+      right: suspended
+    })
   ).annotations({ title: `CauseEncoded<${format(error)}>` })
   return out
 }
@@ -9631,11 +9788,11 @@ const causeParse = <A, D, R>(
  * @since 3.10.0
  */
 export interface CauseFromSelf<E extends Schema.All, D extends Schema.All> extends
-  AnnotableClass<
+  AnnotableDeclare<
     CauseFromSelf<E, D>,
     cause_.Cause<Schema.Type<E>>,
     cause_.Cause<Schema.Encoded<E>>,
-    Schema.Context<E> | Schema.Context<D>
+    [E, D]
   >
 {}
 
@@ -9708,11 +9865,13 @@ function causeEncode<E>(cause: cause_.Cause<E>): CauseEncoded<E, unknown> {
  * @since 3.10.0
  */
 export interface Cause<E extends Schema.All, D extends Schema.All> extends
-  AnnotableClass<
-    Cause<E, D>,
-    cause_.Cause<Schema.Type<E>>,
-    CauseEncoded<Schema.Encoded<E>, Schema.Encoded<D>>,
-    Schema.Context<E> | Schema.Context<D>
+  transform<
+    SchemaClass<
+      CauseEncoded<Schema.Type<E>, Schema.Type<Defect>>,
+      CauseEncoded<Schema.Encoded<E>, Schema.Encoded<Defect>>,
+      Schema.Context<E> | Schema.Context<D>
+    >,
+    CauseFromSelf<SchemaClass<Schema.Type<E>>, SchemaClass<Schema.Type<D>>>
   >
 {}
 
@@ -9726,19 +9885,18 @@ export const Cause = <E extends Schema.All, D extends Schema.All>({ defect, erro
 }): Cause<E, D> => {
   const error_ = asSchema(error)
   const defect_ = asSchema(defect)
-  return transform(
+  const out = transform(
     causeEncoded(error_, defect_),
-    CauseFromSelf({ error: typeSchema(error_), defect: Unknown }),
-    { strict: false, decode: causeDecode, encode: causeEncode }
+    CauseFromSelf({ error: typeSchema(error_), defect: typeSchema(defect_) }),
+    {
+      strict: false,
+      decode: (i) => causeDecode(i),
+      encode: (a) => causeEncode(a)
+    }
   )
+  return out as any
 }
 
-/**
- * @category api interface
- * @since 3.10.0
- */
-export interface Defect extends transform<typeof Unknown, typeof Unknown> {}
-
 /**
  * Defines a schema for handling JavaScript errors (`Error` instances) and other types of defects.
  * It decodes objects into Error instances if they match the expected structure (i.e., have a `message` and optionally a `name` and `stack`),
@@ -9752,34 +9910,34 @@ export interface Defect extends transform<typeof Unknown, typeof Unknown> {}
  * @category defect
  * @since 3.10.0
  */
-export const Defect: Defect = transform(
+export class Defect extends transform(
   Unknown,
   Unknown,
   {
     strict: true,
-    decode: (u) => {
-      if (Predicate.isObject(u) && "message" in u && typeof u.message === "string") {
-        const err = new Error(u.message, { cause: u })
-        if ("name" in u && typeof u.name === "string") {
-          err.name = u.name
+    decode: (i) => {
+      if (Predicate.isObject(i) && "message" in i && typeof i.message === "string") {
+        const err = new Error(i.message, { cause: i })
+        if ("name" in i && typeof i.name === "string") {
+          err.name = i.name
         }
-        err.stack = "stack" in u && typeof u.stack === "string" ? u.stack : ""
+        err.stack = "stack" in i && typeof i.stack === "string" ? i.stack : ""
         return err
       }
-      return String(u)
+      return String(i)
     },
-    encode: (defect) => {
-      if (defect instanceof Error) {
+    encode: (a) => {
+      if (a instanceof Error) {
         return {
-          name: defect.name,
-          message: defect.message
+          name: a.name,
+          message: a.message
           // no stack because of security reasons
         }
       }
-      return internalCause_.prettyErrorMessage(defect)
+      return internalCause_.prettyErrorMessage(a)
     }
   }
-).annotations({ identifier: "Defect" })
+).annotations({ identifier: "Defect" }) {}
 
 /**
  * @category Exit utils
@@ -9795,34 +9953,35 @@ export type ExitEncoded<A, E, D> =
     readonly value: A
   }
 
-const exitFailureEncoded = <E, EI, ER, D, DI, DR>(
-  error: Schema<E, EI, ER>,
-  defect: Schema<D, DI, DR>
+const exitFailureEncoded = <E extends Schema.All, D extends Schema.All>(
+  error: E,
+  defect: D
 ) =>
   Struct({
     _tag: Literal("Failure"),
     cause: causeEncoded(error, defect)
   })
 
-const exitSuccessEncoded = <A, I, R>(
-  value: Schema<A, I, R>
+const exitSuccessEncoded = <A extends Schema.All>(
+  value: A
 ) =>
   Struct({
     _tag: Literal("Success"),
     value
   })
 
-const exitEncoded = <A, I, R, E, EI, ER, D, DI, DR>(
-  value: Schema<A, I, R>,
-  error: Schema<E, EI, ER>,
-  defect: Schema<D, DI, DR>
-): Schema<ExitEncoded<A, E, D>, ExitEncoded<I, EI, DI>, R | ER | DR> =>
-  Union(
+const exitEncoded = <A extends Schema.All, E extends Schema.All, D extends Schema.Any>(
+  value: A,
+  error: E,
+  defect: D
+) => {
+  return Union(
     exitFailureEncoded(error, defect),
     exitSuccessEncoded(value)
   ).annotations({
     title: `ExitEncoded<${format(value)}, ${format(error)}, ${format(defect)}>`
   })
+}
 
 const exitDecode = <A, E>(input: ExitEncoded<A, E, unknown>): exit_.Exit<A, E> => {
   switch (input._tag) {
@@ -9866,13 +10025,14 @@ const exitParse = <A, R, E, ER>(
  * @category api interface
  * @since 3.10.0
  */
-export interface ExitFromSelf<A extends Schema.All, E extends Schema.All, D extends Schema.All> extends
-  AnnotableClass<
-    ExitFromSelf<A, E, D>,
-    exit_.Exit<Schema.Type<A>, Schema.Type<E>>,
-    exit_.Exit<Schema.Encoded<A>, Schema.Encoded<E>>,
-    Schema.Context<A> | Schema.Context<E> | Schema.Context<D>
-  >
+export interface ExitFromSelf<A extends Schema.All, E extends Schema.All, D extends Schema.All>
+  extends
+    AnnotableDeclare<
+      ExitFromSelf<A, E, D>,
+      exit_.Exit<Schema.Type<A>, Schema.Type<E>>,
+      exit_.Exit<Schema.Encoded<A>, Schema.Encoded<E>>,
+      [A, E, D]
+    >
 {}
 
 /**
@@ -9912,11 +10072,22 @@ export const ExitFromSelf = <A extends Schema.All, E extends Schema.All, D exten
  * @since 3.10.0
  */
 export interface Exit<A extends Schema.All, E extends Schema.All, D extends Schema.All> extends
-  AnnotableClass<
-    Exit<A, E, D>,
-    exit_.Exit<Schema.Type<A>, Schema.Type<E>>,
-    ExitEncoded<Schema.Encoded<A>, Schema.Encoded<E>, Schema.Encoded<D>>,
-    Schema.Context<A> | Schema.Context<E> | Schema.Context<D>
+  transform<
+    Union<[
+      Struct<{
+        _tag: Literal<["Failure"]>
+        cause: SchemaClass<
+          CauseEncoded<Schema.Type<E>, Schema.Type<D>>,
+          CauseEncoded<Schema.Encoded<E>, Schema.Encoded<D>>,
+          Schema.Context<E> | Schema.Context<D>
+        >
+      }>,
+      Struct<{
+        _tag: Literal<["Success"]>
+        value: A
+      }>
+    ]>,
+    ExitFromSelf<SchemaClass<Schema.Type<A>>, SchemaClass<Schema.Type<E>>, SchemaClass<Schema.Type<D>>>
   >
 {}
 
@@ -9934,18 +10105,19 @@ export const Exit = <A extends Schema.All, E extends Schema.All, D extends Schem
   const success_ = asSchema(success)
   const failure_ = asSchema(failure)
   const defect_ = asSchema(defect)
-  return transform(
+  const out = transform(
     exitEncoded(success_, failure_, defect_),
-    ExitFromSelf({ failure: typeSchema(failure_), success: typeSchema(success_), defect: Unknown }),
+    ExitFromSelf({ failure: typeSchema(failure_), success: typeSchema(success_), defect: typeSchema(defect_) }),
     {
       strict: false,
-      decode: exitDecode,
-      encode: (exit) =>
-        exit._tag === "Failure"
-          ? { _tag: "Failure", cause: exit.cause } as const
-          : { _tag: "Success", value: exit.value } as const
+      decode: (i) => exitDecode(i),
+      encode: (a) =>
+        a._tag === "Failure"
+          ? { _tag: "Failure", cause: a.cause } as const
+          : { _tag: "Success", value: a.value } as const
     }
   )
+  return out as any
 }
 
 const hashSetArbitrary =
@@ -9979,11 +10151,11 @@ const hashSetParse = <A, R>(
  * @since 3.10.0
  */
 export interface HashSetFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     HashSetFromSelf<Value>,
     hashSet_.HashSet<Schema.Type<Value>>,
     hashSet_.HashSet<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -10013,25 +10185,23 @@ export const HashSetFromSelf = <Value extends Schema.Any>(
  * @category api interface
  * @since 3.10.0
  */
-export interface HashSet<Value extends Schema.Any> extends
-  AnnotableClass<
-    HashSet<Value>,
-    hashSet_.HashSet<Schema.Type<Value>>,
-    ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface HashSet<Value extends Schema.Any>
+  extends transform<Array$<Value>, HashSetFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category HashSet transformations
  * @since 3.10.0
  */
-export const HashSet = <Value extends Schema.Any>(value: Value): HashSet<Value> => {
-  const value_ = asSchema(value)
+export function HashSet<Value extends Schema.Any>(value: Value): HashSet<Value> {
   return transform(
-    Array$(value_),
-    HashSetFromSelf(typeSchema(value_)),
-    { strict: true, decode: (as) => hashSet_.fromIterable(as), encode: (set) => Array.from(set) }
+    Array$(value),
+    HashSetFromSelf(typeSchema(asSchema(value))),
+    {
+      strict: true,
+      decode: (i) => hashSet_.fromIterable(i),
+      encode: (a) => Array.from(a)
+    }
   )
 }
 
@@ -10079,11 +10249,11 @@ const hashMapParse = <R, K, V>(
  * @since 3.10.0
  */
 export interface HashMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     HashMapFromSelf<K, V>,
     hashMap_.HashMap<Schema.Type<K>, Schema.Type<V>>,
     hashMap_.HashMap<Schema.Encoded<K>, Schema.Encoded<V>>,
-    Schema.Context<K> | Schema.Context<V>
+    [K, V]
   >
 {}
 
@@ -10114,13 +10284,8 @@ export const HashMapFromSelf = <K extends Schema.Any, V extends Schema.Any>({ ke
  * @category api interface
  * @since 3.10.0
  */
-export interface HashMap<K extends Schema.Any, V extends Schema.Any> extends
-  AnnotableClass<
-    HashMap<K, V>,
-    hashMap_.HashMap<Schema.Type<K>, Schema.Type<V>>,
-    ReadonlyArray<readonly [Schema.Encoded<K>, Schema.Encoded<V>]>,
-    Schema.Context<K> | Schema.Context<V>
-  >
+export interface HashMap<K extends Schema.Any, V extends Schema.Any>
+  extends transform<Array$<Tuple2<K, V>>, HashMapFromSelf<SchemaClass<Schema.Type<K>>, SchemaClass<Schema.Type<V>>>>
 {}
 
 /**
@@ -10131,12 +10296,14 @@ export const HashMap = <K extends Schema.Any, V extends Schema.Any>({ key, value
   readonly key: K
   readonly value: V
 }): HashMap<K, V> => {
-  const key_ = asSchema(key)
-  const value_ = asSchema(value)
   return transform(
-    Array$(Tuple(key_, value_)),
-    HashMapFromSelf({ key: typeSchema(key_), value: typeSchema(value_) }),
-    { strict: true, decode: (as) => hashMap_.fromIterable(as), encode: (map) => Array.from(map) }
+    Array$(Tuple(key, value)),
+    HashMapFromSelf({ key: typeSchema(asSchema(key)), value: typeSchema(asSchema(value)) }),
+    {
+      strict: true,
+      decode: (i) => hashMap_.fromIterable(i),
+      encode: (a) => Array.from(a)
+    }
   )
 }
 
@@ -10169,11 +10336,11 @@ const listParse = <A, R>(
  * @since 3.10.0
  */
 export interface ListFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     ListFromSelf<Value>,
     list_.List<Schema.Type<Value>>,
     list_.List<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -10203,25 +10370,23 @@ export const ListFromSelf = <Value extends Schema.Any>(
  * @category api interface
  * @since 3.10.0
  */
-export interface List<Value extends Schema.Any> extends
-  AnnotableClass<
-    List<Value>,
-    list_.List<Schema.Type<Value>>,
-    ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface List<Value extends Schema.Any>
+  extends transform<Array$<Value>, ListFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category List transformations
  * @since 3.10.0
  */
-export const List = <Value extends Schema.Any>(value: Value): List<Value> => {
-  const value_ = asSchema(value)
+export function List<Value extends Schema.Any>(value: Value): List<Value> {
   return transform(
-    Array$(value_),
-    ListFromSelf(typeSchema(value_)),
-    { strict: true, decode: (as) => list_.fromIterable(as), encode: (set) => Array.from(set) }
+    Array$(value),
+    ListFromSelf(typeSchema(asSchema(value))),
+    {
+      strict: true,
+      decode: (i) => list_.fromIterable(i),
+      encode: (a) => Array.from(a)
+    }
   )
 }
 
@@ -10259,11 +10424,11 @@ const sortedSetParse = <A, R>(
  * @since 3.10.0
  */
 export interface SortedSetFromSelf<Value extends Schema.Any> extends
-  AnnotableClass<
+  AnnotableDeclare<
     SortedSetFromSelf<Value>,
     sortedSet_.SortedSet<Schema.Type<Value>>,
     sortedSet_.SortedSet<Schema.Encoded<Value>>,
-    Schema.Context<Value>
+    [Value]
   >
 {}
 
@@ -10295,32 +10460,26 @@ export const SortedSetFromSelf = <Value extends Schema.Any>(
  * @category api interface
  * @since 3.10.0
  */
-export interface SortedSet<Value extends Schema.Any> extends
-  AnnotableClass<
-    SortedSet<Value>,
-    sortedSet_.SortedSet<Schema.Type<Value>>,
-    ReadonlyArray<Schema.Encoded<Value>>,
-    Schema.Context<Value>
-  >
+export interface SortedSet<Value extends Schema.Any>
+  extends transform<Array$<Value>, SortedSetFromSelf<SchemaClass<Schema.Type<Value>>>>
 {}
 
 /**
  * @category SortedSet transformations
  * @since 3.10.0
  */
-export const SortedSet = <Value extends Schema.Any>(
+export function SortedSet<Value extends Schema.Any>(
   value: Value,
   ordA: Order.Order<Schema.Type<Value>>
-): SortedSet<Value> => {
-  const value_ = asSchema(value)
-  const to = typeSchema(value_)
+): SortedSet<Value> {
+  const to = typeSchema(asSchema(value))
   return transform(
-    Array$(value_),
+    Array$(value),
     SortedSetFromSelf<typeof to>(to, ordA, ordA),
     {
       strict: true,
-      decode: (as) => sortedSet_.fromIterable(as, ordA),
-      encode: (set) => Array.from(sortedSet_.values(set))
+      decode: (i) => sortedSet_.fromIterable(i, ordA),
+      encode: (a) => Array.from(sortedSet_.values(a))
     }
   )
 }
@@ -10336,7 +10495,11 @@ export const SortedSet = <Value extends Schema.Any>(
 export class BooleanFromUnknown extends transform(
   Unknown,
   Boolean$,
-  { strict: true, decode: Predicate.isTruthy, encode: identity }
+  {
+    strict: true,
+    decode: (i) => Predicate.isTruthy(i),
+    encode: identity
+  }
 ).annotations({ identifier: "BooleanFromUnknown" }) {}
 
 /**
@@ -10349,7 +10512,11 @@ export class BooleanFromUnknown extends transform(
 export class BooleanFromString extends transform(
   Literal("true", "false").annotations({ description: "a string to be decoded into a boolean" }),
   Boolean$,
-  { strict: true, decode: (value) => value === "true", encode: (value) => value ? "true" : "false" }
+  {
+    strict: true,
+    decode: (i) => i === "true",
+    encode: (a) => a ? "true" : "false"
+  }
 ).annotations({ identifier: "BooleanFromString" }) {}
 
 /**
@@ -10617,9 +10784,7 @@ export const deserializeFailure: {
    * @since 3.10.0
    * @category decoding
    */
-  (
-    value: unknown
-  ): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FA, ParseResult.ParseError, R>
+  (value: unknown): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FA, ParseResult.ParseError, R>
   /**
    * @since 3.10.0
    * @category decoding
@@ -10697,10 +10862,7 @@ export const serializeExit: {
    * @since 3.10.0
    * @category encoding
    */
-  <SA, SI, FA, FI, R>(
-    self: WithResult<SA, SI, FA, FI, R>,
-    value: exit_.Exit<SA, FA>
-  ): Effect.Effect<ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
+  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: exit_.Exit<SA, FA>): Effect.Effect<ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
 } = dual(2, <SA, SI, FA, FI, R>(
   self: WithResult<SA, SI, FA, FI, R>,
   value: exit_.Exit<SA, FA>
@@ -10722,10 +10884,7 @@ export const deserializeExit: {
    * @since 3.10.0
    * @category decoding
    */
-  <SA, SI, FA, FI, R>(
-    self: WithResult<SA, SI, FA, FI, R>,
-    value: unknown
-  ): Effect.Effect<exit_.Exit<SA, FA>, ParseResult.ParseError, R>
+  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: unknown): Effect.Effect<exit_.Exit<SA, FA>, ParseResult.ParseError, R>
 } = dual(2, <SA, SI, FA, FI, R>(
   self: WithResult<SA, SI, FA, FI, R>,
   value: unknown
@@ -10902,7 +11061,7 @@ export const TaggedRequest =
       success: Success
       payload: Payload
     },
-    annotations?: ClassAnnotations<Self, Struct.Type<{ readonly _tag: tag<Tag> } & Payload>>
+    annotations?: ClassAnnotations<Self, Simplify<Struct.Type<{ readonly _tag: tag<Tag> } & Payload>>>
   ): [Self] extends [never] ? MissingSelfGeneric<"TaggedRequest", `"Tag", SuccessSchema, FailureSchema, `>
     : TaggedRequestClass<
       Self,
@@ -11124,6 +11283,20 @@ const go = (ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equival
   }
 }
 
+const SymbolStruct = TaggedStruct("symbol", {
+  key: String$
+}).annotations({ description: "an object to be decoded into a globally shared symbol" })
+
+const SymbolFromStruct = transformOrFail(
+  SymbolStruct,
+  SymbolFromSelf,
+  {
+    strict: true,
+    decode: (i) => decodeSymbol(i.key),
+    encode: (a, _, ast) => ParseResult.map(encodeSymbol(a, ast), (key) => SymbolStruct.make({ key }))
+  }
+)
+
 /** @ignore */
 class PropertyKey$ extends Union(String$, Number$, SymbolFromStruct).annotations({ identifier: "PropertyKey" }) {}