ts
import { Schema } from "@effect/schema"
 
Schema.String // Schema<string>
Schema.Number // Schema<number>
Schema.Boolean // Schema<boolean>
Schema.BigIntFromSelf // Schema<BigInt>
Schema.SymbolFromSelf // Schema<symbol>
Schema.Object // Schema<object>
Schema.Undefined // Schema<undefined>
Schema.Void // Schema<void>
Schema.Any // Schema<any>
Schema.Unknown // Schema<unknown>
Schema.Never // Schema<never>

ts
import { Schema } from "@effect/schema"
 
Schema.Null // same as S.Literal(null)
Schema.Literal("a")
Schema.Literal("a", "b", "c") // union of literals
Schema.Literal(1)
Schema.Literal(2n) // BigInt literal
Schema.Literal(true)

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.Literal("a", "b")
 
// Accesses the literals
const literals = schema.literals

ts
import { Schema } from "@effect/schema"
 
Schema.Literal("a", "b", "c").pipe(Schema.pickLiteral("a", "b")) // same as S.Literal("a", "b")

ts
import { Schema } from "@effect/schema"
 
const FruitId = Schema.Number
// the source of truth regarding the Fruit category
const FruitCategory = Schema.Literal("sweet", "citrus", "tropical")
 
const Fruit = Schema.Struct({
  id: FruitId,
  category: FruitCategory
})
 
// Here, we want to reuse our FruitCategory definition to create a subtype of Fruit
const SweetAndCitrusFruit = Schema.Struct({
  fruitId: FruitId,
  category: FruitCategory.pipe(Schema.pickLiteral("sweet", "citrus"))
  /*
    By using pickLiteral from the FruitCategory, we ensure that the values selected
    are those defined in the category definition above.
    If we remove "sweet" from the FruitCategory definition, TypeScript will notify us.
  */
})

ts
import { Schema } from "@effect/schema"
 
// This creates a TemplateLiteral of type `a${string}`
Schema.TemplateLiteral("a", Schema.String)
 
// This creates a TemplateLiteral of type `https://${string}.com` or `https://${string}.net`
Schema.TemplateLiteral(
  "https://",
  Schema.String,
  ".",
  Schema.Literal("com", "net")
)

ts
import { Schema } from "@effect/schema"
 
// example from https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html
const EmailLocaleIDs = Schema.Literal("welcome_email", "email_heading")
const FooterLocaleIDs = Schema.Literal("footer_title", "footer_sendoff")

ts
// This creates a TemplateLiteral of type "welcome_email_id" | "email_heading_id" | "footer_title_id" | "footer_sendoff_id"
Schema.TemplateLiteral(Schema.Union(EmailLocaleIDs, FooterLocaleIDs), "_id")

ts
import { Schema } from "@effect/schema"
 
// const schema: Schema.Schema<readonly [number, "a", string], `${string}a${string}`, never>
const schema = Schema.TemplateLiteralParser(
  Schema.NumberFromString,
  "a",
  Schema.NonEmptyString
)
 
console.log(Schema.decodeEither(schema)("100afoo"))
// { _id: 'Either', _tag: 'Right', right: [ 100, 'a', 'foo' ] }
 
console.log(Schema.encode(schema)([100, "a", "foo"]))
// { _id: 'Either', _tag: 'Right', right: '100afoo' }

ts
import { Schema } from "@effect/schema"
 
const mySymbol = Symbol.for("mysymbol")
 
// const mySymbolSchema: S.Schema<typeof mySymbol>
const mySymbolSchema = Schema.UniqueSymbolFromSelf(mySymbol)

ts
import { Schema } from "@effect/schema"
 
const LongString = Schema.String.pipe(
  Schema.filter(
    (s) => s.length >= 10 || "a string at least 10 characters long"
  )
)
 
// string
type LongString = typeof LongString.Type
 
console.log(Schema.decodeUnknownSync(LongString)("a"))
/*
throws:
ParseError: { string | filter }
└─ Predicate refinement failure
   └─ a string at least 10 characters long
*/

ts
import { Schema } from "@effect/schema"
 
const LongString = Schema.String.pipe(
  Schema.filter(
    (s) =>
      s.length >= 10 ? undefined : "a string at least 10 characters long",
    {
      identifier: "LongString",
      jsonSchema: { minLength: 10 },
      description:
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua"
    }
  )
)
 
console.log(Schema.decodeUnknownSync(LongString)("a"))
/*
throws:
ParseError: { string | filter }
└─ Predicate refinement failure
   └─ a string at least 10 characters long
*/

ts
import { ArrayFormatter, Schema } from "@effect/schema"
import { Either } from "effect"
 
const Password = Schema.Trim.pipe(Schema.minLength(1))
 
const MyForm = Schema.Struct({
  password: Password,
  confirm_password: Password
}).pipe(
  Schema.filter((input) => {
    if (input.password !== input.confirm_password) {
      return {
        path: ["confirm_password"],
        message: "Passwords do not match"
      }
    }
  })
)
 
console.log(
  JSON.stringify(
    Schema.decodeUnknownEither(MyForm)({
      password: "abc",
      confirm_password: "d"
    }).pipe(Either.mapLeft((error) => ArrayFormatter.formatErrorSync(error))),
    null,
    2
  )
)
/*
  "_id": "Either",
  "_tag": "Left",
  "left": [
    {
      "_tag": "Type",
      "path": [
        "confirm_password"
      ],
      "message": "Passwords do not match"
    }
  ]
}
*/

ts
import { ArrayFormatter, Schema } from "@effect/schema"
import { Either } from "effect"
 
const Password = Schema.Trim.pipe(Schema.minLength(1))
const OptionalString = Schema.optional(Schema.String)
 
const MyForm = Schema.Struct({
  password: Password,
  confirm_password: Password,
  name: OptionalString,
  surname: OptionalString
}).pipe(
  Schema.filter((input) => {
    const issues: Array<Schema.FilterIssue> = []
    // passwords must match
    if (input.password !== input.confirm_password) {
      issues.push({
        path: ["confirm_password"],
        message: "Passwords do not match"
      })
    }
    // either name or surname must be present
    if (!input.name && !input.surname) {
      issues.push({
        path: ["surname"],
        message: "Surname must be present if name is not present"
      })
    }
    return issues
  })
)
 
console.log(
  JSON.stringify(
    Schema.decodeUnknownEither(MyForm)({
      password: "abc",
      confirm_password: "d"
    }).pipe(Either.mapLeft((error) => ArrayFormatter.formatErrorSync(error))),
    null,
    2
  )
)
/*
{
  "_id": "Either",
  "_tag": "Left",
  "left": [
    {
      "_tag": "Type",
      "path": [
        "confirm_password"
      ],
      "message": "Passwords do not match"
    },
    {
      "_tag": "Type",
      "path": [
        "surname"
      ],
      "message": "Surname must be present if name is not present"
    }
  ]
}
*/

ts
import { Schema } from "@effect/schema"
 
const LongString = Schema.String.pipe(Schema.filter((s) => s.length >= 10))
 
// const From: typeof Schema.String
const From = LongString.from

ts
import { Schema } from "@effect/schema"
 
// Specifies maximum length of a string
Schema.String.pipe(Schema.maxLength(5))
 
// Specifies minimum length of a string
Schema.String.pipe(Schema.minLength(5))
 
// Equivalent to ensuring the string has a minimum length of 1
Schema.NonEmptyString
 
// Specifies exact length of a string
Schema.String.pipe(Schema.length(5))
 
// Specifies a range for the length of a string
Schema.String.pipe(Schema.length({ min: 2, max: 4 }))
 
// Matches a string against a regular expression pattern
Schema.String.pipe(Schema.pattern(/^[a-z]+$/))
 
// Ensures a string starts with a specific substring
Schema.String.pipe(Schema.startsWith("prefix"))
 
// Ensures a string ends with a specific substring
Schema.String.pipe(Schema.endsWith("suffix"))
 
// Checks if a string includes a specific substring
Schema.String.pipe(Schema.includes("substring"))
 
// Validates that a string has no leading or trailing whitespaces
Schema.String.pipe(Schema.trimmed())
 
// Validates that a string is entirely in lowercase
Schema.String.pipe(Schema.lowercased())

ts
import { Schema } from "@effect/schema"
 
// Specifies a number greater than 5
Schema.Number.pipe(Schema.greaterThan(5))
 
// Specifies a number greater than or equal to 5
Schema.Number.pipe(Schema.greaterThanOrEqualTo(5))
 
// Specifies a number less than 5
Schema.Number.pipe(Schema.lessThan(5))
 
// Specifies a number less than or equal to 5
Schema.Number.pipe(Schema.lessThanOrEqualTo(5))
 
// Specifies a number between -2 and 2, inclusive
Schema.Number.pipe(Schema.between(-2, 2))
 
// Specifies that the value must be an integer
Schema.Number.pipe(Schema.int())
 
// Ensures the value is not NaN
Schema.Number.pipe(Schema.nonNaN())
 
// Ensures the value is finite and not Infinity or -Infinity
Schema.Number.pipe(Schema.finite())
 
// Specifies a positive number (> 0)
Schema.Number.pipe(Schema.positive())
 
// Specifies a non-negative number (>= 0)
Schema.Number.pipe(Schema.nonNegative())
 
// Specifies a negative number (< 0)
Schema.Number.pipe(Schema.negative())
 
// Specifies a non-positive number (<= 0)
Schema.Number.pipe(Schema.nonPositive())
 
// Specifies a number that is evenly divisible by 5
Schema.Number.pipe(Schema.multipleOf(5))

ts
import { Schema } from "@effect/schema"
 
// Specifies a BigInt greater than 5
Schema.BigInt.pipe(Schema.greaterThanBigInt(5n))
 
// Specifies a BigInt greater than or equal to 5
Schema.BigInt.pipe(Schema.greaterThanOrEqualToBigInt(5n))
 
// Specifies a BigInt less than 5
Schema.BigInt.pipe(Schema.lessThanBigInt(5n))
 
// Specifies a BigInt less than or equal to 5
Schema.BigInt.pipe(Schema.lessThanOrEqualToBigInt(5n))
 
// Specifies a BigInt between -2n and 2n, inclusive
Schema.BigInt.pipe(Schema.betweenBigInt(-2n, 2n))
 
// Specifies a positive BigInt (> 0n)
Schema.BigInt.pipe(Schema.positiveBigInt())
 
// Specifies a non-negative BigInt (>= 0n)
Schema.BigInt.pipe(Schema.nonNegativeBigInt())
 
// Specifies a negative BigInt (< 0n)
Schema.BigInt.pipe(Schema.negativeBigInt())
 
// Specifies a non-positive BigInt (<= 0n)
Schema.BigInt.pipe(Schema.nonPositiveBigInt())

ts
import { Schema } from "@effect/schema"
import { BigDecimal } from "effect"
 
// Specifies a BigDecimal greater than 5
Schema.BigDecimal.pipe(Schema.greaterThanBigDecimal(BigDecimal.fromNumber(5)))
 
// Specifies a BigDecimal greater than or equal to 5
Schema.BigDecimal.pipe(
  Schema.greaterThanOrEqualToBigDecimal(BigDecimal.fromNumber(5))
)
// Specifies a BigDecimal less than 5
Schema.BigDecimal.pipe(Schema.lessThanBigDecimal(BigDecimal.fromNumber(5)))
 
// Specifies a BigDecimal less than or equal to 5
Schema.BigDecimal.pipe(
  Schema.lessThanOrEqualToBigDecimal(BigDecimal.fromNumber(5))
)
 
// Specifies a BigDecimal between -2 and 2, inclusive
Schema.BigDecimal.pipe(
  Schema.betweenBigDecimal(
    BigDecimal.fromNumber(-2),
    BigDecimal.fromNumber(2)
  )
)
 
// Specifies a positive BigDecimal (> 0)
Schema.BigDecimal.pipe(Schema.positiveBigDecimal())
 
// Specifies a non-negative BigDecimal (>= 0)
Schema.BigDecimal.pipe(Schema.nonNegativeBigDecimal())
 
// Specifies a negative BigDecimal (< 0)
Schema.BigDecimal.pipe(Schema.negativeBigDecimal())
 
// Specifies a non-positive BigDecimal (<= 0)
Schema.BigDecimal.pipe(Schema.nonPositiveBigDecimal())

ts
import { Schema } from "@effect/schema"
 
// Specifies a duration greater than 5 seconds
Schema.Duration.pipe(Schema.greaterThanDuration("5 seconds"))
 
// Specifies a duration greater than or equal to 5 seconds
Schema.Duration.pipe(Schema.greaterThanOrEqualToDuration("5 seconds"))
 
// Specifies a duration less than 5 seconds
Schema.Duration.pipe(Schema.lessThanDuration("5 seconds"))
 
// Specifies a duration less than or equal to 5 seconds
Schema.Duration.pipe(Schema.lessThanOrEqualToDuration("5 seconds"))
 
// Specifies a duration between 5 seconds and 10 seconds, inclusive
Schema.Duration.pipe(Schema.betweenDuration("5 seconds", "10 seconds"))

ts
import { Schema } from "@effect/schema"
 
// Specifies the maximum number of items in the array
Schema.Array(Schema.Number).pipe(Schema.maxItems(2))
 
// Specifies the minimum number of items in the array
Schema.Array(Schema.Number).pipe(Schema.minItems(2))
 
// Specifies the exact number of items in the array
Schema.Array(Schema.Number).pipe(Schema.itemsCount(2))

ts
type UserId = string
type Username = string
 
declare const getUser: (id: UserId) => object
 
const myUsername: Username = "gcanti"
 
getUser(myUsername) // This erroneously works

ts
import { Brand } from "effect"
 
type UserId = string & Brand.Brand<"UserId">
type Username = string
 
declare const getUser: (id: UserId) => object
 
const myUsername: Username = "gcanti"
 
getUser(myUsername)
Argument of type 'string' is not assignable to parameter of type 'UserId'.
  Type 'string' is not assignable to type 'Brand<"UserId">'.2345Argument of type 'string' is not assignable to parameter of type 'UserId'.
  Type 'string' is not assignable to type 'Brand<"UserId">'.

ts
import { Schema } from "@effect/schema"
 
const UserId = Schema.String.pipe(Schema.brand("UserId"))
 
// string & Brand<"UserId">
type UserId = Schema.Schema.Type<typeof UserId>

ts
import { Schema } from "@effect/schema"
 
const UserIdBrand = Symbol.for("UserId")
 
const UserId = Schema.String.pipe(Schema.brand(UserIdBrand))
 
// string & Brand<typeof UserIdBrand>
type UserId = Schema.Schema.Type<typeof UserId>

ts
import { Schema } from "@effect/schema"
import { Brand } from "effect"
 
// the existing branded type
type UserId = string & Brand.Brand<"UserId">
 
const UserId = Brand.nominal<UserId>()
 
// Define a schema for the branded type
const UserIdSchema = Schema.String.pipe(Schema.fromBrand(UserId))

ts
import { Schema } from "@effect/schema"
 
const UserId = Schema.String.pipe(Schema.brand("UserId"))
 
const userId = UserId.make("123") // Creates a branded UserId

ts
import { Schema } from "@effect/schema"
 
enum Fruits {
  Apple,
  Banana
}
 
// Schema.Enums<typeof Fruits>
const schema = Schema.Enums(Fruits)

ts
// Access the enum members
schema.enums // Returns all enum members
schema.enums.Apple // Access the Apple member
schema.enums.Banana // Access the Banana member

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.Union(Schema.String, Schema.Number)

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.Union(
  Schema.Literal("a"),
  Schema.Literal("b"),
  Schema.Literal("c")
)

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.Literal("a", "b", "c")

ts
import { Schema } from "@effect/schema"
 
// Represents a schema for a string or null value
Schema.NullOr(Schema.String)
 
// Represents a schema for a string, null, or undefined value
Schema.NullishOr(Schema.String)
 
// Represents a schema for a string or undefined value
Schema.UndefinedOr(Schema.String)

ts
type Circle = {
  readonly kind: "circle"
  readonly radius: number
}
 
type Square = {
  readonly kind: "square"
  readonly sideLength: number
}
 
type Shape = Circle | Square

ts
import { Schema } from "@effect/schema"
 
const Circle = Schema.Struct({
  kind: Schema.Literal("circle"),
  radius: Schema.Number
})
 
const Square = Schema.Struct({
  kind: Schema.Literal("square"),
  sideLength: Schema.Number
})
 
const Shape = Schema.Union(Circle, Square)

ts
import { Schema } from "@effect/schema"
 
const Circle = Schema.Struct({
  radius: Schema.Number
})
 
const Square = Schema.Struct({
  sideLength: Schema.Number
})
 
const Shape = Schema.Union(Circle, Square)