effect 4.0.6 → 4.1.0

package/dist/Schema.d.ts

@@ -17,6 +17,13 @@ import type * as Brand from "./Brand.ts";
 import * as ByteSize_ from "./ByteSize.ts";
 import * as Cause_ from "./Cause.ts";
 import * as Chunk_ from "./Chunk.ts";
+import * as Aead_ from "./crypto/Aead.ts";
+import * as Cipher_ from "./crypto/Cipher.ts";
+import * as KeyAgreement_ from "./crypto/KeyAgreement.ts";
+import * as KeyFormat_ from "./crypto/KeyFormat.ts";
+import * as KeyWrap_ from "./crypto/KeyWrap.ts";
+import * as Mac_ from "./crypto/Mac.ts";
+import * as Signature_ from "./crypto/Signature.ts";
 import * as DateTime from "./DateTime.ts";
 import type { Differ } from "./Differ.ts";
 import * as Duration_ from "./Duration.ts";
@@ -3315,11 +3322,18 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  *
  * **Gotchas**
  *
+ * Dynamic records reject value schemas wrapped with {@link optionalKey} or
+ * {@link optional}. Index signatures already allow keys to be absent; use
+ * {@link UndefinedOr} when existing entries may contain `undefined`. Optional
+ * value schemas remain valid for finite literal keys, which become declared
+ * properties.
+ *
  * When decoded or encoded key transformations produce the same property key,
  * sequential parsing applies selected own properties in selection order, so
  * the later selected property overwrites the earlier value. Dynamic key
- * selection always examines own properties. Finite literal keys are declared
- * fields and may therefore be inherited. Output key order is not guaranteed.
+ * selection always examines own properties. Finite literal and enum keys are
+ * declared fields and may therefore be inherited. Output key order is not
+ * guaranteed.
  *
  * **Example** (Defining a string-keyed record of numbers)
  *
@@ -5151,7 +5165,27 @@ type Flatten<Schemas> = Schemas extends readonly [infer Head, ...infer Tail] ? H
 type MatchCasesResult<Cases> = {
     [K in keyof Cases]-?: NonNullable<Cases[K]> extends (...args: Array<any>) => infer R ? R : never;
 }[keyof Cases];
-type MatchOrElseResult<Cases, OrElse extends (...args: Array<any>) => any> = Unify<MatchCasesResult<Cases> | ReturnType<OrElse>>;
+type MatchOrElseResult<Cases, OrElse> = Unify<MatchCasesResult<Cases> | (OrElse extends (...args: Array<any>) => infer R ? R : never)>;
+type TaggedUnionMatch<Cases extends Record<PropertyKey, Constraint>, Value> = {
+    <Handlers extends {
+        [K in keyof Cases]: (value: Cases[K]["Type"]) => any;
+    }>(value: Value, cases: Handlers): Unify<ReturnType<Handlers[keyof Cases]>>;
+    <Handlers extends {
+        [K in keyof Cases]: (value: Cases[K]["Type"]) => any;
+    }>(cases: Handlers): (value: Value) => Unify<ReturnType<Handlers[keyof Cases]>>;
+};
+type TaggedUnionMatchOrElse<Cases extends Record<PropertyKey, Constraint>, Value, Tag extends PropertyKey> = {
+    <Handlers, OrElse>(value: Value, cases: Handlers & {
+        [K in keyof Cases]?: (value: Cases[K]["Type"]) => any;
+    } & (Exclude<keyof Handlers, keyof Cases> extends never ? unknown : never), orElse: OrElse & ((value: Exclude<Value, {
+        readonly [K in Tag]: keyof Handlers;
+    }>) => any)): MatchOrElseResult<Handlers, OrElse>;
+    <Handlers, OrElse>(cases: Handlers & {
+        [K in keyof Cases]?: (value: Cases[K]["Type"]) => any;
+    } & (Exclude<keyof Handlers, keyof Cases> extends never ? unknown : never), orElse: OrElse & ((value: Exclude<Value, {
+        readonly [K in Tag]: keyof Handlers;
+    }>) => any)): (value: Value) => MatchOrElseResult<Handlers, OrElse>;
+};
 type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Constraint & {
     readonly Type: {
         readonly [K in Tag]: PropertyKey;
@@ -5180,30 +5214,12 @@ type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Con
     readonly guards: {
         [M in Flattened[number] as M["Type"][Tag]]: (u: unknown) => u is M["Type"];
     };
-    readonly match: {
-        <Cases extends {
-            [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => any;
-        }>(value: Members[number]["Type"], cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? Unify<R> : never;
-        <Cases extends {
-            [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => any;
-        }>(cases: Cases): (value: Members[number]["Type"]) => Cases[keyof Cases] extends (value: any) => infer R ? Unify<R> : never;
-    };
-    readonly matchOrElse: {
-        <Cases extends {
-            [M in Flattened[number] as M["Type"][Tag]]+?: (value: M["Type"]) => any;
-        } & {
-            [K in Exclude<keyof Cases, Flattened[number]["Type"][Tag]>]: never;
-        }, OrElse extends (value: Exclude<Members[number]["Type"], {
-            readonly [K in Tag]: keyof Cases;
-        }>) => any>(value: Members[number]["Type"], cases: Cases, orElse: OrElse): MatchOrElseResult<Cases, OrElse>;
-        <Cases extends {
-            [M in Flattened[number] as M["Type"][Tag]]+?: (value: M["Type"]) => any;
-        } & {
-            [K in Exclude<keyof Cases, Flattened[number]["Type"][Tag]>]: never;
-        }, OrElse extends (value: Exclude<Members[number]["Type"], {
-            readonly [K in Tag]: keyof Cases;
-        }>) => any>(cases: Cases, orElse: OrElse): (value: Members[number]["Type"]) => MatchOrElseResult<Cases, OrElse>;
-    };
+    readonly match: TaggedUnionMatch<{
+        readonly [M in Flattened[number] as M["Type"][Tag]]: M;
+    }, Members[number]["Type"]>;
+    readonly matchOrElse: TaggedUnionMatchOrElse<{
+        readonly [M in Flattened[number] as M["Type"][Tag]]: M;
+    }, Members[number]["Type"], Tag>;
 };
 /**
  * Type-level representation returned by {@link toTaggedUnion}.
@@ -5290,22 +5306,8 @@ export interface TaggedUnion<Cases extends Record<string, Constraint>> extends B
     readonly guards: {
         [K in keyof Cases]: (u: unknown) => u is Cases[K]["Type"];
     };
-    readonly match: {
-        <Output>(cases: {
-            [K in keyof Cases]: (value: Cases[K]["Type"]) => Output;
-        }): (value: Cases[keyof Cases]["Type"]) => Output;
-        <Output>(value: Cases[keyof Cases]["Type"], cases: {
-            [K in keyof Cases]: (value: Cases[K]["Type"]) => Output;
-        }): Output;
-    };
-    readonly matchOrElse: {
-        <Output>(value: Cases[keyof Cases]["Type"], cases: {
-            [K in keyof Cases]?: (value: Cases[K]["Type"]) => Output;
-        }, orElse: (value: Cases[keyof Cases]["Type"]) => Output): Output;
-        <Output>(cases: {
-            [K in keyof Cases]?: (value: Cases[K]["Type"]) => Output;
-        }, orElse: (value: Cases[keyof Cases]["Type"]) => Output): (value: Cases[keyof Cases]["Type"]) => Output;
-    };
+    readonly match: TaggedUnionMatch<Cases, Cases[keyof Cases]["Type"]>;
+    readonly matchOrElse: TaggedUnionMatchOrElse<Cases, Cases[keyof Cases]["Type"], "_tag">;
 }
 /**
  * Builds a discriminated union from a record of field sets, one per variant.
@@ -5451,9 +5453,8 @@ export declare function link<T>(): <To extends Constraint>(encodeTo: To, transfo
  * )
  *
  * const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
- * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
- *   result.failure.issue.issue.path // => ["password"]
- * }
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "password and confirmPassword must match\n  at [\"password\"]"
  * ```
  *
  * **Example** (Reporting multiple failures at once)
@@ -5473,9 +5474,8 @@ export declare function link<T>(): <To extends Constraint>(encodeTo: To, transfo
  * )
  *
  * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
- * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
- *   result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
- * }
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "b must be greater than 0\n  at [\"b\"]\nc must be greater than 0\n  at [\"c\"]"
  * ```
  *
  * @stability stable
@@ -5699,6 +5699,9 @@ export declare function isGUID(annotations?: Annotations.Filter): SchemaAST.Filt
  *
  * **Details**
  *
+ * Accepts uppercase and lowercase characters. The first character must be
+ * between `0` and `7` so the value fits in 128 bits.
+ *
  * JSON Schema:
  *
  * This check corresponds to a `pattern` constraint in JSON Schema that matches
@@ -5714,6 +5717,35 @@ export declare function isGUID(annotations?: Annotations.Filter): SchemaAST.Filt
  * @since 4.0.0
  */
 export declare function isULID(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
+/**
+ * Validates that a string contains only ASCII characters.
+ *
+ * **When to use**
+ *
+ * Use when a value must stay within the 7-bit ASCII range, for example
+ * identifiers, protocol tokens, or data sent to systems that reject
+ * non-ASCII input.
+ *
+ * **Details**
+ *
+ * This check accepts strings whose characters are all in the range `U+0000`
+ * to `U+007F`, including control characters and the empty string.
+ *
+ * JSON Schema:
+ *
+ * This check corresponds to a `pattern` constraint in JSON Schema that matches
+ * ASCII-only strings.
+ *
+ * Arbitrary:
+ *
+ * During arbitrary generation, this applies a `patterns`
+ * constraint to ensure generated strings match the ASCII pattern.
+ *
+ * @stability unstable
+ * @category validation
+ * @since 4.0.6
+ */
+export declare function isAscii(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string is valid Base64 encoded data.
  *
@@ -9868,6 +9900,38 @@ export interface DurationFromMillis extends decodeTo<Duration, Number> {
  * @since 3.10.0
  */
 export declare const DurationFromMillis: DurationFromMillis;
+/**
+ * Type-level representation of {@link DurationFromIsoString}.
+ *
+ * @stability stable
+ * @category models
+ * @since 4.1.0
+ */
+export interface DurationFromIsoString extends decodeTo<Duration, String> {
+    readonly "Rebuild": DurationFromIsoString;
+}
+/**
+ * Schema that decodes an ISO 8601 duration string into a `Duration`.
+ *
+ * **Details**
+ *
+ * Decoding:
+ * - A string accepted by `Duration.fromIso` is decoded as a `Duration`, such
+ *   as `"PT1H30M"`, `"P1W2D"`, or `"-PT0.5S"`. Years and months are rejected
+ *   because they have no fixed length.
+ *
+ * Encoding:
+ * - A finite `Duration` is encoded with `Duration.formatIso`, using days,
+ *   hours, minutes, and seconds. Encoding fails for `Duration.infinity` and
+ *   `Duration.negativeInfinity`.
+ *
+ * @see {@link DurationFromString} for the `"5 seconds"` string format
+ *
+ * @stability stable
+ * @category schemas
+ * @since 4.1.0
+ */
+export declare const DurationFromIsoString: DurationFromIsoString;
 /**
  * Type-level representation of {@link DnsRecordType}.
  *
@@ -10146,6 +10210,575 @@ export interface DnsRecord extends Union<readonly [
  * @since 4.0.0
  */
 export declare const DnsRecord: DnsRecord;
+type CryptoKeyOptions = {
+    readonly allowEncode?: boolean | undefined;
+};
+/**
+ * Type-level representation of {@link MacKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface MacKey<A extends Mac_.Algorithm = Mac_.Algorithm> extends declare<Mac_.Key<A>> {
+    readonly "Rebuild": MacKey<A>;
+}
+/**
+ * Schema for live `Mac.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link MacKeyFromFormat} or {@link MacKeyFromBytes} to read and write keys.
+ * Keys display redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const MacKey: <A extends Mac_.Algorithm>(algorithm: A) => MacKey<A>;
+/**
+ * Schema that decodes raw key bytes into a `Mac.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Mac.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * **Example** (Reading an HMAC key from the environment)
+ *
+ * ```ts import.meta.vitest
+ * import { Config, ConfigProvider, Effect, Schema } from "effect"
+ * import { Mac } from "effect/crypto"
+ *
+ * const config = Config.schema(Schema.MacKeyFromBytes(Mac.hmacSha256), "HMAC_KEY")
+ * const provider = ConfigProvider.fromEnv({ env: { HMAC_KEY: "A".repeat(43) + "=" } })
+ * const key = await Effect.runPromise(Effect.provide(config, ConfigProvider.layer(provider)))
+ * key.algorithm.name // => "hmacSha256"
+ * ```
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const MacKeyFromBytes: <A extends Mac_.Algorithm>(algorithm: A, options?: CryptoKeyOptions) => decodeTo<MacKey<A>, Uint8Array>;
+/**
+ * Schema that decodes a `Mac.Key` from a JWK with `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const MacKeyFromFormat: <A extends Mac_.Algorithm, Data>(format: KeyFormat_.Format<"secret", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<MacKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link AeadKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface AeadKey<A extends Aead_.Algorithm = Aead_.Algorithm> extends declare<Aead_.Key<A>> {
+    readonly "Rebuild": AeadKey<A>;
+}
+/**
+ * Schema for live `Aead.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link AeadKeyFromFormat} or {@link AeadKeyFromBytes} to read and write
+ * keys. Keys display redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const AeadKey: <A extends Aead_.Algorithm>(algorithm: A) => AeadKey<A>;
+/**
+ * Schema that decodes raw key bytes into an `Aead.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Aead.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const AeadKeyFromBytes: <A extends Aead_.Algorithm>(algorithm: A, options?: CryptoKeyOptions) => decodeTo<AeadKey<A>, Uint8Array>;
+/**
+ * Schema that decodes an `Aead.Key` from a JWK with `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const AeadKeyFromFormat: <A extends Aead_.Algorithm, Data>(format: KeyFormat_.Format<"secret", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<AeadKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link CipherKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface CipherKey<A extends Cipher_.Algorithm = Cipher_.Algorithm> extends declare<Cipher_.Key<A>> {
+    readonly "Rebuild": CipherKey<A>;
+}
+/**
+ * Schema for live `Cipher.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link CipherKeyFromFormat} or {@link CipherKeyFromBytes} to read and
+ * write keys. Keys display redacted, compare by reference, and have no
+ * `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const CipherKey: <A extends Cipher_.Algorithm>(algorithm: A) => CipherKey<A>;
+/**
+ * Schema that decodes raw key bytes into a `Cipher.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Cipher.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const CipherKeyFromBytes: <A extends Cipher_.Algorithm>(algorithm: A, options?: CryptoKeyOptions) => decodeTo<CipherKey<A>, Uint8Array>;
+/**
+ * Schema that decodes a `Cipher.Key` from a JWK with
+ * `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const CipherKeyFromFormat: <A extends Cipher_.Algorithm, Data>(format: KeyFormat_.Format<"secret", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<CipherKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link SignaturePublicKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface SignaturePublicKey<A extends Signature_.Algorithm = Signature_.Algorithm> extends declare<Signature_.PublicKey<A>> {
+    readonly "Rebuild": SignaturePublicKey<A>;
+}
+/**
+ * Schema for live `Signature.PublicKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link SignaturePublicKeyFromFormat} or {@link SignaturePublicKeyFromBytes}
+ * to read and write keys. Keys compare by reference and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const SignaturePublicKey: <A extends Signature_.Algorithm>(algorithm: A) => SignaturePublicKey<A>;
+/**
+ * Schema that decodes a raw public key into a `Signature.PublicKey`: 32 bytes
+ * for Ed25519, or an uncompressed SEC1 point for ECDSA.
+ *
+ * **Details**
+ *
+ * Decoding runs `Signature.publicKey`, which is synchronous, so the schema
+ * works with `Schema.decodeSync`. Under `Config.schema` the bytes are read as
+ * base64. A `CryptoError` becomes an `InvalidValue` issue whose `cause` is
+ * the error. RSA public keys have no raw form, so passing an RSA algorithm is
+ * a type error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const SignaturePublicKeyFromBytes: <A extends Signature_.Ed25519 | Signature_.Ecdsa>(algorithm: A) => decodeTo<SignaturePublicKey<A>, Uint8Array>;
+/**
+ * Schema that decodes a `Signature.PublicKey` with
+ * `KeyFormat.decodePublic` and encodes it with `KeyFormat.encode`.
+ *
+ * **Details**
+ *
+ * The format must hold public keys: `KeyFormat.spki`, `KeyFormat.jwk`, or
+ * `KeyFormat.pem(KeyFormat.spki)`. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const SignaturePublicKeyFromFormat: <A extends Signature_.Algorithm, Data>(format: KeyFormat_.Format<"public", "decode", Data>, algorithm: A) => decodeTo<SignaturePublicKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link SignaturePrivateKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface SignaturePrivateKey<A extends Signature_.Algorithm = Signature_.Algorithm> extends declare<Signature_.PrivateKey<A>> {
+    readonly "Rebuild": SignaturePrivateKey<A>;
+}
+/**
+ * Schema for live `Signature.PrivateKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link SignaturePrivateKeyFromFormat} or
+ * {@link SignaturePrivateKeyFromBytes} to read and write keys. Keys display
+ * redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const SignaturePrivateKey: <A extends Signature_.Algorithm>(algorithm: A) => SignaturePrivateKey<A>;
+/**
+ * Schema that decodes an Ed25519 seed into a `Signature.PrivateKey`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Signature.privateKey`, which is synchronous, so the schema
+ * works with `Schema.decodeSync`. Under `Config.schema` the bytes are read as
+ * base64. A `CryptoError` becomes an `InvalidValue` issue whose `cause` is
+ * the error. ECDSA and RSA private keys have no raw form, so passing them is
+ * a type error. Encoding fails with a `Forbidden` issue unless `allowEncode`
+ * is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const SignaturePrivateKeyFromBytes: <A extends Signature_.Ed25519>(algorithm: A, options?: CryptoKeyOptions) => decodeTo<SignaturePrivateKey<A>, Uint8Array>;
+/**
+ * Schema that decodes a `Signature.PrivateKey` with
+ * `KeyFormat.decodePrivate`.
+ *
+ * **Details**
+ *
+ * The format must hold private keys: `KeyFormat.pkcs8`, `KeyFormat.jwk`,
+ * `KeyFormat.pkcs1`, `KeyFormat.sec1`, or their PEM forms. A format for
+ * another role is a type error. Decoding runs the runtime's key import, so
+ * use the async decoding functions: `Schema.decodeSync` throws. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`,
+ * and always for the read-only PKCS#1 and SEC1 formats.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const SignaturePrivateKeyFromFormat: <A extends Signature_.Algorithm, Data>(format: KeyFormat_.Format<"private", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<SignaturePrivateKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link KeyAgreementPublicKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface KeyAgreementPublicKey<A extends KeyAgreement_.Algorithm = KeyAgreement_.Algorithm> extends declare<KeyAgreement_.PublicKey<A>> {
+    readonly "Rebuild": KeyAgreementPublicKey<A>;
+}
+/**
+ * Schema for live `KeyAgreement.PublicKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyAgreementPublicKeyFromFormat} or
+ * {@link KeyAgreementPublicKeyFromBytes} to read and write keys. Keys compare
+ * by reference and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyAgreementPublicKey: <A extends KeyAgreement_.Algorithm>(algorithm: A) => KeyAgreementPublicKey<A>;
+/**
+ * Schema that decodes a raw public key into a `KeyAgreement.PublicKey`: 32
+ * bytes for X25519, or an uncompressed SEC1 point for ECDH.
+ *
+ * **Details**
+ *
+ * Decoding runs `KeyAgreement.publicKey`, which is synchronous, so the schema
+ * works with `Schema.decodeSync`. Under `Config.schema` the bytes are read as
+ * base64. A `CryptoError` becomes an `InvalidValue` issue whose `cause` is
+ * the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyAgreementPublicKeyFromBytes: <A extends KeyAgreement_.Algorithm>(algorithm: A) => decodeTo<KeyAgreementPublicKey<A>, Uint8Array>;
+/**
+ * Schema that decodes a `KeyAgreement.PublicKey` with
+ * `KeyFormat.decodePublic` and encodes it with `KeyFormat.encode`.
+ *
+ * **Details**
+ *
+ * The format must hold public keys: `KeyFormat.spki`, `KeyFormat.jwk`, or
+ * `KeyFormat.pem(KeyFormat.spki)`. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyAgreementPublicKeyFromFormat: <A extends KeyAgreement_.Algorithm, Data>(format: KeyFormat_.Format<"public", "decode", Data>, algorithm: A) => decodeTo<KeyAgreementPublicKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link KeyAgreementPrivateKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface KeyAgreementPrivateKey<A extends KeyAgreement_.Algorithm = KeyAgreement_.Algorithm> extends declare<KeyAgreement_.PrivateKey<A>> {
+    readonly "Rebuild": KeyAgreementPrivateKey<A>;
+}
+/**
+ * Schema for live `KeyAgreement.PrivateKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyAgreementPrivateKeyFromFormat} or
+ * {@link KeyAgreementPrivateKeyFromBytes} to read and write keys. Keys
+ * display redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyAgreementPrivateKey: <A extends KeyAgreement_.Algorithm>(algorithm: A) => KeyAgreementPrivateKey<A>;
+/**
+ * Schema that decodes an X25519 private key into a
+ * `KeyAgreement.PrivateKey`.
+ *
+ * **Details**
+ *
+ * Decoding runs `KeyAgreement.privateKey`, which is synchronous, so the
+ * schema works with `Schema.decodeSync`. Under `Config.schema` the bytes are
+ * read as base64. A `CryptoError` becomes an `InvalidValue` issue whose
+ * `cause` is the error. ECDH private keys have no raw form, so passing them
+ * is a type error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyAgreementPrivateKeyFromBytes: <A extends KeyAgreement_.X25519>(algorithm: A, options?: CryptoKeyOptions) => decodeTo<KeyAgreementPrivateKey<A>, Uint8Array>;
+/**
+ * Schema that decodes a `KeyAgreement.PrivateKey` with
+ * `KeyFormat.decodePrivate`.
+ *
+ * **Details**
+ *
+ * The format must hold private keys: `KeyFormat.pkcs8`, `KeyFormat.jwk`,
+ * `KeyFormat.sec1`, or their PEM forms. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error. Encoding fails with a
+ * `Forbidden` issue unless `allowEncode` is `true`, and always for the
+ * read-only PKCS#1 and SEC1 formats.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyAgreementPrivateKeyFromFormat: <A extends KeyAgreement_.Algorithm, Data>(format: KeyFormat_.Format<"private", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<KeyAgreementPrivateKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link KeyWrapKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface KeyWrapKey<A extends KeyWrap_.AesKw = KeyWrap_.AesKw> extends declare<KeyWrap_.Key<A>> {
+    readonly "Rebuild": KeyWrapKey<A>;
+}
+/**
+ * Schema for live AES-KW `KeyWrap.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyWrapKeyFromFormat} or {@link KeyWrapKeyFromBytes} to read and
+ * write keys. Keys display redacted, compare by reference, and have no
+ * `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapKey: <A extends KeyWrap_.AesKw>(algorithm: A) => KeyWrapKey<A>;
+/**
+ * Schema that decodes raw key bytes into an AES-KW `KeyWrap.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `KeyWrap.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapKeyFromBytes: <A extends KeyWrap_.AesKw>(algorithm: A, options?: CryptoKeyOptions) => decodeTo<KeyWrapKey<A>, Uint8Array>;
+/**
+ * Schema that decodes an AES-KW `KeyWrap.Key` from a JWK with
+ * `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapKeyFromFormat: <A extends KeyWrap_.AesKw, Data>(format: KeyFormat_.Format<"secret", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<KeyWrapKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link KeyWrapPublicKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface KeyWrapPublicKey<A extends KeyWrap_.RsaOaep = KeyWrap_.RsaOaep> extends declare<KeyWrap_.PublicKey<A>> {
+    readonly "Rebuild": KeyWrapPublicKey<A>;
+}
+/**
+ * Schema for live RSA-OAEP `KeyWrap.PublicKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyWrapPublicKeyFromFormat} to read and write keys. RSA-OAEP keys
+ * have no raw form. Keys compare by reference and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapPublicKey: <A extends KeyWrap_.RsaOaep>(algorithm: A) => KeyWrapPublicKey<A>;
+/**
+ * Schema that decodes an RSA-OAEP `KeyWrap.PublicKey` with
+ * `KeyFormat.decodePublic` and encodes it with `KeyFormat.encode`.
+ *
+ * **Details**
+ *
+ * The format must hold public keys: `KeyFormat.spki`, `KeyFormat.jwk`, or
+ * `KeyFormat.pem(KeyFormat.spki)`. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapPublicKeyFromFormat: <A extends KeyWrap_.RsaOaep, Data>(format: KeyFormat_.Format<"public", "decode", Data>, algorithm: A) => decodeTo<KeyWrapPublicKey<A>, Codec<Data>>;
+/**
+ * Type-level representation of {@link KeyWrapPrivateKey}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface KeyWrapPrivateKey<A extends KeyWrap_.RsaOaep = KeyWrap_.RsaOaep> extends declare<KeyWrap_.PrivateKey<A>> {
+    readonly "Rebuild": KeyWrapPrivateKey<A>;
+}
+/**
+ * Schema for live RSA-OAEP `KeyWrap.PrivateKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyWrapPrivateKeyFromFormat} to read and write keys. RSA-OAEP keys
+ * have no raw form. Keys display redacted, compare by reference, and have no
+ * `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapPrivateKey: <A extends KeyWrap_.RsaOaep>(algorithm: A) => KeyWrapPrivateKey<A>;
+/**
+ * Schema that decodes an RSA-OAEP `KeyWrap.PrivateKey` with
+ * `KeyFormat.decodePrivate`.
+ *
+ * **Details**
+ *
+ * The format must hold private keys: `KeyFormat.pkcs8`, `KeyFormat.jwk`,
+ * `KeyFormat.pkcs1`, or their PEM forms. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error. Encoding fails with a
+ * `Forbidden` issue unless `allowEncode` is `true`, and always for the
+ * read-only PKCS#1 format.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export declare const KeyWrapPrivateKeyFromFormat: <A extends KeyWrap_.RsaOaep, Data>(format: KeyFormat_.Format<"private", "decode", Data>, algorithm: A, options?: CryptoKeyOptions) => decodeTo<KeyWrapPrivateKey<A>, Codec<Data>>;
 /**
  * Type-level representation returned by {@link Exit}.
  *
@@ -11057,6 +11690,10 @@ type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use
  *
  * **Gotchas**
  *
+ * To subclass a `Schema.Class`, use `Base.extend<Self>(...)`, even when only
+ * adding methods or getters. Pass `{}` for the fields when none are added.
+ * Plain `class Child extends Base` is unsupported.
+ *
  * Passing `disableChecks: true` skips filters and checks, not parsing of types
  * and structure. Wrong types and shapes are still rejected, and constructor
  * defaults still apply.
@@ -11130,6 +11767,10 @@ export declare const Class: {
      *
      * **Gotchas**
      *
+     * To subclass a `Schema.Class`, use `Base.extend<Self>(...)`, even when only
+     * adding methods or getters. Pass `{}` for the fields when none are added.
+     * Plain `class Child extends Base` is unsupported.
+     *
      * Passing `disableChecks: true` skips filters and checks, not parsing of types
      * and structure. Wrong types and shapes are still rejected, and constructor
      * defaults still apply.