effect 4.0.0-beta.35 → 4.0.0-beta.37

package/dist/Schema.d.ts

@@ -527,9 +527,7 @@ export declare namespace Codec {
      *
      * @since 4.0.0
      */
-    type ToAsserts<S extends Top & {
-        readonly DecodingServices: never;
-    }> = <I>(input: I) => asserts input is I & S["Type"];
+    type ToAsserts<S extends Top> = <I>(input: I) => asserts input is I & S["Type"];
 }
 /**
  * A schema that additionally supports optic (lens/prism) operations.
@@ -776,9 +774,7 @@ export declare function isSchemaError(u: unknown): u is SchemaError;
  * @category Standard Schema
  * @since 4.0.0
  */
-export declare function toStandardSchemaV1<S extends Top & {
-    readonly DecodingServices: never;
-}>(self: S, options?: {
+export declare function toStandardSchemaV1<S extends Decoder<unknown>>(self: S, options?: {
     readonly leafHook?: Issue.LeafHook | undefined;
     readonly checkHook?: Issue.CheckHook | undefined;
     readonly parseOptions?: AST.ParseOptions | undefined;
@@ -890,9 +886,7 @@ export declare const decodeEffect: <S extends Top>(schema: S) => (input: S["Enco
  * @category Decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownExit<S extends Top & {
-    readonly DecodingServices: never;
-}>(schema: S): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
  * synchronously, returning an `Exit` that is either a `Success` with the
@@ -903,9 +897,7 @@ export declare function decodeUnknownExit<S extends Top & {
  * @category Decoding
  * @since 4.0.0
  */
-export declare const decodeExit: <S extends Top & {
-    readonly DecodingServices: never;
-}>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare const decodeExit: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
 /**
  * Decodes an `unknown` input against a schema, returning an `Option` that is
  * `Some` with the decoded value on success or `None` on failure. Prefer this
@@ -925,9 +917,7 @@ export declare const decodeUnknownOption: typeof Parser.decodeUnknownOption;
  * @category Decoding
  * @since 4.0.0
  */
-export declare const decodeOption: <S extends Top & {
-    readonly DecodingServices: never;
-}>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Option_.Option<S["Type"]>;
+export declare const decodeOption: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Option_.Option<S["Type"]>;
 /**
  * Decodes an `unknown` input against a schema, returning a `Promise` that
  * resolves with the decoded value or rejects with a {@link SchemaError}. Useful
@@ -937,6 +927,16 @@ export declare const decodeOption: <S extends Top & {
  * @category Decoding
  * @since 4.0.0
  */
+export declare const decodeUnknownResult: typeof Parser.decodeUnknownResult;
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export declare const decodeResult: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Result_.Result<S["Type"], Issue.Issue>;
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
 export declare const decodeUnknownPromise: typeof Parser.decodeUnknownPromise;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
@@ -984,9 +984,7 @@ export declare const decodeUnknownSync: typeof Parser.decodeUnknownSync;
  * @category Decoding
  * @since 4.0.0
  */
-export declare const decodeSync: <S extends Top & {
-    readonly DecodingServices: never;
-}>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"];
+export declare const decodeSync: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"];
 /**
  * Encodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the encoded value or fails with a {@link SchemaError}. Use this
@@ -1028,9 +1026,7 @@ export declare const encodeEffect: <S extends Top>(schema: S) => (input: S["Type
  * @category Encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownExit<S extends Top & {
-    readonly EncodingServices: never;
-}>(schema: S): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * returning an `Exit` that is either a `Success` with the encoded value or a
@@ -1041,9 +1037,7 @@ export declare function encodeUnknownExit<S extends Top & {
  * @category Encoding
  * @since 4.0.0
  */
-export declare const encodeExit: <S extends Top & {
-    readonly EncodingServices: never;
-}>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare const encodeExit: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
 /**
  * Encodes an `unknown` input against a schema, returning an `Option` that is
  * `Some` with the encoded value on success or `None` on failure. Prefer this
@@ -1063,9 +1057,7 @@ export declare const encodeUnknownOption: typeof Parser.encodeUnknownOption;
  * @category Encoding
  * @since 4.0.0
  */
-export declare const encodeOption: <S extends Top & {
-    readonly EncodingServices: never;
-}>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Option_.Option<S["Encoded"]>;
+export declare const encodeOption: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Option_.Option<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema, returning a `Promise` that
  * resolves with the encoded value or rejects with a {@link SchemaError}. Useful
@@ -1075,9 +1067,17 @@ export declare const encodeOption: <S extends Top & {
  * @category Encoding
  * @since 4.0.0
  */
-export declare const encodeUnknownPromise: <S extends Top & {
-    readonly EncodingServices: never;
-}>(schema: S) => (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]>;
+export declare const encodeUnknownResult: typeof Parser.encodeUnknownResult;
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export declare const encodeResult: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Result_.Result<S["Encoded"], Issue.Issue>;
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export declare const encodeUnknownPromise: <S extends Encoder<unknown>>(schema: S) => (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
  * `Promise` that resolves with the encoded value or rejects with a
@@ -1086,9 +1086,7 @@ export declare const encodeUnknownPromise: <S extends Top & {
  * @category Encoding
  * @since 4.0.0
  */
-export declare const encodePromise: <S extends Top & {
-    readonly EncodingServices: never;
-}>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]>;
+export declare const encodePromise: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema synchronously, throwing a
  * {@link SchemaError} on failure. Use this when you want to serialize data at a
@@ -1109,9 +1107,7 @@ export declare const encodeUnknownSync: typeof Parser.encodeUnknownSync;
  * @category Encoding
  * @since 4.0.0
  */
-export declare const encodeSync: <S extends Top & {
-    readonly EncodingServices: never;
-}>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"];
+export declare const encodeSync: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"];
 /**
  * Creates a schema from an AST (Abstract Syntax Tree) node.
  *
@@ -1756,7 +1752,7 @@ export declare namespace Struct {
     /**
      * @since 4.0.0
      */
-    type Type<F extends Fields> = Type_<F>;
+    type Type<F extends Fields> = Simplify<Type_<F>>;
     type Iso_<F extends Fields, O extends keyof F = TypeOptionalKeys<F>, M extends keyof F = TypeMutableKeys<F>> = {
         readonly [K in Exclude<keyof F, M | O>]: F[K]["Iso"];
     } & {
@@ -1769,7 +1765,7 @@ export declare namespace Struct {
     /**
      * @since 4.0.0
      */
-    type Iso<F extends Fields> = Iso_<F>;
+    type Iso<F extends Fields> = Simplify<Iso_<F>>;
     type EncodedOptionalKeys<Fields extends Struct.Fields> = {
         [K in keyof Fields]: Fields[K] extends {
             readonly "~encoded.optionality": "optional";
@@ -1792,7 +1788,7 @@ export declare namespace Struct {
     /**
      * @since 4.0.0
      */
-    type Encoded<F extends Fields> = Encoded_<F>;
+    type Encoded<F extends Fields> = Simplify<Encoded_<F>>;
     /**
      * @since 4.0.0
      */
@@ -1818,12 +1814,12 @@ export declare namespace Struct {
     /**
      * @since 4.0.0
      */
-    type MakeIn<F extends Fields> = MakeIn_<F>;
+    type MakeIn<F extends Fields> = Simplify<MakeIn_<F>>;
 }
 /**
  * @since 4.0.0
  */
-export interface Struct<Fields extends Struct.Fields> extends Bottom<Simplify<Struct.Type<Fields>>, Simplify<Struct.Encoded<Fields>>, Struct.DecodingServices<Fields>, Struct.EncodingServices<Fields>, AST.Objects, Struct<Fields>, Simplify<Struct.MakeIn<Fields>>, Simplify<Struct.Iso<Fields>>> {
+export interface Struct<Fields extends Struct.Fields> extends Bottom<Struct.Type<Fields>, Struct.Encoded<Fields>, Struct.DecodingServices<Fields>, Struct.EncodingServices<Fields>, AST.Objects, Struct<Fields>, Struct.MakeIn<Fields>, Struct.Iso<Fields>> {
     readonly "~rebuild.out": this;
     /**
      * The field definitions of this struct. Spread them into a new struct to