Schema

import { Schema } from "effect"

const schema = Schema.String

type Inferred = typeof schema.Type // string

import { Schema } from "effect"

const schema = Schema.Number

type Inferred = typeof schema.Type // number

import { Schema } from "effect"

const User = Schema.Struct({
  name: Schema.String,
  age: Schema.Number
})

type User = typeof User.Type
// { readonly name: string; readonly age: number }

const decodeUnknown: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (
  u: unknown,
  overrideOptions?: ParseOptions
) => Effect<A, ParseError, R>

import { Effect, Schema } from "effect"

const parse = Schema.decodeUnknown(Schema.String)

Effect.runPromise(parse("hello")) // "hello"
Effect.runPromise(parse(123)) // fails with ParseError

import { Schema } from "effect"

const value = Schema.decodeSync(Schema.Number)(42) // 42
Schema.decodeSync(Schema.Number)("not a number") // throws ParseError

import { Schema } from "effect"

const isString = Schema.is(Schema.String)

if (isString(value)) {
  // value is string
}

const encode: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (a: A, overrideOptions?: ParseOptions) => Effect<I, ParseError, R>

import { Schema } from "effect"

const User = Schema.Struct({
  name: Schema.String,
  age: Schema.Number
})

const encoded = Schema.encodeSync(User)({
  name: "Alice",
  age: 30
})

interface Schema<in out A, in out I = A, out R = never> {
  readonly Type: A
  readonly Encoded: I
  readonly Context: R
  readonly ast: AST.AST
  annotations(annotations: Annotations.GenericSchema<A>): Schema<A, I, R>
}

import { Schema } from "effect"

const StringOrNumber = Schema.Union(Schema.String, Schema.Number)

type T = typeof StringOrNumber.Type // string | number

import { Schema } from "effect"

const Numbers = Schema.Array(Schema.Number)

type T = typeof Numbers.Type // readonly number[]

import { Schema } from "effect"

const Pair = Schema.Tuple(Schema.String, Schema.Number)

type T = typeof Pair.Type // readonly [string, number]

import { Schema } from "effect"

const Status = Schema.Literal("pending", "active", "completed")

type Status = typeof Status.Type
// "pending" | "active" | "completed"

import { Schema } from "effect"

const schema = Schema.transform(
  Schema.String,
  Schema.Number,
  {
    strict: true,
    decode: (s) => s.length,
    encode: (n) => "x".repeat(n)
  }
)

const typeSchema: <A, I, R>(schema: Schema<A, I, R>) => SchemaClass<A>

const encodedSchema: <A, I, R>(schema: Schema<A, I, R>) => SchemaClass<I>

import { Schema } from "effect"

const User = Schema.Struct({
  name: Schema.String,
  age: Schema.Number
})

type User = Schema.Schema.Type<typeof User>
// { readonly name: string; readonly age: number }

type Encoded<S> = S extends Schema.Variance<infer _A, infer I, infer _R> ? I : never

type Context<S> = S extends Schema.Variance<infer _A, infer _I, infer R> ? R : never