effect 3.13.9 → 3.13.11

package/dist/dts/Schema.d.ts

@@ -1207,11 +1207,30 @@ export declare const optionalWith: {
  * @since 3.10.0
  */
 export declare namespace Struct {
+    /**
+     * Useful for creating a type that can be used to add custom constraints to the fields of a struct.
+     *
+     * ```ts
+     * import { Schema } from "effect"
+     *
+     * const f = <Fields extends Record<"a" | "b", Schema.Struct.Field>>(
+     *   schema: Schema.Struct<Fields>
+     * ) => {
+     *   return schema.omit("a")
+     * }
+     *
+     * //      ┌─── Schema.Struct<{ b: typeof Schema.Number; }>
+     * //      ▼
+     * const result = f(Schema.Struct({ a: Schema.String, b: Schema.Number }))
+     * ```
+     * @since 3.13.11
+     */
+    type Field = Schema.All | PropertySignature.All;
     /**
      * @since 3.10.0
      */
     type Fields = {
-        readonly [x: PropertyKey]: Schema.All | PropertySignature.All;
+        readonly [x: PropertyKey]: Field;
     };
     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> = {
@@ -1274,22 +1293,23 @@ export declare namespace IndexSignature {
      * @since 3.10.0
      */
     type NonEmptyRecords = array_.NonEmptyReadonlyArray<Record>;
+    type MergeTuple<T extends ReadonlyArray<unknown>> = T extends readonly [infer Head, ...infer Tail] ? Head & MergeTuple<Tail> : {};
     /**
      * @since 3.10.0
      */
-    type Type<Records extends IndexSignature.Records> = Types.UnionToIntersection<{
-        [K in keyof Records]: {
+    type Type<Records extends IndexSignature.Records> = MergeTuple<{
+        readonly [K in keyof Records]: {
             readonly [P in Schema.Type<Records[K]["key"]>]: Schema.Type<Records[K]["value"]>;
         };
-    }[number]>;
+    }>;
     /**
      * @since 3.10.0
      */
-    type Encoded<Records extends IndexSignature.Records> = Types.UnionToIntersection<{
-        [K in keyof Records]: {
+    type Encoded<Records extends IndexSignature.Records> = MergeTuple<{
+        readonly [K in keyof Records]: {
             readonly [P in Schema.Encoded<Records[K]["key"]>]: Schema.Encoded<Records[K]["value"]>;
         };
-    }[number]>;
+    }>;
     /**
      * @since 3.10.0
      */
@@ -1319,9 +1339,7 @@ export declare namespace TypeLiteral {
  * @since 3.10.0
  */
 export interface TypeLiteral<Fields extends Struct.Fields, Records extends IndexSignature.Records> extends AnnotableClass<TypeLiteral<Fields, Records>, Simplify<TypeLiteral.Type<Fields, Records>>, Simplify<TypeLiteral.Encoded<Fields, Records>>, Struct.Context<Fields> | IndexSignature.Context<Records>> {
-    readonly fields: {
-        readonly [K in keyof Fields]: Fields[K];
-    };
+    readonly fields: Readonly<Fields>;
     readonly records: Readonly<Records>;
     annotations(annotations: Annotations.Schema<Simplify<TypeLiteral.Type<Fields, Records>>>): TypeLiteral<Fields, Records>;
     make(props: RequiredKeys<TypeLiteral.Constructor<Fields, Records>> extends never ? void | Simplify<TypeLiteral.Constructor<Fields, Records>> : Simplify<TypeLiteral.Constructor<Fields, Records>>, options?: MakeOptions): Simplify<TypeLiteral.Type<Fields, Records>>;
@@ -1330,7 +1348,10 @@ export interface TypeLiteral<Fields extends Struct.Fields, Records extends Index
  * @category api interface
  * @since 3.10.0
  */
-export interface Struct<Fields extends Struct.Fields> extends TypeLiteral<Fields, []> {
+export interface Struct<Fields extends Struct.Fields> extends AnnotableClass<Struct<Fields>, Simplify<Struct.Type<Fields>>, Simplify<Struct.Encoded<Fields>>, Struct.Context<Fields>> {
+    readonly fields: Readonly<Fields>;
+    readonly records: readonly [];
+    make(props: RequiredKeys<Struct.Constructor<Fields>> extends never ? void | Simplify<Struct.Constructor<Fields>> : Simplify<Struct.Constructor<Fields>>, options?: MakeOptions): Simplify<Struct.Type<Fields>>;
     annotations(annotations: Annotations.Schema<Simplify<Struct.Type<Fields>>>): Struct<Fields>;
     pick<Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys): Struct<Simplify<Pick<Fields, Keys[number]>>>;
     omit<Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys): Struct<Simplify<Omit<Fields, Keys[number]>>>;
@@ -1352,8 +1373,6 @@ export interface tag<Tag extends AST.LiteralValue> extends PropertySignature<":"
  * A tag is a literal value that is used to distinguish between different types of objects.
  * The tag is optional when using the `make` method.
  *
- * @see {@link TaggedStruct}
- *
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -1368,6 +1387,8 @@ export interface tag<Tag extends AST.LiteralValue> extends PropertySignature<":"
  * assert.deepStrictEqual(User.make({ name: "John", age: 44 }), { _tag: "User", name: "John", age: 44 })
  * ```
  *
+ * @see {@link TaggedStruct}
+ *
  * @since 3.10.0
  */
 export declare const tag: <Tag extends AST.LiteralValue>(tag: Tag) => tag<Tag>;
@@ -1404,16 +1425,26 @@ export declare const TaggedStruct: <Tag extends AST.LiteralValue, Fields extends
  * @category api interface
  * @since 3.10.0
  */
-export interface Record$<K extends Schema.All, V extends Schema.All> extends TypeLiteral<{}, [{
-    key: K;
-    value: V;
-}]> {
+export interface Record$<K extends Schema.All, V extends Schema.All> extends AnnotableClass<Record$<K, V>, {
+    readonly [P in Schema.Type<K>]: Schema.Type<V>;
+}, {
+    readonly [P in Schema.Encoded<K>]: Schema.Encoded<V>;
+}, Schema.Context<K> | Schema.Context<V>> {
+    readonly fields: {};
+    readonly records: readonly [{
+        readonly key: K;
+        readonly value: V;
+    }];
     readonly key: K;
     readonly value: V;
-    annotations(annotations: Annotations.Schema<Simplify<TypeLiteral.Type<{}, [{
-        key: K;
-        value: V;
-    }]>>>): Record$<K, V>;
+    make(props: void | {
+        readonly [P in Schema.Type<K>]: Schema.Type<V>;
+    }, options?: MakeOptions): {
+        readonly [P in Schema.Type<K>]: Schema.Type<V>;
+    };
+    annotations(annotations: Annotations.Schema<{
+        readonly [P in Schema.Type<K>]: Schema.Type<V>;
+    }>): Record$<K, V>;
 }
 /**
  * @category constructors
@@ -4681,6 +4712,7 @@ declare const BooleanFromUnknown_base: transform<typeof Unknown, typeof Boolean$
  * Uses `!!val` to coerce the value to a `boolean`.
  *
  * @see https://developer.mozilla.org/docs/Glossary/Truthy
+ *
  * @category boolean constructors
  * @since 3.10.0
  */