<K extends Schema.Record.Key, V extends Schema.Constraint>(
key: K,
value: V,
options?: {
readonly separator?: string | undefined
readonly keyValueSeparator?: string | undefined
}
): Schema.Union<
readonly [
Schema.$Record<K, V>,
Schema.compose<
Schema.$Record<K, V>,
Schema.decodeTo<
Schema.$Record<Schema.String, Schema.String>,
Schema.String,
never,
never
>
>
]
>Schema for key-value record types that can also be parsed from a flat comma-separated string.
When to use
Use when reading key-value maps from a single env var (e.g. OpenTelemetry resource attributes).
Details
Accepts either a JSON-like record from the provider or a flat string like
"key1=val1,key2=val2". The separator (default ",") and
keyValueSeparator (default "=") can be customized.
Example (Parsing a comma-separated record)
import { Config, ConfigProvider, Effect, Schema } from "effect"
const schema = Config.Record(Schema.String, Schema.String)
const config = Config.schema(schema, "OTEL_RESOURCE_ATTRIBUTES")
const provider = ConfigProvider.fromEnv({
env: {
OTEL_RESOURCE_ATTRIBUTES:
"service.name=my-service,service.version=1.0.0,custom.attribute=value"
}
})
console.dir(Effect.runSync(config.parse(provider)))
// {
// 'service.name': 'my-service',
// 'service.version': '1.0.0',
// 'custom.attribute': 'value'
// }export const const Record: <
K extends Schema.Record.Key,
V extends Schema.Constraint
>(
key: K,
value: V,
options?: {
readonly separator?: string | undefined
readonly keyValueSeparator?:
| string
| undefined
}
) => Schema.Union<
readonly [
Schema.$Record<K, V>,
Schema.compose<
Schema.$Record<K, V>,
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.String
>,
Schema.String,
never,
never
>
>
]
>
Schema for key-value record types that can also be parsed from
a flat comma-separated string.
When to use
Use when reading key-value maps from a single env var (e.g. OpenTelemetry
resource attributes).
Details
Accepts either a JSON-like record from the provider or a flat string like
"key1=val1,key2=val2". The separator (default ",") and
keyValueSeparator (default "=") can be customized.
Example (Parsing a comma-separated record)
import { Config, ConfigProvider, Effect, Schema } from "effect"
const schema = Config.Record(Schema.String, Schema.String)
const config = Config.schema(schema, "OTEL_RESOURCE_ATTRIBUTES")
const provider = ConfigProvider.fromEnv({
env: {
OTEL_RESOURCE_ATTRIBUTES:
"service.name=my-service,service.version=1.0.0,custom.attribute=value"
}
})
console.dir(Effect.runSync(config.parse(provider)))
// {
// 'service.name': 'my-service',
// 'service.version': '1.0.0',
// 'custom.attribute': 'value'
// }
Record = <function (type parameter) K in <K extends Schema.Record.Key, V extends Schema.Constraint>(key: K, value: V, options?: {
readonly separator?: string | undefined;
readonly keyValueSeparator?: string | undefined;
}): Schema.Union<...>
import SchemaSchema.Record.interface Record.KeyConstraint for schemas that can be used as record keys.
Details
The key schema must decode and encode property keys (string, number, or
symbol) so it can describe object property names.
Key, function (type parameter) V in <K extends Schema.Record.Key, V extends Schema.Constraint>(key: K, value: V, options?: {
readonly separator?: string | undefined;
readonly keyValueSeparator?: string | undefined;
}): Schema.Union<...>
import SchemaSchema.Constraint>(key: K extends Schema.Record.Keykey: function (type parameter) K in <K extends Schema.Record.Key, V extends Schema.Constraint>(key: K, value: V, options?: {
readonly separator?: string | undefined;
readonly keyValueSeparator?: string | undefined;
}): Schema.Union<...>
value: V extends Schema.Constraintvalue: function (type parameter) V in <K extends Schema.Record.Key, V extends Schema.Constraint>(key: K, value: V, options?: {
readonly separator?: string | undefined;
readonly keyValueSeparator?: string | undefined;
}): Schema.Union<...>
options: | {
readonly separator?: string | undefined
readonly keyValueSeparator?:
| string
| undefined
}
| undefined
separator?: string | undefinedseparator?: string | undefined
readonly keyValueSeparator?: string | undefinedkeyValueSeparator?: string | undefined
}) => {
const const record: Schema.$Record<K, V>const record: {
Type: Record.Type<Key, Value>;
Encoded: Record.Encoded<Key, Value>;
DecodingServices: Record.DecodingServices<Key, Value>;
EncodingServices: Record.EncodingServices<Key, Value>;
Iso: Record.Iso<Key, Value>;
key: Key;
value: Value;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Record.Type<K, V>, readonly []>) => Schema.$Record<K, V>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Record.Type<K, V>>) => Schema.$Record<K, V>;
check: (checks_0: SchemaAST.Check<Schema.Record.Type<K, V>>, ...checks: Array<SchemaAST.Check<Schema.Record.Type<K, V>>>) => Schema.$Record<K, V>;
rebuild: (ast: SchemaAST.Objects) => Schema.$Record<K, V>;
make: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Record.Type<K, V>;
makeOption: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Option_.Option<Record.Type<K, V>>;
makeEffect: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Effect.Effect<Record.Type<K, V>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.function Record<
Key extends Record.Key,
Value extends Constraint
>(
key: Key,
value: Value,
options?: {
readonly keyValueCombiner: {
readonly decode?:
| Combiner.Combiner<
readonly [Key["Type"], Value["Type"]]
>
| undefined
readonly encode?:
| Combiner.Combiner<
readonly [
Key["Encoded"],
Value["Encoded"]
]
>
| undefined
}
}
): $Record<Key, Value>
Defines a record schema whose dynamic properties are selected by a key schema
and decoded with a value schema.
Details
For dynamic keys, the key schema selects matching own properties and the
value schema decodes or encodes only those selected properties. Checks on
string, number, symbol, and template literal key schemas narrow which
properties are selected.
For transformed key schemas, property selection is based on encoded property
names before the selected key is decoded.
Example (Defining a string-keyed record of numbers)
import { Schema } from "effect"
const schema = Schema.Record(Schema.String, Schema.Number)
// { readonly [x: string]: number }
type R = typeof schema.Type
const result = Schema.decodeUnknownSync(schema)({ a: 1, b: 2 })
console.log(result)
// { a: 1, b: 2 }
Record(key: K extends Schema.Record.Keykey, value: V extends Schema.Constraintvalue)
const const recordString: Schema.compose<
Schema.$Record<K, V>,
Schema.decodeTo<
Schema.$Record<Schema.String, Schema.String>,
Schema.String,
never,
never
>
>
const recordString: {
Type: To["Type"];
Encoded: From["Encoded"];
DecodingServices: To["DecodingServices"] | From["DecodingServices"] | RD;
EncodingServices: To["EncodingServices"] | From["EncodingServices"] | RE;
Iso: To["Iso"];
from: From;
to: To;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Record.Type<K, V>, readonly []>) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, never, never>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Record.Type<K, V>>) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, never, never>;
check: (checks_0: SchemaAST.Check<Schema.Record.Type<K, V>>, ...checks: Array<SchemaAST.Check<Schema.Record.Type<K, V>>>) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never,…;
rebuild: (ast: SchemaAST.Objects) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, never, never>;
make: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Record.Type<K, V>;
makeOption: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Option_.Option<Record.Type<K, V>>;
makeEffect: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Effect.Effect<Record.Type<K, V>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.const String: Stringconst String: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<string, readonly []>) => Schema.String;
annotateKey: (annotations: Schema.Annotations.Key<string>) => Schema.String;
check: (checks_0: SchemaAST.Check<string>, ...checks: Array<SchemaAST.Check<string>>) => Schema.String;
rebuild: (ast: SchemaAST.String) => Schema.String;
make: (input: string, options?: MakeOptions) => string;
makeOption: (input: string, options?: MakeOptions) => Option_.Option<string>;
makeEffect: (input: string, options?: MakeOptions) => Effect.Effect<string, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
String
.
Schema for string values. Validates that the input is typeof "string".
String.Pipeable.pipe<Schema.String, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, Schema.compose<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>>>(this: Schema.String, ab: (_: Schema.String) => Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, bc: (_: Schema.decodeTo<...>) => Schema.compose<...>): Schema.compose<...> (+21 overloads)pipe(
import SchemaSchema.function decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>(to: Schema.$Record<Schema.String, Schema.String>, transformation: {
readonly decode: SchemaGetter.Getter<NoInfer<{
readonly [x: string]: string;
}>, string, never>;
readonly encode: SchemaGetter.Getter<string, NoInfer<{
readonly [x: string]: string;
}>, never>;
}): (from: Schema.String) => Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never> (+1 overload)
Creates a schema that transforms from a source schema to a target schema.
When to use
Use when decoding should change the schema's decoded type or encoded shape,
with an optional custom bidirectional transformation.
Details
Call it with the target schema to and then pipe the source schema from
into the returned function. The resulting schema decodes from
From["Encoded"] to To["Type"] and encodes from To["Type"] back to
From["Encoded"].
When no transformation is provided, SchemaTransformation.passthrough() is
used, so From["Type"] must already be compatible with To["Encoded"].
The resulting schema combines decoding and encoding services from both
schemas and any custom transformation.
Gotchas
In a custom transformation, decode maps From["Type"] to To["Encoded"]
and is used on the encoding path, while encode maps To["Encoded"] to
From["Type"] and is used on the decoding path.
Example (Transforming strings to numbers with a schema transformation)
import { Schema, SchemaGetter } from "effect"
const NumberFromString = Schema.String.pipe(
Schema.decodeTo(
Schema.Number,
{
decode: SchemaGetter.transform((s) => Number(s)),
encode: SchemaGetter.transform((n) => String(n))
}
)
)
const result = Schema.decodeUnknownSync(NumberFromString)("123")
// result: 123
decodeTo(
import SchemaSchema.function Record<
Key extends Record.Key,
Value extends Constraint
>(
key: Key,
value: Value,
options?: {
readonly keyValueCombiner: {
readonly decode?:
| Combiner.Combiner<
readonly [Key["Type"], Value["Type"]]
>
| undefined
readonly encode?:
| Combiner.Combiner<
readonly [
Key["Encoded"],
Value["Encoded"]
]
>
| undefined
}
}
): $Record<Key, Value>
Defines a record schema whose dynamic properties are selected by a key schema
and decoded with a value schema.
Details
For dynamic keys, the key schema selects matching own properties and the
value schema decodes or encodes only those selected properties. Checks on
string, number, symbol, and template literal key schemas narrow which
properties are selected.
For transformed key schemas, property selection is based on encoded property
names before the selected key is decoded.
Example (Defining a string-keyed record of numbers)
import { Schema } from "effect"
const schema = Schema.Record(Schema.String, Schema.Number)
// { readonly [x: string]: number }
type R = typeof schema.Type
const result = Schema.decodeUnknownSync(schema)({ a: 1, b: 2 })
console.log(result)
// { a: 1, b: 2 }
Record(import SchemaSchema.const String: Stringconst String: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<string, readonly []>) => Schema.String;
annotateKey: (annotations: Schema.Annotations.Key<string>) => Schema.String;
check: (checks_0: SchemaAST.Check<string>, ...checks: Array<SchemaAST.Check<string>>) => Schema.String;
rebuild: (ast: SchemaAST.String) => Schema.String;
make: (input: string, options?: MakeOptions) => string;
makeOption: (input: string, options?: MakeOptions) => Option_.Option<string>;
makeEffect: (input: string, options?: MakeOptions) => Effect.Effect<string, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
String
.
Schema for string values. Validates that the input is typeof "string".
String, import SchemaSchema.const String: Stringconst String: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<string, readonly []>) => Schema.String;
annotateKey: (annotations: Schema.Annotations.Key<string>) => Schema.String;
check: (checks_0: SchemaAST.Check<string>, ...checks: Array<SchemaAST.Check<string>>) => Schema.String;
rebuild: (ast: SchemaAST.String) => Schema.String;
make: (input: string, options?: MakeOptions) => string;
makeOption: (input: string, options?: MakeOptions) => Option_.Option<string>;
makeEffect: (input: string, options?: MakeOptions) => Effect.Effect<string, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
String
.
Schema for string values. Validates that the input is typeof "string".
String),
import SchemaTransformationSchemaTransformation.function splitKeyValue(options?: {
readonly separator?: string | undefined
readonly keyValueSeparator?: string | undefined
}): Transformation<Record<string, string>, string>
Transforms a string into a record of key-value pairs and
encodes a record of key-value pairs into a string.
When to use
Use when you need a schema transformation to parse query-string-like or
config-file-like strings into records.
Details
Decoding splits the string by separator (default ",") into pairs, then
splits each pair by keyValueSeparator (default "="). Encoding joins the
record back into a string using the same separators. The transformation is
round-trippable when keys and values do not contain the separators.
Example (Parsing key-value pairs)
import { Schema, SchemaTransformation } from "effect"
const Config = Schema.String.pipe(
Schema.decodeTo(
Schema.Record(Schema.String, Schema.String),
SchemaTransformation.splitKeyValue({ separator: ";", keyValueSeparator: ":" })
)
)
// "host:localhost;port:3000" → { host: "localhost", port: "3000" }
splitKeyValue(options: | {
readonly separator?: string | undefined
readonly keyValueSeparator?:
| string
| undefined
}
| undefined
import SchemaSchema.function decodeTo<Schema.$Record<K, V>>(to: Schema.$Record<K, V>): <From>(from: From) => Schema.compose<Schema.$Record<K, V>, From> (+1 overload)Creates a schema that transforms from a source schema to a target schema.
When to use
Use when decoding should change the schema's decoded type or encoded shape,
with an optional custom bidirectional transformation.
Details
Call it with the target schema to and then pipe the source schema from
into the returned function. The resulting schema decodes from
From["Encoded"] to To["Type"] and encodes from To["Type"] back to
From["Encoded"].
When no transformation is provided, SchemaTransformation.passthrough() is
used, so From["Type"] must already be compatible with To["Encoded"].
The resulting schema combines decoding and encoding services from both
schemas and any custom transformation.
Gotchas
In a custom transformation, decode maps From["Type"] to To["Encoded"]
and is used on the encoding path, while encode maps To["Encoded"] to
From["Type"] and is used on the decoding path.
Example (Transforming strings to numbers with a schema transformation)
import { Schema, SchemaGetter } from "effect"
const NumberFromString = Schema.String.pipe(
Schema.decodeTo(
Schema.Number,
{
decode: SchemaGetter.transform((s) => Number(s)),
encode: SchemaGetter.transform((n) => String(n))
}
)
)
const result = Schema.decodeUnknownSync(NumberFromString)("123")
// result: 123
decodeTo(const record: Schema.$Record<K, V>const record: {
Type: Record.Type<Key, Value>;
Encoded: Record.Encoded<Key, Value>;
DecodingServices: Record.DecodingServices<Key, Value>;
EncodingServices: Record.EncodingServices<Key, Value>;
Iso: Record.Iso<Key, Value>;
key: Key;
value: Value;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Record.Type<K, V>, readonly []>) => Schema.$Record<K, V>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Record.Type<K, V>>) => Schema.$Record<K, V>;
check: (checks_0: SchemaAST.Check<Schema.Record.Type<K, V>>, ...checks: Array<SchemaAST.Check<Schema.Record.Type<K, V>>>) => Schema.$Record<K, V>;
rebuild: (ast: SchemaAST.Objects) => Schema.$Record<K, V>;
make: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Record.Type<K, V>;
makeOption: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Option_.Option<Record.Type<K, V>>;
makeEffect: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Effect.Effect<Record.Type<K, V>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.function Union<
Members extends ReadonlyArray<Constraint>
>(
members: Members,
options?: { mode?: "anyOf" | "oneOf" }
): Union<Members>
Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Union([const record: Schema.$Record<K, V>const record: {
Type: Record.Type<Key, Value>;
Encoded: Record.Encoded<Key, Value>;
DecodingServices: Record.DecodingServices<Key, Value>;
EncodingServices: Record.EncodingServices<Key, Value>;
Iso: Record.Iso<Key, Value>;
key: Key;
value: Value;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Record.Type<K, V>, readonly []>) => Schema.$Record<K, V>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Record.Type<K, V>>) => Schema.$Record<K, V>;
check: (checks_0: SchemaAST.Check<Schema.Record.Type<K, V>>, ...checks: Array<SchemaAST.Check<Schema.Record.Type<K, V>>>) => Schema.$Record<K, V>;
rebuild: (ast: SchemaAST.Objects) => Schema.$Record<K, V>;
make: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Record.Type<K, V>;
makeOption: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Option_.Option<Record.Type<K, V>>;
makeEffect: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Effect.Effect<Record.Type<K, V>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const recordString: Schema.compose<
Schema.$Record<K, V>,
Schema.decodeTo<
Schema.$Record<Schema.String, Schema.String>,
Schema.String,
never,
never
>
>
const recordString: {
Type: To["Type"];
Encoded: From["Encoded"];
DecodingServices: To["DecodingServices"] | From["DecodingServices"] | RD;
EncodingServices: To["EncodingServices"] | From["EncodingServices"] | RE;
Iso: To["Iso"];
from: From;
to: To;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Record.Type<K, V>, readonly []>) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, never, never>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Record.Type<K, V>>) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, never, never>;
check: (checks_0: SchemaAST.Check<Schema.Record.Type<K, V>>, ...checks: Array<SchemaAST.Check<Schema.Record.Type<K, V>>>) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never,…;
rebuild: (ast: SchemaAST.Objects) => Schema.decodeTo<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>, never, never>;
make: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Record.Type<K, V>;
makeOption: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Option_.Option<Record.Type<K, V>>;
makeEffect: (input: { [K in keyof Record.MakeIn<K, V>]: Record.MakeIn<K, V>[K]; }, options?: MakeOptions) => Effect.Effect<Record.Type<K, V>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}