effect 3.13.2 → 3.13.4

package/dist/dts/Schema.d.ts

@@ -68,6 +68,20 @@ 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
@@ -78,7 +92,7 @@ export interface SchemaClass<A, I = A, R = never> extends AnnotableClass<SchemaC
  * @category constructors
  * @since 3.10.0
  */
-export declare const make: <A, I = A, R = never>(ast: AST.AST) => SchemaClass<A, I, R>;
+export declare function make<A, I = A, R = never>(ast: AST.AST): SchemaClass<A, I, R>;
 /**
  * Returns a "Standard Schema" object conforming to the [Standard Schema
  * v1](https://standardschema.dev/) specification.
@@ -126,24 +140,10 @@ export declare namespace Annotable {
      */
     type All = Any | Annotable<any, any, never, unknown> | Annotable<any, never, any, unknown> | 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 declare const asSchema: <S extends Schema.All>(schema: S) => Schema<Schema.Type<S>, Schema.Encoded<S>, Schema.Context<S>>;
+export declare function asSchema<S extends Schema.All>(schema: S): Schema<Schema.Type<S>, Schema.Encoded<S>, Schema.Context<S>>;
 /**
  * @category formatting
  * @since 3.10.0
@@ -395,7 +395,7 @@ export interface Literal<Literals extends array_.NonEmptyReadonlyArray<AST.Liter
  */
 export declare function Literal<Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>(...literals: Literals): Literal<Literals>;
 export declare function Literal(): Never;
-export declare function Literal<Literals extends ReadonlyArray<AST.LiteralValue>>(...literals: Literals): Schema<Literals[number]>;
+export declare function Literal<Literals extends ReadonlyArray<AST.LiteralValue>>(...literals: Literals): SchemaClass<Literals[number]>;
 /**
  * Creates a new `Schema` from a literal schema.
  *
@@ -471,6 +471,20 @@ export interface TemplateLiteralParser<Params extends array_.NonEmptyReadonlyArr
  * @since 3.10.0
  */
 export declare const TemplateLiteralParser: <Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParserParameters>>(...params: Params) => TemplateLiteralParser<Params>;
+/**
+ * @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;
+}
 /**
  * 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.
@@ -486,7 +500,7 @@ export declare 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.
@@ -494,7 +508,7 @@ export declare const declare: {
      * @category constructors
      * @since 3.10.0
      */
-    <const P extends ReadonlyArray<Schema.All>, I, A>(typeParameters: P, options: {
+    <A, I, const P extends ReadonlyArray<Schema.All>>(typeParameters: P, options: {
         readonly decode: (...typeParameters: {
             readonly [K in keyof P]: Schema<Schema.Type<P[K]>, Schema.Encoded<P[K]>, never>;
         }) => (input: unknown, options: ParseOptions, ast: AST.Declaration) => Effect.Effect<A, ParseResult.ParseIssue, never>;
@@ -503,7 +517,7 @@ export declare const declare: {
         }) => (input: unknown, options: ParseOptions, ast: AST.Declaration) => 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>;
 };
 /**
  * @category schema id
@@ -524,7 +538,7 @@ export declare const InstanceOfSchemaId: unique symbol;
  * @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
@@ -630,7 +644,6 @@ String$ as String };
  */
 export interface Union<Members extends ReadonlyArray<Schema.All>> extends AnnotableClass<Union<Members>, Schema.Type<Members[number]>, Schema.Encoded<Members[number]>, Schema.Context<Members[number]>> {
     readonly members: Readonly<Members>;
-    annotations(annotations: Annotations.Schema<Schema.Type<Members[number]>>): Union<Members>;
 }
 /**
  * @category combinators
@@ -770,11 +783,20 @@ export interface TupleType<Elements extends TupleType.Elements, Rest extends Tup
 export interface Tuple<Elements extends TupleType.Elements> extends TupleType<Elements, []> {
     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
  */
 export declare function Tuple<const Elements extends TupleType.Elements, Rest extends array_.NonEmptyReadonlyArray<TupleType.Rest[number]>>(elements: Elements, ...rest: Rest): TupleType<Elements, Rest>;
+export declare function Tuple<Fst extends Schema.Any, Snd extends Schema.Any>(fst: Fst, snd: Snd): Tuple2<Fst, Snd>;
 export declare function Tuple<Elements extends TupleType.Elements>(...elements: Elements): Tuple<Elements>;
 /**
  * @category api interface
@@ -795,9 +817,10 @@ Array$ as Array };
  * @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>;
 }
 /**
  * @category constructors
@@ -808,24 +831,24 @@ export declare const NonEmptyArray: <Value extends Schema.Any>(value: Value) =>
  * @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 declare const ArrayEnsure: <Value extends Schema.Any>(value: Value) => ArrayEnsure<Value>;
+export declare function ArrayEnsure<Value extends Schema.Any>(value: Value): ArrayEnsure<Value>;
 /**
  * @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 declare const NonEmptyArrayEnsure: <Value extends Schema.Any>(value: Value) => NonEmptyArrayEnsure<Value>;
+export declare function NonEmptyArrayEnsure<Value extends Schema.Any>(value: Value): NonEmptyArrayEnsure<Value>;
 /**
  * @since 3.10.0
  */
@@ -1190,31 +1213,29 @@ export declare namespace Struct {
     type Fields = {
         readonly [x: PropertyKey]: Schema.All | 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 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 : never;
-    }[keyof Fields];
-    type TypeTokenKeys<Fields extends Struct.Fields> = {
-        [K in keyof Fields]: Fields[K] extends OptionalPropertySignature ? K : never;
+    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 EncodedOptionalKeys<Fields extends Struct.Fields> = {
+        [K in keyof Fields]: Fields[K] extends OptionalEncodedPropertySignature ? K : never;
     }[keyof Fields];
-    type OptionalPropertySignature = 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 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>;
     /**
      * @since 3.10.0
      */
     type Type<F extends Fields> = Types.UnionToIntersection<{
-        [K in keyof F]: F[K] extends OptionalPropertySignature ? {
+        [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
      */
     type Encoded<F extends Fields> = {
-        readonly [K in Exclude<keyof F, 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 EncodedTokenKeys<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
@@ -1225,7 +1246,7 @@ export declare namespace Struct {
      * @since 3.10.0
      */
     type Constructor<F extends Fields> = Types.UnionToIntersection<{
-        [K in keyof F]: F[K] extends OptionalPropertySignature ? {
+        [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]>;
@@ -1471,7 +1492,7 @@ export declare 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]`.
@@ -1502,7 +1523,7 @@ export declare 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>;
 };
 /**
  * @category branding
@@ -1516,6 +1537,7 @@ export interface BrandSchema<A extends Brand<any>, I = A, R = never> extends Ann
  * @since 3.10.0
  */
 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>;
 }
 /**
@@ -1741,50 +1763,50 @@ export declare 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?: {
+    <To extends Schema.Any>(to: To, options?: {
         readonly strict: true;
-    }): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<C, A, R1 | R2>;
+    }): <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: {
+    <To extends Schema.Any>(to: To, options: {
         readonly strict: false;
-    }): <B, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>;
+    }): <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>, options?: {
+    <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: {
+    <From extends Schema.Any, To extends Schema.Any>(from: From, to: To, options: {
         readonly strict: false;
-    }): SchemaClass<D, A, R1 | R2>;
+    }): transform<From, To>;
 };
 /**
  * @category api interface
@@ -1871,7 +1893,7 @@ export declare const filterEffect: {
  * @category api interface
  * @since 3.10.0
  */
-export interface transformOrFail<From extends Schema.Any, To extends Schema.Any, R = never> extends AnnotableClass<transformOrFail<From, To, R>, Schema.Type<To>, Schema.Encoded<From>, Schema.Context<From> | Schema.Context<To> | R> {
+export interface transformOrFail<From extends Schema.All, To extends Schema.All, R = never> extends AnnotableClass<transformOrFail<From, To, R>, Schema.Type<To>, Schema.Encoded<From>, Schema.Context<From> | Schema.Context<To> | R> {
     readonly from: From;
     readonly to: To;
 }
@@ -1920,7 +1942,7 @@ export declare 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>;
 }
 /**
@@ -1968,7 +1990,8 @@ export declare 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.
@@ -1985,7 +2008,7 @@ export interface transformLiteral<Type, Encoded> extends Annotable<transformLite
  * @category constructors
  * @since 3.10.0
  */
-export declare const transformLiteral: <Encoded extends AST.LiteralValue, Type extends AST.LiteralValue>(from: Encoded, to: Type) => transformLiteral<Type, Encoded>;
+export declare function transformLiteral<Encoded extends AST.LiteralValue, Type extends AST.LiteralValue>(from: Encoded, to: Type): transformLiteral<Type, Encoded>;
 /**
  * Creates a new `Schema` which maps between corresponding literal values.
  *
@@ -2225,7 +2248,7 @@ export declare const TrimmedSchemaId: unique symbol;
  * @category string filters
  * @since 3.10.0
  */
-export declare const trimmed: <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2240,7 +2263,7 @@ export type MaxLengthSchemaId = typeof MaxLengthSchemaId;
  * @category string filters
  * @since 3.10.0
  */
-export declare const maxLength: <A extends string>(maxLength: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2255,7 +2278,25 @@ export type MinLengthSchemaId = typeof MinLengthSchemaId;
  * @category string filters
  * @since 3.10.0
  */
-export declare const minLength: <A extends string>(minLength: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const minLength: <S extends Schema.Any>(minLength: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export declare const LengthSchemaId: unique symbol;
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export type LengthSchemaId = typeof LengthSchemaId;
+/**
+ * @category string filters
+ * @since 3.10.0
+ */
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2265,7 +2306,7 @@ export declare const PatternSchemaId: unique symbol;
  * @category string filters
  * @since 3.10.0
  */
-export declare const pattern: <A extends string>(regex: RegExp, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const pattern: <S extends Schema.Any>(regex: RegExp, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2275,7 +2316,7 @@ export declare const StartsWithSchemaId: unique symbol;
  * @category string filters
  * @since 3.10.0
  */
-export declare const startsWith: <A extends string>(startsWith: string, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const startsWith: <S extends Schema.Any>(startsWith: string, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2285,7 +2326,7 @@ export declare const EndsWithSchemaId: unique symbol;
  * @category string filters
  * @since 3.10.0
  */
-export declare const endsWith: <A extends string>(endsWith: string, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const endsWith: <S extends Schema.Any>(endsWith: string, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2295,7 +2336,7 @@ export declare const IncludesSchemaId: unique symbol;
  * @category string filters
  * @since 3.10.0
  */
-export declare const includes: <A extends string>(searchString: string, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const includes: <S extends Schema.Any>(searchString: string, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2307,8 +2348,8 @@ export declare const LowercasedSchemaId: unique symbol;
  * @category string filters
  * @since 3.10.0
  */
-export declare const lowercased: <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
-declare const Lowercased_base: filter<Schema<string, string, never>>;
+export declare const lowercased: <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>;
+declare const Lowercased_base: filter<typeof String$>;
 /**
  * @category string constructors
  * @since 3.10.0
@@ -2319,78 +2360,60 @@ export declare class Lowercased extends Lowercased_base {
  * @category schema id
  * @since 3.10.0
  */
-export declare const CapitalizedSchemaId: unique symbol;
+export declare const UppercasedSchemaId: unique symbol;
 /**
- * Verifies that a string is capitalized.
+ * Verifies that a string is uppercased.
  *
  * @category string filters
  * @since 3.10.0
  */
-export declare const capitalized: <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
-declare const Capitalized_base: filter<Schema<string, string, never>>;
+export declare 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>;
+declare const Uppercased_base: filter<typeof String$>;
 /**
  * @category string constructors
  * @since 3.10.0
  */
-export declare class Capitalized extends Capitalized_base {
+export declare class Uppercased extends Uppercased_base {
 }
 /**
  * @category schema id
  * @since 3.10.0
  */
-export declare const UncapitalizedSchemaId: unique symbol;
+export declare const CapitalizedSchemaId: unique symbol;
 /**
- * Verifies that a string is uncapitalized.
+ * Verifies that a string is capitalized.
  *
  * @category string filters
  * @since 3.10.0
  */
-export declare const uncapitalized: <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
-declare const Uncapitalized_base: filter<Schema<string, string, never>>;
+export declare 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>;
+declare const Capitalized_base: filter<typeof String$>;
 /**
  * @category string constructors
  * @since 3.10.0
  */
-export declare class Uncapitalized extends Uncapitalized_base {
+export declare class Capitalized extends Capitalized_base {
 }
 /**
  * @category schema id
  * @since 3.10.0
  */
-export declare const UppercasedSchemaId: unique symbol;
+export declare const UncapitalizedSchemaId: unique symbol;
 /**
- * Verifies that a string is uppercased.
+ * Verifies that a string is uncapitalized.
  *
  * @category string filters
  * @since 3.10.0
  */
-export declare const uppercased: <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
-declare const Uppercased_base: filter<Schema<string, string, never>>;
+export declare 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>;
+declare const Uncapitalized_base: filter<typeof String$>;
 /**
  * @category string constructors
  * @since 3.10.0
  */
-export declare class Uppercased extends Uppercased_base {
+export declare class Uncapitalized extends Uncapitalized_base {
 }
-/**
- * @category schema id
- * @since 3.10.0
- */
-export declare const LengthSchemaId: unique symbol;
-/**
- * @category schema id
- * @since 3.10.0
- */
-export type LengthSchemaId = typeof LengthSchemaId;
-/**
- * @category string filters
- * @since 3.10.0
- */
-export declare 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>>;
-declare const Char_base: filter<Schema<string, string, never>>;
+declare const Char_base: filter<typeof String$>;
 /**
  * A schema representing a single character.
  *
@@ -2403,7 +2426,7 @@ export declare class Char extends Char_base {
  * @category string filters
  * @since 3.10.0
  */
-export declare const nonEmptyString: <A extends string>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 declare const Lowercase_base: transform<SchemaClass<string, string, never>, typeof Lowercased>;
 /**
  * This schema converts a string to lowercase.
@@ -2440,14 +2463,14 @@ declare const Uncapitalize_base: transform<SchemaClass<string, string, never>, t
  */
 export declare class Uncapitalize extends Uncapitalize_base {
 }
-declare const Trimmed_base: filter<Schema<string, string, never>>;
+declare const Trimmed_base: filter<typeof String$>;
 /**
  * @category string constructors
  * @since 3.10.0
  */
 export declare class Trimmed extends Trimmed_base {
 }
-declare const NonEmptyTrimmedString_base: filter<Schema<string, string, never>>;
+declare const NonEmptyTrimmedString_base: filter<typeof Trimmed>;
 /**
  * Useful for validating strings that must contain meaningful characters without
  * leading or trailing whitespace.
@@ -2481,7 +2504,7 @@ export declare class Trim extends Trim_base {
  * @category string transformations
  * @since 3.10.0
  */
-export declare const split: (separator: string) => transform<typeof String$, Array$<typeof String$>>;
+export declare const split: (separator: string) => transform<SchemaClass<string>, Array$<typeof String$>>;
 /**
  * @since 3.10.0
  */
@@ -2529,7 +2552,7 @@ export declare 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.
@@ -2551,7 +2574,7 @@ export declare const parseJson: {
      */
     (options?: ParseJsonOptions): SchemaClass<unknown, string>;
 };
-declare const NonEmptyString_base: filter<Schema<string, string, never>>;
+declare const NonEmptyString_base: filter<typeof String$>;
 /**
  * @category string constructors
  * @since 3.10.0
@@ -2563,7 +2586,7 @@ export declare class NonEmptyString extends NonEmptyString_base {
  * @since 3.10.0
  */
 export declare const UUIDSchemaId: unique symbol;
-declare const UUID_base: filter<Schema<string, string, never>>;
+declare const UUID_base: filter<typeof String$>;
 /**
  * Represents a Universally Unique Identifier (UUID).
  *
@@ -2579,7 +2602,7 @@ export declare class UUID extends UUID_base {
  * @since 3.10.0
  */
 export declare const ULIDSchemaId: unique symbol;
-declare const ULID_base: filter<Schema<string, string, never>>;
+declare const ULID_base: filter<typeof String$>;
 /**
  * Represents a Universally Unique Lexicographically Sortable Identifier (ULID).
  *
@@ -2629,7 +2652,7 @@ export type FiniteSchemaId = typeof FiniteSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const finite: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const finite: <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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2646,7 +2669,7 @@ export type GreaterThanSchemaId = typeof GreaterThanSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const greaterThan: <A extends number>(exclusiveMinimum: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThan: <S extends Schema.Any>(exclusiveMinimum: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2663,7 +2686,7 @@ export type GreaterThanOrEqualToSchemaId = typeof GreaterThanOrEqualToSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const greaterThanOrEqualTo: <A extends number>(minimum: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanOrEqualTo: <S extends Schema.Any>(minimum: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2673,7 +2696,7 @@ export declare const MultipleOfSchemaId: unique symbol;
  * @category number filters
  * @since 3.10.0
  */
-export declare const multipleOf: <A extends number>(divisor: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const multipleOf: <S extends Schema.Any>(divisor: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2690,7 +2713,7 @@ export type IntSchemaId = typeof IntSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const int: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const int: <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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2707,7 +2730,7 @@ export type LessThanSchemaId = typeof LessThanSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const lessThan: <A extends number>(exclusiveMaximum: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThan: <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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2724,7 +2747,7 @@ export type LessThanOrEqualToSchemaId = typeof LessThanOrEqualToSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const lessThanOrEqualTo: <A extends number>(maximum: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanOrEqualTo: <S extends Schema.Any>(maximum: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2741,7 +2764,7 @@ export type BetweenSchemaId = typeof BetweenSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const between: <A extends number>(minimum: number, maximum: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const between: <S extends Schema.Any>(minimum: number, maximum: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends number>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2756,46 +2779,49 @@ export type NonNaNSchemaId = typeof NonNaNSchemaId;
  * @category number filters
  * @since 3.10.0
  */
-export declare const nonNaN: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const nonNaN: <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>;
 /**
  * @category number filters
  * @since 3.10.0
  */
-export declare const positive: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category number filters
  * @since 3.10.0
  */
-export declare const negative: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category number filters
  * @since 3.10.0
  */
-export declare const nonPositive: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category number filters
  * @since 3.10.0
  */
-export declare const nonNegative: <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * Clamps a number between a minimum and a maximum value.
  *
  * @category number transformations
  * @since 3.10.0
  */
-export declare const clamp: (minimum: number, maximum: number) => <A extends number, I, R>(self: Schema<A, I, R>) => transform<Schema<A, I, R>, filter<Schema<A>>>;
+export declare 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>>>;
 /**
- * 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 declare const parseNumber: <A extends string, I, R>(self: Schema<A, I, R>) => transformOrFail<Schema<A, I, R>, typeof Number$>;
-declare const NumberFromString_base: transformOrFail<Schema<string, string, never>, typeof Number$, never>;
+export declare function parseNumber<S extends Schema.Any, A extends string>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): transformOrFail<S, typeof Number$>;
+declare const NumberFromString_base: transformOrFail<SchemaClass<string, string, never>, typeof Number$, never>;
 /**
  * This schema transforms a `string` into a `number` by parsing the string using the `parse` function of the `effect/Number` module.
  *
@@ -2808,49 +2834,49 @@ declare const NumberFromString_base: transformOrFail<Schema<string, string, neve
  */
 export declare class NumberFromString extends NumberFromString_base {
 }
-declare const Finite_base: filter<Schema<number, number, never>>;
+declare const Finite_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
  */
 export declare class Finite extends Finite_base {
 }
-declare const Int_base: filter<Schema<number, number, never>>;
+declare const Int_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
  */
 export declare class Int extends Int_base {
 }
-declare const NonNaN_base: filter<Schema<number, number, never>>;
+declare const NonNaN_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
  */
 export declare class NonNaN extends NonNaN_base {
 }
-declare const Positive_base: filter<Schema<number, number, never>>;
+declare const Positive_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
  */
 export declare class Positive extends Positive_base {
 }
-declare const Negative_base: filter<Schema<number, number, never>>;
+declare const Negative_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
  */
 export declare class Negative extends Negative_base {
 }
-declare const NonPositive_base: filter<Schema<number, number, never>>;
+declare const NonPositive_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
  */
 export declare class NonPositive extends NonPositive_base {
 }
-declare const NonNegative_base: filter<Schema<number, number, never>>;
+declare const NonNegative_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.10.0
@@ -2867,7 +2893,7 @@ export declare const JsonNumberSchemaId: unique symbol;
  * @since 3.10.0
  */
 export type JsonNumberSchemaId = typeof JsonNumberSchemaId;
-declare const JsonNumber_base: filter<Schema<number, number, never>>;
+declare const JsonNumber_base: filter<typeof Number$>;
 /**
  * The `JsonNumber` is a schema for representing JSON numbers. It ensures that the provided value is a valid
  * number by filtering out `NaN` and `(+/-) Infinity`. This is useful when you want to validate and represent numbers in JSON
@@ -2923,7 +2949,7 @@ export type GreaterThanBigIntSchemaId = typeof GreaterThanBigIntSchemaId;
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const greaterThanBigInt: <A extends bigint>(min: bigint, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanBigInt: <S extends Schema.Any>(min: bigint, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2938,7 +2964,7 @@ export type GreaterThanOrEqualToBigIntSchemaId = typeof GreaterThanOrEqualToBigI
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const greaterThanOrEqualToBigInt: <A extends bigint>(min: bigint, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanOrEqualToBigInt: <S extends Schema.Any>(min: bigint, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2953,7 +2979,7 @@ export type LessThanBigIntSchemaId = typeof LessThanBigIntSchemaId;
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const lessThanBigInt: <A extends bigint>(max: bigint, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanBigInt: <S extends Schema.Any>(max: bigint, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2968,7 +2994,7 @@ export type LessThanOrEqualToBigIntSchemaId = typeof LessThanOrEqualToBigIntSche
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const lessThanOrEqualToBigInt: <A extends bigint>(max: bigint, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanOrEqualToBigInt: <S extends Schema.Any>(max: bigint, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -2983,34 +3009,34 @@ export type BetweenBigIntSchemaId = typeof BetweenBigIntSchemaId;
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const betweenBigInt: <A extends bigint>(min: bigint, max: bigint, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const betweenBigInt: <S extends Schema.Any>(min: bigint, max: bigint, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends bigint>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const positiveBigInt: <A extends bigint>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const negativeBigInt: <A extends bigint>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const nonNegativeBigInt: <A extends bigint>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category bigint filters
  * @since 3.10.0
  */
-export declare const nonPositiveBigInt: <A extends bigint>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * Clamps a bigint between a minimum and a maximum value.
  *
  * @category bigint transformations
  * @since 3.10.0
  */
-export declare const clampBigInt: (minimum: bigint, maximum: bigint) => <A extends bigint, I, R>(self: Schema<A, I, R>) => transform<Schema<A, I, R>, filter<Schema<A>>>;
+export declare 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>>>;
 declare const BigInt$_base: transformOrFail<SchemaClass<string, string, never>, typeof BigIntFromSelf, never>;
 /** @ignore */
 declare class BigInt$ extends BigInt$_base {
@@ -3065,7 +3091,7 @@ export declare const NonNegativeBigIntFromSelf: filter<Schema<bigint>>;
  * @since 3.10.0
  */
 export declare const NonNegativeBigInt: filter<Schema<bigint, string>>;
-declare const BigIntFromNumber_base: transformOrFail<SchemaClass<number, number, never>, filter<Schema<bigint, bigint, never>>, never>;
+declare const BigIntFromNumber_base: transformOrFail<SchemaClass<number, number, never>, filter<typeof BigIntFromSelf>, never>;
 /**
  * This schema transforms a `number` into a `bigint` by parsing the number using the `BigInt` function.
  *
@@ -3080,7 +3106,9 @@ export declare class BigIntFromNumber extends BigIntFromNumber_base {
  * @category api interface
  * @since 3.10.0
  */
-export interface RedactedFromSelf<Value extends Schema.Any> extends AnnotableClass<RedactedFromSelf<Value>, redacted_.Redacted<Schema.Type<Value>>, redacted_.Redacted<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface RedactedFromSelf<Value extends Schema.Any> extends AnnotableDeclare<RedactedFromSelf<Value>, redacted_.Redacted<Schema.Type<Value>>, redacted_.Redacted<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category Redacted constructors
@@ -3091,16 +3119,17 @@ export declare const RedactedFromSelf: <Value extends Schema.Any>(value: Value)
  * @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 declare const Redacted: <Value extends Schema.Any>(value: Value) => Redacted<Value>;
-declare const DurationFromSelf_base: SchemaClass<duration_.Duration, duration_.Duration, never>;
+export declare function Redacted<Value extends Schema.Any>(value: Value): Redacted<Value>;
+declare const DurationFromSelf_base: declare<duration_.Duration, duration_.Duration, readonly [], never>;
 /**
  * @category Duration constructors
  * @since 3.10.0
@@ -3123,8 +3152,8 @@ export declare class DurationFromNanos extends DurationFromNanos_base {
  * @category number constructors
  * @since 3.11.10
  */
-export declare const NonNegativeInt: refine<number, Schema<number, number, never>>;
-declare const DurationFromMillis_base: transform<refine<number, Schema<number, number, never>>, typeof DurationFromSelf>;
+export declare const NonNegativeInt: refine<number, typeof NonNegative>;
+declare const DurationFromMillis_base: transform<refine<number, typeof Number$>, typeof DurationFromSelf>;
 /**
  * A schema that transforms a (possibly Infinite) non negative number into a
  * `Duration`. Treats the value as the number of milliseconds.
@@ -3162,7 +3191,7 @@ export declare class Duration extends Duration_base {
  * @category Duration transformations
  * @since 3.10.0
  */
-export declare 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>>>;
+export declare const clampDuration: (minimum: duration_.DurationInput, maximum: duration_.DurationInput) => <S extends Schema.Any, A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => transform<S, filter<SchemaClass<A>>>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3172,7 +3201,7 @@ export declare const LessThanDurationSchemaId: unique symbol;
  * @category Duration filters
  * @since 3.10.0
  */
-export declare const lessThanDuration: <A extends duration_.Duration>(max: duration_.DurationInput, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanDuration: <S extends Schema.Any>(max: duration_.DurationInput, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3182,7 +3211,7 @@ export declare const LessThanOrEqualToDurationSchemaId: unique symbol;
  * @category Duration filters
  * @since 3.10.0
  */
-export declare const lessThanOrEqualToDuration: <A extends duration_.Duration>(max: duration_.DurationInput, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanOrEqualToDuration: <S extends Schema.Any>(max: duration_.DurationInput, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3192,7 +3221,7 @@ export declare const GreaterThanDurationSchemaId: unique symbol;
  * @category Duration filters
  * @since 3.10.0
  */
-export declare const greaterThanDuration: <A extends duration_.Duration>(min: duration_.DurationInput, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanDuration: <S extends Schema.Any>(min: duration_.DurationInput, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3202,7 +3231,7 @@ export declare const GreaterThanOrEqualToDurationSchemaId: unique symbol;
  * @category Duration filters
  * @since 3.10.0
  */
-export declare const greaterThanOrEqualToDuration: <A extends duration_.Duration>(min: duration_.DurationInput, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanOrEqualToDuration: <S extends Schema.Any>(min: duration_.DurationInput, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3212,18 +3241,25 @@ export declare const BetweenDurationSchemaId: unique symbol;
  * @category Duration filters
  * @since 3.10.0
  */
-export declare const betweenDuration: <A extends duration_.Duration>(minimum: duration_.DurationInput, maximum: duration_.DurationInput, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const betweenDuration: <S extends Schema.Any>(minimum: duration_.DurationInput, maximum: duration_.DurationInput, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends duration_.Duration>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
+declare const Uint8ArrayFromSelf_base: declare<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, readonly [], never>;
 /**
  * @category Uint8Array constructors
  * @since 3.10.0
  */
-export declare const Uint8ArrayFromSelf: Schema<Uint8Array>;
+export declare class Uint8ArrayFromSelf extends Uint8ArrayFromSelf_base {
+}
+declare const Uint8_base: filter<typeof Number$>;
 /**
  * @category number constructors
  * @since 3.11.10
  */
-export declare const Uint8: filter<Schema<number, number, never>>;
-declare const Uint8Array$: Schema<Uint8Array, ReadonlyArray<number>>;
+export declare class Uint8 extends Uint8_base {
+}
+declare const Uint8Array$_base: transform<Array$<typeof Uint8>, typeof Uint8ArrayFromSelf>;
+/** @ignore */
+declare class Uint8Array$ extends Uint8Array$_base {
+}
 export { 
 /**
  * A schema that transforms an array of numbers into a `Uint8Array`.
@@ -3311,7 +3347,7 @@ export type MinItemsSchemaId = typeof MinItemsSchemaId;
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export declare const minItems: <A extends ReadonlyArray<any>>(n: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const minItems: <S extends Schema.Any>(n: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends ReadonlyArray<any>>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3326,7 +3362,7 @@ export type MaxItemsSchemaId = typeof MaxItemsSchemaId;
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export declare const maxItems: <A extends ReadonlyArray<any>>(n: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const maxItems: <S extends Schema.Any>(n: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends ReadonlyArray<any>>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3341,7 +3377,7 @@ export type ItemsCountSchemaId = typeof ItemsCountSchemaId;
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export declare const itemsCount: <A extends ReadonlyArray<any>>(n: number, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const itemsCount: <S extends Schema.Any>(n: number, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends ReadonlyArray<any>>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category ReadonlyArray transformations
  * @since 3.10.0
@@ -3353,14 +3389,14 @@ export declare const getNumberIndexedAccess: <A extends ReadonlyArray<any>, I ex
  * @category ReadonlyArray transformations
  * @since 3.10.0
  */
-export declare const head: <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>) => SchemaClass<option_.Option<A>, I, R>;
+export declare 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]>>>;
 /**
  * Get the first element of a `NonEmptyReadonlyArray`.
  *
  * @category NonEmptyReadonlyArray transformations
  * @since 3.12.0
  */
-export declare const headNonEmpty: <A, I, R>(self: Schema<array_.NonEmptyReadonlyArray<A>, I, R>) => SchemaClass<A, I, R>;
+export declare 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]>>;
 /**
  * Retrieves the first element of a `ReadonlyArray`.
  *
@@ -3378,7 +3414,7 @@ export declare 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`.
      *
@@ -3387,7 +3423,7 @@ export declare 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]>>;
 };
 /**
  * @category schema id
@@ -3403,7 +3439,7 @@ export declare const ValidDateSchemaId: unique symbol;
  * @category Date filters
  * @since 3.10.0
  */
-export declare const validDate: (annotations?: Annotations.Filter<Date>) => <I, R>(self: Schema<Date, I, R>) => filter<Schema<Date, I, R>>;
+export declare const validDate: <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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3413,7 +3449,7 @@ export declare const LessThanDateSchemaId: unique symbol;
  * @category Date filters
  * @since 3.10.0
  */
-export declare const lessThanDate: <A extends Date>(max: Date, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanDate: <S extends Schema.Any>(max: Date, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3423,7 +3459,7 @@ export declare const LessThanOrEqualToDateSchemaId: unique symbol;
  * @category Date filters
  * @since 3.10.0
  */
-export declare const lessThanOrEqualToDate: <A extends Date>(max: Date, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const lessThanOrEqualToDate: <S extends Schema.Any>(max: Date, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3433,7 +3469,7 @@ export declare const GreaterThanDateSchemaId: unique symbol;
  * @category Date filters
  * @since 3.10.0
  */
-export declare const greaterThanDate: <A extends Date>(min: Date, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanDate: <S extends Schema.Any>(min: Date, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3443,7 +3479,7 @@ export declare const GreaterThanOrEqualToDateSchemaId: unique symbol;
  * @category Date filters
  * @since 3.10.0
  */
-export declare const greaterThanOrEqualToDate: <A extends Date>(min: Date, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const greaterThanOrEqualToDate: <S extends Schema.Any>(min: Date, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3453,7 +3489,7 @@ export declare const BetweenDateSchemaId: unique symbol;
  * @category Date filters
  * @since 3.10.0
  */
-export declare const betweenDate: <A extends Date>(min: Date, max: Date, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const betweenDate: <S extends Schema.Any>(min: Date, max: Date, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * @category schema id
  * @since 3.11.8
@@ -3464,7 +3500,7 @@ export declare const DateFromSelfSchemaId: unique symbol;
  * @since 3.11.8
  */
 export type DateFromSelfSchemaId = typeof DateFromSelfSchemaId;
-declare const DateFromSelf_base: SchemaClass<Date, Date, never>;
+declare const DateFromSelf_base: declare<Date, Date, readonly [], never>;
 /**
  * Describes a schema that accommodates potentially invalid `Date` instances,
  * such as `new Date("Invalid Date")`, without rejection.
@@ -3474,7 +3510,7 @@ declare const DateFromSelf_base: SchemaClass<Date, Date, never>;
  */
 export declare class DateFromSelf extends DateFromSelf_base {
 }
-declare const ValidDateFromSelf_base: filter<Schema<Date, Date, never>>;
+declare const ValidDateFromSelf_base: filter<typeof DateFromSelf>;
 /**
  * Defines a schema that ensures only valid dates are accepted. This schema
  * rejects values like `new Date("Invalid Date")`, which, despite being a `Date`
@@ -3499,7 +3535,7 @@ declare const DateFromString_base: transform<SchemaClass<string, string, never>,
  */
 export declare class DateFromString extends DateFromString_base {
 }
-declare const Date$_base: filter<Schema<Date, string, never>>;
+declare const Date$_base: filter<typeof DateFromString>;
 /** @ignore */
 declare class Date$ extends Date$_base {
 }
@@ -3527,7 +3563,7 @@ declare const DateFromNumber_base: transform<SchemaClass<number, number, never>,
  */
 export declare class DateFromNumber extends DateFromNumber_base {
 }
-declare const DateTimeUtcFromSelf_base: SchemaClass<dateTime.Utc, dateTime.Utc, never>;
+declare const DateTimeUtcFromSelf_base: declare<dateTime.Utc, dateTime.Utc, readonly [], never>;
 /**
  * Describes a schema that represents a `DateTime.Utc` instance.
  *
@@ -3545,7 +3581,7 @@ declare const DateTimeUtcFromNumber_base: transformOrFail<SchemaClass<number, nu
  */
 export declare class DateTimeUtcFromNumber extends DateTimeUtcFromNumber_base {
 }
-declare const DateTimeUtcFromDate_base: transformOrFail<SchemaClass<Date, Date, never>, typeof DateTimeUtcFromSelf, never>;
+declare const DateTimeUtcFromDate_base: transformOrFail<declare<Date, Date, readonly [], never>, typeof DateTimeUtcFromSelf, never>;
 /**
  * Defines a schema that attempts to convert a `Date` to a `DateTime.Utc` instance using the `DateTime.unsafeMake` constructor.
  *
@@ -3563,7 +3599,7 @@ declare const DateTimeUtc_base: transformOrFail<SchemaClass<string, string, neve
  */
 export declare class DateTimeUtc extends DateTimeUtc_base {
 }
-declare const TimeZoneOffsetFromSelf_base: SchemaClass<dateTime.TimeZone.Offset, dateTime.TimeZone.Offset, never>;
+declare const TimeZoneOffsetFromSelf_base: declare<dateTime.TimeZone.Offset, dateTime.TimeZone.Offset, readonly [], never>;
 /**
  * Describes a schema that represents a `TimeZone.Offset` instance.
  *
@@ -3581,7 +3617,7 @@ declare const TimeZoneOffset_base: transform<SchemaClass<number, number, never>,
  */
 export declare class TimeZoneOffset extends TimeZoneOffset_base {
 }
-declare const TimeZoneNamedFromSelf_base: SchemaClass<dateTime.TimeZone.Named, dateTime.TimeZone.Named, never>;
+declare const TimeZoneNamedFromSelf_base: declare<dateTime.TimeZone.Named, dateTime.TimeZone.Named, readonly [], never>;
 /**
  * Describes a schema that represents a `TimeZone.Named` instance.
  *
@@ -3615,7 +3651,7 @@ declare const TimeZone_base: transformOrFail<SchemaClass<string, string, never>,
  */
 export declare class TimeZone extends TimeZone_base {
 }
-declare const DateTimeZonedFromSelf_base: SchemaClass<dateTime.Zoned, dateTime.Zoned, never>;
+declare const DateTimeZonedFromSelf_base: declare<dateTime.Zoned, dateTime.Zoned, readonly [], never>;
 /**
  * Describes a schema that represents a `DateTime.Zoned` instance.
  *
@@ -3647,7 +3683,9 @@ export type OptionEncoded<I> = {
  * @category api interface
  * @since 3.10.0
  */
-export interface OptionFromSelf<Value extends Schema.Any> extends AnnotableClass<OptionFromSelf<Value>, option_.Option<Schema.Type<Value>>, option_.Option<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface OptionFromSelf<Value extends Schema.Any> extends AnnotableDeclare<OptionFromSelf<Value>, option_.Option<Schema.Type<Value>>, option_.Option<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category Option transformations
@@ -3658,46 +3696,55 @@ export declare const OptionFromSelf: <Value extends Schema.Any>(value: Value) =>
  * @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>> {
+export interface Option<Value extends Schema.Any> extends transform<Union<[
+    Struct<{
+        _tag: Literal<["None"]>;
+    }>,
+    Struct<{
+        _tag: Literal<["Some"]>;
+        value: Value;
+    }>
+]>, OptionFromSelf<SchemaClass<Schema.Type<Value>>>> {
 }
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export declare const Option: <Value extends Schema.Any>(value: Value) => Option<Value>;
+export declare function Option<Value extends Schema.Any>(value: Value): Option<Value>;
 /**
  * @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 declare const OptionFromNullOr: <Value extends Schema.Any>(value: Value) => OptionFromNullOr<Value>;
+export declare function OptionFromNullOr<Value extends Schema.Any>(value: Value): OptionFromNullOr<Value>;
 /**
  * @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 declare const OptionFromNullishOr: <Value extends Schema.Any>(value: Value, onNoneEncoding: null | undefined) => OptionFromNullishOr<Value>;
+export declare function OptionFromNullishOr<Value extends Schema.Any>(value: Value, onNoneEncoding: null | undefined): OptionFromNullishOr<Value>;
 /**
  * @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 declare const OptionFromUndefinedOr: <Value extends Schema.Any>(value: Value) => OptionFromUndefinedOr<Value>;
+export declare function OptionFromUndefinedOr<Value extends Schema.Any>(value: Value): OptionFromUndefinedOr<Value>;
+declare const OptionFromNonEmptyTrimmedString_base: transform<typeof String$, OptionFromSelf<typeof NonEmptyTrimmedString>>;
 /**
  * Transforms strings into an Option type, effectively filtering out empty or
  * whitespace-only strings by trimming them and checking their length. Returns
@@ -3715,7 +3762,8 @@ export declare const OptionFromUndefinedOr: <Value extends Schema.Any>(value: Va
  * @category Option transformations
  * @since 3.10.0
  */
-export declare const OptionFromNonEmptyTrimmedString: transform<typeof String$, OptionFromSelf<typeof NonEmptyTrimmedString>>;
+export declare class OptionFromNonEmptyTrimmedString extends OptionFromNonEmptyTrimmedString_base {
+}
 /**
  * @category Either utils
  * @since 3.10.0
@@ -3741,7 +3789,10 @@ export type EitherEncoded<IR, IL> = RightEncoded<IR> | LeftEncoded<IL>;
  * @category api interface
  * @since 3.10.0
  */
-export interface EitherFromSelf<R extends Schema.All, L extends Schema.All> extends AnnotableClass<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>> {
+export interface EitherFromSelf<R extends Schema.All, L extends Schema.All> extends AnnotableDeclare<EitherFromSelf<R, L>, either_.Either<Schema.Type<R>, Schema.Type<L>>, either_.Either<Schema.Encoded<R>, Schema.Encoded<L>>, [
+    R,
+    L
+]> {
 }
 /**
  * @category Either transformations
@@ -3755,7 +3806,16 @@ export declare const EitherFromSelf: <R extends Schema.All, L extends Schema.All
  * @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>>>> {
 }
 /**
  * @category Either transformations
@@ -3769,7 +3829,16 @@ export declare const Either: <R extends Schema.All, L extends Schema.All>({ left
  * @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>>>> {
 }
 /**
  * @example
@@ -3783,15 +3852,18 @@ export interface EitherFromUnion<R extends Schema.All, L extends Schema.All> ext
  * @category Either transformations
  * @since 3.10.0
  */
-export declare const EitherFromUnion: <R extends Schema.All, L extends Schema.All>({ left, right }: {
-    readonly left: L;
-    readonly right: R;
-}) => EitherFromUnion<R, L>;
+export declare const EitherFromUnion: <Right extends Schema.All, Left extends Schema.All>({ left, right }: {
+    readonly left: Left;
+    readonly right: Right;
+}) => EitherFromUnion<Right, Left>;
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface ReadonlyMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableClass<ReadonlyMapFromSelf<K, V>, ReadonlyMap<Schema.Type<K>, Schema.Type<V>>, ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>, Schema.Context<K> | Schema.Context<V>> {
+export interface ReadonlyMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableDeclare<ReadonlyMapFromSelf<K, V>, ReadonlyMap<Schema.Type<K>, Schema.Type<V>>, ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>, [
+    K,
+    V
+]> {
 }
 /**
  * @category ReadonlyMap
@@ -3805,7 +3877,10 @@ export declare const ReadonlyMapFromSelf: <K extends Schema.Any, V extends Schem
  * @category api interface
  * @since 3.10.0
  */
-export interface MapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableClass<MapFromSelf<K, V>, Map<Schema.Type<K>, Schema.Type<V>>, ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>, Schema.Context<K> | Schema.Context<V>> {
+export interface MapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableDeclare<MapFromSelf<K, V>, Map<Schema.Type<K>, Schema.Type<V>>, ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>, [
+    K,
+    V
+]> {
 }
 /**
  * @category Map
@@ -3819,26 +3894,27 @@ export declare const MapFromSelf: <K extends Schema.Any, V extends Schema.Any>({
  * @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 declare const ReadonlyMap: <K extends Schema.Any, V extends Schema.Any>({ key, value }: {
+export declare function ReadonlyMap<K extends Schema.Any, V extends Schema.Any>({ key, value }: {
     readonly key: K;
     readonly value: V;
-}) => ReadonlyMap$<K, V>;
+}): ReadonlyMap$<K, 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>>>> {
 }
-declare const map: <K extends Schema.Any, V extends Schema.Any>({ key, value }: {
+/** @ignore */
+declare function map<K extends Schema.Any, V extends Schema.Any>({ key, value }: {
     readonly key: K;
     readonly value: V;
-}) => Map$<K, V>;
+}): Map$<K, V>;
 export { 
 /**
  * @category Map transformations
@@ -3852,7 +3928,7 @@ map as Map };
 export declare const ReadonlyMapFromRecord: <KA, KR, VA, VI, VR>({ key, value }: {
     key: Schema<KA, string, KR>;
     value: Schema<VA, VI, VR>;
-}) => Schema<ReadonlyMap<KA, VA>, {
+}) => SchemaClass<ReadonlyMap<KA, VA>, {
     readonly [x: string]: VI;
 }, KR | VR>;
 /**
@@ -3862,14 +3938,16 @@ export declare const ReadonlyMapFromRecord: <KA, KR, VA, VI, VR>({ key, value }:
 export declare const MapFromRecord: <KA, KR, VA, VI, VR>({ key, value }: {
     key: Schema<KA, string, KR>;
     value: Schema<VA, VI, VR>;
-}) => Schema<Map<KA, VA>, {
+}) => SchemaClass<Map<KA, VA>, {
     readonly [x: string]: VI;
 }, KR | VR>;
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface ReadonlySetFromSelf<Value extends Schema.Any> extends AnnotableClass<ReadonlySetFromSelf<Value>, ReadonlySet<Schema.Type<Value>>, ReadonlySet<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface ReadonlySetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<ReadonlySetFromSelf<Value>, ReadonlySet<Schema.Type<Value>>, ReadonlySet<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category ReadonlySet
@@ -3880,7 +3958,9 @@ export declare const ReadonlySetFromSelf: <Value extends Schema.Any>(value: Valu
  * @category api interface
  * @since 3.10.0
  */
-export interface SetFromSelf<Value extends Schema.Any> extends AnnotableClass<SetFromSelf<Value>, Set<Schema.Type<Value>>, ReadonlySet<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface SetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<SetFromSelf<Value>, Set<Schema.Type<Value>>, ReadonlySet<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category Set
@@ -3891,27 +3971,28 @@ export declare const SetFromSelf: <Value extends Schema.Any>(value: Value) => Se
  * @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 declare const ReadonlySet: <Value extends Schema.Any>(value: Value) => ReadonlySet$<Value>;
+export declare function ReadonlySet<Value extends Schema.Any>(value: Value): ReadonlySet$<Value>;
 /**
  * @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>>>> {
 }
-declare const set: <Value extends Schema.Any>(value: Value) => Set$<Value>;
+/** @ignore */
+declare function set<Value extends Schema.Any>(value: Value): Set$<Value>;
 export { 
 /**
  * @category Set transformations
  * @since 3.10.0
  */
 set as Set };
-declare const BigDecimalFromSelf_base: SchemaClass<bigDecimal_.BigDecimal, bigDecimal_.BigDecimal, never>;
+declare const BigDecimalFromSelf_base: declare<bigDecimal_.BigDecimal, bigDecimal_.BigDecimal, readonly [], never>;
 /**
  * @category BigDecimal constructors
  * @since 3.10.0
@@ -3944,7 +4025,7 @@ export declare const GreaterThanBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare 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>>;
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3954,7 +4035,7 @@ export declare const GreaterThanOrEqualToBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare 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>>;
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3964,7 +4045,7 @@ export declare const LessThanBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare 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>>;
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3974,7 +4055,7 @@ export declare const LessThanOrEqualToBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare 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>>;
+export declare 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>;
 /**
  * @category schema id
  * @since 3.10.0
@@ -3984,7 +4065,7 @@ export declare const PositiveBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare const positiveBigDecimal: <A extends bigDecimal_.BigDecimal>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category BigDecimal constructors
  * @since 3.10.0
@@ -3999,7 +4080,7 @@ export declare const NonNegativeBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare const nonNegativeBigDecimal: <A extends bigDecimal_.BigDecimal>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category BigDecimal constructors
  * @since 3.10.0
@@ -4014,7 +4095,7 @@ export declare const NegativeBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare const negativeBigDecimal: <A extends bigDecimal_.BigDecimal>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category BigDecimal constructors
  * @since 3.10.0
@@ -4029,7 +4110,7 @@ export declare const NonPositiveBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare const nonPositiveBigDecimal: <A extends bigDecimal_.BigDecimal>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare 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>;
 /**
  * @category BigDecimal constructors
  * @since 3.10.0
@@ -4044,19 +4125,21 @@ export declare const BetweenBigDecimalSchemaId: unique symbol;
  * @category BigDecimal filters
  * @since 3.10.0
  */
-export declare const betweenBigDecimal: <A extends bigDecimal_.BigDecimal>(minimum: bigDecimal_.BigDecimal, maximum: bigDecimal_.BigDecimal, annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>;
+export declare const betweenBigDecimal: <S extends Schema.Any>(minimum: bigDecimal_.BigDecimal, maximum: bigDecimal_.BigDecimal, annotations?: Annotations.Filter<Schema.Type<S>>) => <A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => filter<S>;
 /**
  * Clamps a `BigDecimal` between a minimum and a maximum value.
  *
  * @category BigDecimal transformations
  * @since 3.10.0
  */
-export declare 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>>>;
+export declare const clampBigDecimal: (minimum: bigDecimal_.BigDecimal, maximum: bigDecimal_.BigDecimal) => <S extends Schema.Any, A extends bigDecimal_.BigDecimal>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>) => transform<S, filter<SchemaClass<A>>>;
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface ChunkFromSelf<Value extends Schema.Any> extends AnnotableClass<ChunkFromSelf<Value>, chunk_.Chunk<Schema.Type<Value>>, chunk_.Chunk<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface ChunkFromSelf<Value extends Schema.Any> extends AnnotableDeclare<ChunkFromSelf<Value>, chunk_.Chunk<Schema.Type<Value>>, chunk_.Chunk<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category Chunk
@@ -4067,18 +4150,20 @@ export declare const ChunkFromSelf: <Value extends Schema.Any>(value: Value) =>
  * @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 declare const Chunk: <Value extends Schema.Any>(value: Value) => Chunk<Value>;
+export declare function Chunk<Value extends Schema.Any>(value: Value): Chunk<Value>;
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface NonEmptyChunkFromSelf<Value extends Schema.Any> extends AnnotableClass<NonEmptyChunkFromSelf<Value>, chunk_.NonEmptyChunk<Schema.Type<Value>>, chunk_.NonEmptyChunk<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface NonEmptyChunkFromSelf<Value extends Schema.Any> extends AnnotableDeclare<NonEmptyChunkFromSelf<Value>, chunk_.NonEmptyChunk<Schema.Type<Value>>, chunk_.NonEmptyChunk<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category Chunk
@@ -4089,23 +4174,43 @@ export declare const NonEmptyChunkFromSelf: <Value extends Schema.Any>(value: Va
  * @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 declare const NonEmptyChunk: <Value extends Schema.Any>(value: Value) => NonEmptyChunk<Value>;
+export declare function NonEmptyChunk<Value extends Schema.Any>(value: Value): NonEmptyChunk<Value>;
 /**
+ * @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 declare 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>;
+export declare const DataFromSelf: <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>;
+/**
+ * @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 declare 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>;
+export declare const Data: <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>;
 type MissingSelfGeneric<Usage extends string, Params extends string = ""> = `Missing \`Self\` generic - use \`class Self extends ${Usage}<Self>()(${Params}{ ... })\``;
 type RequiredKeys<T> = {
     [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
@@ -4153,7 +4258,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>>) => [Extended] extends [never] ? MissingSelfGeneric<"Base.extend"> : Class<Extended, Fields & NewFields, I & Struct.Encoded<NewFields>, R | Struct.Context<NewFields>, C & Struct.Constructor<NewFields>, Self, Proto>;
+    extend<Extended = never>(identifier: string): <NewFields extends Struct.Fields>(fields: NewFields | HasFields<NewFields>, annotations?: ClassAnnotations<Extended, Simplify<Struct.Type<Fields & NewFields>>>) => [Extended] extends [never] ? MissingSelfGeneric<"Base.extend"> : Class<Extended, Fields & NewFields, I & Struct.Encoded<NewFields>, R | Struct.Context<NewFields>, C & Struct.Constructor<NewFields>, Self, Proto>;
     /**
      * @example
      * ```ts
@@ -4186,7 +4291,7 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
     transformOrFail<Transformed = never>(identifier: string): <NewFields extends Struct.Fields, R2, R3>(fields: NewFields, options: {
         readonly decode: (input: Simplify<Struct.Type<Fields>>, options: ParseOptions, ast: AST.Transformation) => Effect.Effect<Simplify<Struct.Type<Fields & NewFields>>, ParseResult.ParseIssue, R2>;
         readonly encode: (input: Simplify<Struct.Type<Fields & NewFields>>, options: ParseOptions, ast: AST.Transformation) => Effect.Effect<Struct.Type<Fields>, ParseResult.ParseIssue, R3>;
-    }, annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFail"> : Class<Transformed, Fields & NewFields, I, R | Struct.Context<NewFields> | R2 | R3, C & Struct.Constructor<NewFields>, Self, Proto>;
+    }, annotations?: ClassAnnotations<Transformed, Simplify<Struct.Type<Fields & NewFields>>>) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFail"> : Class<Transformed, Fields & NewFields, I, R | Struct.Context<NewFields> | R2 | R3, C & Struct.Constructor<NewFields>, Self, Proto>;
     /**
      * @example
      * ```ts
@@ -4219,7 +4324,7 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
     transformOrFailFrom<Transformed = never>(identifier: string): <NewFields extends Struct.Fields, R2, R3>(fields: NewFields, options: {
         readonly decode: (input: Simplify<I>, options: ParseOptions, ast: AST.Transformation) => Effect.Effect<Simplify<I & Struct.Encoded<NewFields>>, ParseResult.ParseIssue, R2>;
         readonly encode: (input: Simplify<I & Struct.Encoded<NewFields>>, options: ParseOptions, ast: AST.Transformation) => Effect.Effect<I, ParseResult.ParseIssue, R3>;
-    }, annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFailFrom"> : Class<Transformed, Fields & NewFields, I, R | Struct.Context<NewFields> | R2 | R3, C & Struct.Constructor<NewFields>, Self, Proto>;
+    }, annotations?: ClassAnnotations<Transformed, Simplify<Struct.Type<Fields & NewFields>>>) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFailFrom"> : Class<Transformed, Fields & NewFields, I, R | Struct.Context<NewFields> | R2 | R3, C & Struct.Constructor<NewFields>, Self, Proto>;
 }
 type HasFields<Fields extends Struct.Fields> = Struct<Fields> | {
     readonly [RefineSchemaId]: HasFields<Fields>;
@@ -4241,7 +4346,7 @@ type HasFields<Fields extends Struct.Fields> = Struct<Fields> | {
  * @category classes
  * @since 3.10.0
  */
-export declare const Class: <Self = never>(identifier: string) => <Fields extends Struct.Fields>(fieldsOr: Fields | HasFields<Fields>, annotations?: ClassAnnotations<Self, Struct.Type<Fields>>) => [Self] extends [never] ? MissingSelfGeneric<"Class"> : Class<Self, Fields, Struct.Encoded<Fields>, Struct.Context<Fields>, Struct.Constructor<Fields>, {}, {}>;
+export declare const Class: <Self = never>(identifier: string) => <Fields extends Struct.Fields>(fieldsOr: Fields | HasFields<Fields>, annotations?: ClassAnnotations<Self, Simplify<Struct.Type<Fields>>>) => [Self] extends [never] ? MissingSelfGeneric<"Class"> : Class<Self, Fields, Struct.Encoded<Fields>, Struct.Context<Fields>, Struct.Constructor<Fields>, {}, {}>;
 /**
  * @category api interface
  * @since 3.10.0
@@ -4262,9 +4367,9 @@ export interface TaggedClass<Self, Tag extends string, Fields extends Struct.Fie
  * @category classes
  * @since 3.10.0
  */
-export declare const TaggedClass: <Self = never>(identifier?: string) => <Tag extends string, Fields extends Struct.Fields>(tag: Tag, fieldsOr: Fields | HasFields<Fields>, annotations?: ClassAnnotations<Self, Struct.Type<{
+export declare const TaggedClass: <Self = never>(identifier?: string) => <Tag extends string, Fields extends Struct.Fields>(tag: Tag, fieldsOr: Fields | HasFields<Fields>, annotations?: ClassAnnotations<Self, Simplify<Struct.Type<{
     readonly _tag: tag<Tag>;
-} & Fields>>) => [Self] extends [never] ? MissingSelfGeneric<"TaggedClass", `"Tag", `> : TaggedClass<Self, Tag, {
+} & Fields>>>) => [Self] extends [never] ? MissingSelfGeneric<"TaggedClass", `"Tag", `> : TaggedClass<Self, Tag, {
     readonly _tag: tag<Tag>;
 } & Fields>;
 /**
@@ -4295,13 +4400,17 @@ export interface TaggedErrorClass<Self, Tag extends string, Fields extends Struc
  * @category classes
  * @since 3.10.0
  */
-export declare const TaggedError: <Self = never>(identifier?: string) => <Tag extends string, Fields extends Struct.Fields>(tag: Tag, fieldsOr: Fields | HasFields<Fields>, annotations?: ClassAnnotations<Self, Struct.Type<{
+export declare const TaggedError: <Self = never>(identifier?: string) => <Tag extends string, Fields extends Struct.Fields>(tag: Tag, fieldsOr: Fields | HasFields<Fields>, annotations?: ClassAnnotations<Self, Simplify<Struct.Type<{
     readonly _tag: tag<Tag>;
-} & Fields>>) => [Self] extends [never] ? MissingSelfGeneric<"TaggedError", `"Tag", `> : TaggedErrorClass<Self, Tag, {
+} & Fields>>>) => [Self] extends [never] ? MissingSelfGeneric<"TaggedError", `"Tag", `> : TaggedErrorClass<Self, Tag, {
     readonly _tag: tag<Tag>;
 } & Fields>;
-type MakeOptions = boolean | {
-    readonly disableValidation?: boolean;
+/**
+ * @category Constructor utils
+ * @since 3.13.4
+ */
+export type MakeOptions = boolean | {
+    readonly disableValidation?: boolean | undefined;
 };
 /**
  * @category FiberId
@@ -4318,7 +4427,7 @@ export type FiberIdEncoded = {
     readonly id: number;
     readonly startTimeMillis: number;
 };
-declare const FiberIdFromSelf_base: SchemaClass<fiberId_.FiberId, fiberId_.FiberId, never>;
+declare const FiberIdFromSelf_base: declare<fiberId_.FiberId, fiberId_.FiberId, readonly [], never>;
 /**
  * @category FiberId constructors
  * @since 3.10.0
@@ -4360,7 +4469,10 @@ export type CauseEncoded<E, D> = {
  * @category api interface
  * @since 3.10.0
  */
-export interface CauseFromSelf<E extends Schema.All, D extends Schema.All> extends AnnotableClass<CauseFromSelf<E, D>, cause_.Cause<Schema.Type<E>>, cause_.Cause<Schema.Encoded<E>>, Schema.Context<E> | Schema.Context<D>> {
+export interface CauseFromSelf<E extends Schema.All, D extends Schema.All> extends AnnotableDeclare<CauseFromSelf<E, D>, cause_.Cause<Schema.Type<E>>, cause_.Cause<Schema.Encoded<E>>, [
+    E,
+    D
+]> {
 }
 /**
  * @category Cause transformations
@@ -4374,7 +4486,7 @@ export declare const CauseFromSelf: <E extends Schema.All, D extends Schema.All>
  * @category api interface
  * @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>> {
+export interface Cause<E extends Schema.All, D extends Schema.All> extends 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>>>> {
 }
 /**
  * @category Cause transformations
@@ -4384,12 +4496,7 @@ export declare const Cause: <E extends Schema.All, D extends Schema.All>({ defec
     readonly error: E;
     readonly defect: D;
 }) => Cause<E, D>;
-/**
- * @category api interface
- * @since 3.10.0
- */
-export interface Defect extends transform<typeof Unknown, typeof Unknown> {
-}
+declare const Defect_base: 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`),
@@ -4403,7 +4510,8 @@ export interface Defect extends transform<typeof Unknown, typeof Unknown> {
  * @category defect
  * @since 3.10.0
  */
-export declare const Defect: Defect;
+export declare class Defect extends Defect_base {
+}
 /**
  * @category Exit utils
  * @since 3.10.0
@@ -4419,7 +4527,11 @@ export type ExitEncoded<A, E, D> = {
  * @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
+]> {
 }
 /**
  * @category Exit transformations
@@ -4434,7 +4546,16 @@ export declare const ExitFromSelf: <A extends Schema.All, E extends Schema.All,
  * @category api interface
  * @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>> {
+export interface Exit<A extends Schema.All, E extends Schema.All, D extends Schema.All> extends 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>>>> {
 }
 /**
  * @category Exit transformations
@@ -4449,7 +4570,9 @@ export declare const Exit: <A extends Schema.All, E extends Schema.All, D extend
  * @category api interface
  * @since 3.10.0
  */
-export interface HashSetFromSelf<Value extends Schema.Any> extends AnnotableClass<HashSetFromSelf<Value>, hashSet_.HashSet<Schema.Type<Value>>, hashSet_.HashSet<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface HashSetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<HashSetFromSelf<Value>, hashSet_.HashSet<Schema.Type<Value>>, hashSet_.HashSet<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category HashSet transformations
@@ -4460,18 +4583,21 @@ export declare const HashSetFromSelf: <Value extends Schema.Any>(value: Value) =
  * @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 declare const HashSet: <Value extends Schema.Any>(value: Value) => HashSet<Value>;
+export declare function HashSet<Value extends Schema.Any>(value: Value): HashSet<Value>;
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface HashMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableClass<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>> {
+export interface HashMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableDeclare<HashMapFromSelf<K, V>, hashMap_.HashMap<Schema.Type<K>, Schema.Type<V>>, hashMap_.HashMap<Schema.Encoded<K>, Schema.Encoded<V>>, [
+    K,
+    V
+]> {
 }
 /**
  * @category HashMap transformations
@@ -4485,7 +4611,7 @@ export declare const HashMapFromSelf: <K extends Schema.Any, V extends Schema.An
  * @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>>>> {
 }
 /**
  * @category HashMap transformations
@@ -4499,7 +4625,9 @@ export declare const HashMap: <K extends Schema.Any, V extends Schema.Any>({ key
  * @category api interface
  * @since 3.10.0
  */
-export interface ListFromSelf<Value extends Schema.Any> extends AnnotableClass<ListFromSelf<Value>, list_.List<Schema.Type<Value>>, list_.List<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface ListFromSelf<Value extends Schema.Any> extends AnnotableDeclare<ListFromSelf<Value>, list_.List<Schema.Type<Value>>, list_.List<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category List transformations
@@ -4510,18 +4638,20 @@ export declare const ListFromSelf: <Value extends Schema.Any>(value: Value) => L
  * @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 declare const List: <Value extends Schema.Any>(value: Value) => List<Value>;
+export declare function List<Value extends Schema.Any>(value: Value): List<Value>;
 /**
  * @category api interface
  * @since 3.10.0
  */
-export interface SortedSetFromSelf<Value extends Schema.Any> extends AnnotableClass<SortedSetFromSelf<Value>, sortedSet_.SortedSet<Schema.Type<Value>>, sortedSet_.SortedSet<Schema.Encoded<Value>>, Schema.Context<Value>> {
+export interface SortedSetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<SortedSetFromSelf<Value>, sortedSet_.SortedSet<Schema.Type<Value>>, sortedSet_.SortedSet<Schema.Encoded<Value>>, [
+    Value
+]> {
 }
 /**
  * @category SortedSet transformations
@@ -4532,13 +4662,13 @@ export declare const SortedSetFromSelf: <Value extends Schema.Any>(value: Value,
  * @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 declare const SortedSet: <Value extends Schema.Any>(value: Value, ordA: Order.Order<Schema.Type<Value>>) => SortedSet<Value>;
+export declare function SortedSet<Value extends Schema.Any>(value: Value, ordA: Order.Order<Schema.Type<Value>>): SortedSet<Value>;
 declare const BooleanFromUnknown_base: transform<typeof Unknown, typeof Boolean$>;
 /**
  * Converts an arbitrary value to a `boolean` by testing whether it is truthy.
@@ -4888,9 +5018,9 @@ export declare const TaggedRequest: <Self = never>(identifier?: string) => <Tag
     failure: Failure;
     success: Success;
     payload: Payload;
-}, annotations?: ClassAnnotations<Self, Struct.Type<{
+}, annotations?: ClassAnnotations<Self, Simplify<Struct.Type<{
     readonly _tag: tag<Tag>;
-} & Payload>>) => [Self] extends [never] ? MissingSelfGeneric<"TaggedRequest", `"Tag", SuccessSchema, FailureSchema, `> : TaggedRequestClass<Self, Tag, {
+} & Payload>>>) => [Self] extends [never] ? MissingSelfGeneric<"TaggedRequest", `"Tag", SuccessSchema, FailureSchema, `> : TaggedRequestClass<Self, Tag, {
     readonly _tag: tag<Tag>;
 } & Payload, Success, Failure>;
 /**