effect-app 3.16.0 → 4.0.0-beta.0

package/src/Schema/ext.ts

@@ -1,24 +1,38 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { Effect, ParseResult, pipe, type SchemaAST } from "effect"
-import type { Tag } from "effect/Context"
-import type { Schema } from "effect/Schema"
+import { Effect, Option, pipe, Schema, type SchemaAST, SchemaGetter, SchemaIssue, SchemaParser, SchemaTransformation, type ServiceMap } from "effect"
 import * as S from "effect/Schema"
 import { type NonEmptyReadonlyArray } from "../Array.js"
-import * as Context from "../Context.js"
 import { extendM, typedKeysOf } from "../utils.js"
 import { type AST } from "./schema.js"
 
-export const withDefaultConstructor: <A, I, R>(
+// TODO: v4 migration — withConstructorDefault signature changed, propertySignature removed
+// Constraint relaxed from `Self extends S.Top & S.WithoutConstructorDefault` to `Self extends S.Top`
+// because `.pipe()` widens the schema type to `Top` which doesn't satisfy `WithoutConstructorDefault`.
+// The narrowing assertions below are safe — we're asserting "this schema hasn't had a default applied yet".
+export const withDefaultConstructor = <A>(
   makeDefault: () => NoInfer<A>
-) => (self: Schema<A, I, R>) => S.PropertySignature<":", A, never, ":", I, true, R> = (makeDefault) => (self) =>
-  S.propertySignature(self).pipe(S.withConstructorDefault(makeDefault))
+) =>
+<Self extends S.Top>(self: Self): S.withConstructorDefault<Self & S.WithoutConstructorDefault> => {
+  type Narrowed = Self & S.WithoutConstructorDefault
+  return S.withConstructorDefault<Narrowed>(
+    () => Option.some(makeDefault() as Narrowed["~type.make.in"])
+  )(self as Narrowed)
+}
+
+// TODO: v4 migration - Date is no longer by default encoded to string.
+const DateFromString = Schema.Date.pipe(
+  Schema.encodeTo(Schema.String, {
+    decode: SchemaGetter.Date(),
+    encode: SchemaGetter.transform((_) => _.toISOString())
+  })
+)
 
 /**
- * Like the default Schema `Date` but with `withDefault` => now
+ * Like the default Schema `Date` but from String with `withDefault` => now
  */
-export const Date = Object.assign(S.Date, {
-  withDefault: S.Date.pipe(withDefaultConstructor(() => new global.Date()))
+export const Date = Object.assign(DateFromString, {
+  withDefault: DateFromString.pipe(withDefaultConstructor(() => new global.Date()))
 })
 
 /**
@@ -38,11 +52,11 @@ export const Number = Object.assign(S.Number, { withDefault: S.Number.pipe(withD
  */
 export const Literal = <Literals extends NonEmptyReadonlyArray<AST.LiteralValue>>(...literals: Literals) =>
   pipe(
-    S.Literal(...literals),
+    S.Literals(literals),
     (s) =>
       Object.assign(s, {
         changeDefault: <A extends Literals[number]>(a: A) => {
-          return Object.assign(S.Literal(...literals), {
+          return Object.assign(S.Literals(literals), {
             Default: a,
             withDefault: s.pipe(withDefaultConstructor(() => a))
           }) // todo: copy annotations from original?
@@ -55,7 +69,7 @@ export const Literal = <Literals extends NonEmptyReadonlyArray<AST.LiteralValue>
 /**
  * Like the default Schema `Array` but with `withDefault` => []
  */
-export function Array<Value extends Schema.Any>(value: Value) {
+export function Array<Value extends S.Top>(value: Value) {
   return pipe(
     S.Array(value),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => [])) })
@@ -65,9 +79,9 @@ export function Array<Value extends Schema.Any>(value: Value) {
 /**
  * Like the default Schema `Map` but with `withDefault` => []
  */
-function Map_<Key extends Schema.Any, Value extends Schema.Any>(input: { key: Key; value: Value }) {
+function Map_<Key extends S.Top, Value extends S.Top>(input: { key: Key; value: Value }) {
   return pipe(
-    S.Map(input),
+    S.ReadonlyMap(input.key, input.value),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new global.Map())) })
   )
 }
@@ -77,7 +91,7 @@ export { Map_ as Map }
 /**
  * Like the default Schema `ReadonlySet` but with `withDefault` => new Set()
  */
-export const ReadonlySet = <Value extends Schema.Any>(value: Value) =>
+export const ReadonlySet = <Value extends S.Top>(value: Value) =>
   pipe(
     S.ReadonlySet(value),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Set<S.Schema.Type<Value>>())) })
@@ -86,52 +100,50 @@ export const ReadonlySet = <Value extends Schema.Any>(value: Value) =>
 /**
  * Like the default Schema `ReadonlyMap` but with `withDefault` => new Map()
  */
-export const ReadonlyMap = <K extends Schema.Any, V extends Schema.Any>(pair: {
+export const ReadonlyMap = <K extends S.Top, V extends S.Top>(pair: {
   readonly key: K
   readonly value: V
 }) =>
   pipe(
-    S.ReadonlyMap(pair),
+    S.ReadonlyMap(pair.key, pair.value),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Map())) })
   )
 
 /**
  * Like the default Schema `NullOr` but with `withDefault` => null
  */
-export const NullOr = <S extends Schema.Any>(self: S) =>
+export const NullOr = <S extends S.Top>(self: S) =>
   pipe(
     S.NullOr(self),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => null)) })
   )
 
-export const defaultDate = <I, R>(s: Schema<Date, I, R>) => s.pipe(withDefaultConstructor(() => new global.Date()))
+export const defaultDate = (s: S.Top) => s.pipe(withDefaultConstructor(() => new global.Date()))
 
-export const defaultBool = <I, R>(s: Schema<boolean, I, R>) => s.pipe(withDefaultConstructor(() => false))
+export const defaultBool = (s: S.Top) => s.pipe(withDefaultConstructor(() => false))
 
-export const defaultNullable = <A, I, R>(
-  s: Schema<A | null, I, R>
+export const defaultNullable = (
+  s: S.Top
 ) => s.pipe(withDefaultConstructor(() => null))
 
-export const defaultArray = <A, I, R>(s: Schema<ReadonlyArray<A>, I, R>) => s.pipe(withDefaultConstructor(() => []))
+export const defaultArray = (s: S.Top) => s.pipe(withDefaultConstructor(() => []))
 
-export const defaultMap = <A, A2, I, R>(s: Schema<ReadonlyMap<A, A2>, I, R>) =>
-  s.pipe(withDefaultConstructor(() => new Map()))
+export const defaultMap = (s: S.Top) => s.pipe(withDefaultConstructor(() => new Map()))
 
-export const defaultSet = <A, I, R>(s: Schema<ReadonlySet<A>, I, R>) =>
-  s.pipe(withDefaultConstructor(() => new Set<A>()))
+export const defaultSet = (s: S.Top) => s.pipe(withDefaultConstructor(() => new Set()))
 
-export const withDefaultMake = <Self extends S.Schema<any, any, never>>(s: Self) => {
-  const a = Object.assign(S.decodeSync(s) as WithDefaults<Self>, s)
+export const withDefaultMake = <Self extends S.Top>(s: Self) => {
+  const a = Object.assign(S.decodeSync(s as any) as WithDefaults<Self>, s)
   Object.setPrototypeOf(a, s)
   return a
 
   // return s as Self & WithDefaults<Self>
 }
 
-export type WithDefaults<Self extends S.Schema<any, any, never>> = (
-  i: S.Schema.Encoded<Self>,
+export type WithDefaults<Self extends S.Top> = (
+  i: Self["Encoded"],
   options?: SchemaAST.ParseOptions
-) => S.Schema.Type<Self>
+) => Self["Type"]
 
 // type GetKeys<U> = U extends Record<infer K, any> ? K : never
 // type UnionToIntersection2<U extends object> = {
@@ -148,174 +160,109 @@ export type WithDefaults<Self extends S.Schema<any, any, never>> = (
 //   : never
 
 export const inputDate = extendM(
-  S.Union(S.ValidDateFromSelf, S.Date),
+  S.Union([S.DateValid, S.Date]),
   (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => new globalThis.Date())) })
 )
 
 export interface UnionBrand {}
 
-const makeOpt = (self: S.PropertySignature.Any, exact?: boolean) => {
-  const ast = self.ast
-  switch (ast._tag) {
-    case "PropertySignatureDeclaration": {
-      return S.makePropertySignature(
-        new S.PropertySignatureDeclaration(
-          exact ? ast.type : S.UndefinedOr(S.make(ast.type)).ast,
-          true,
-          ast.isReadonly,
-          ast.annotations,
-          ast.defaultValue
-        )
-      )
-    }
-    case "PropertySignatureTransformation": {
-      return S.makePropertySignature(
-        new S.PropertySignatureTransformation(
-          new S.FromPropertySignature(
-            exact ? ast.from.type : S.UndefinedOr(S.make(ast.from.type)).ast,
-            true,
-            ast.from.isReadonly,
-            ast.from.annotations
-          ),
-          new S.ToPropertySignature(
-            exact ? ast.to.type : S.UndefinedOr(S.make(ast.to.type)).ast,
-            true,
-            ast.to.isReadonly,
-            ast.to.annotations,
-            ast.to.defaultValue
-          ),
-          ast.decode,
-          ast.encode
-        )
-      )
-    }
-  }
-}
-
-export function makeOptional<NER extends S.Struct.Fields | S.PropertySignature.Any>(
-  t: NER // TODO: enforce non empty
+// TODO: v4 migration — makeOpt used internal PropertySignature types that are removed in v4
+// Simplified to use v4's S.optional / S.optionalKey directly
+export function makeOptional<NER extends S.Struct.Fields>(
+  t: NER
 ): {
-  [K in keyof NER]: S.PropertySignature<
-    "?:",
-    Schema.Type<NER[K]> | undefined,
-    never,
-    "?:",
-    Schema.Encoded<NER[K]> | undefined,
-    NER[K] extends S.PropertySignature<any, any, any, any, any, infer Z, any> ? Z : false,
-    Schema.Context<NER[K]>
-  >
+  [K in keyof NER]: NER[K] extends S.Top ? ReturnType<typeof S.optional<NER[K] & S.Top>> : any
 } {
   return typedKeysOf(t).reduce((prev, cur) => {
-    if (S.isSchema(t[cur])) {
-      prev[cur] = S.optional(t[cur] as any)
-    } else {
-      prev[cur] = makeOpt(t[cur] as any)
-    }
+    prev[cur] = S.optional(t[cur] as any)
     return prev
   }, {} as any)
 }
 
 export function makeExactOptional<NER extends S.Struct.Fields>(
-  t: NER // TODO: enforce non empty
+  t: NER
 ): {
-  [K in keyof NER]: S.PropertySignature<
-    "?:",
-    Schema.Type<NER[K]>,
-    never,
-    "?:",
-    Schema.Encoded<NER[K]>,
-    NER[K] extends S.PropertySignature<any, any, any, any, any, infer Z, any> ? Z : false,
-    Schema.Context<NER[K]>
-  >
+  [K in keyof NER]: NER[K] extends S.Top ? ReturnType<typeof S.optionalKey<NER[K] & S.Top>> : any
 } {
   return typedKeysOf(t).reduce((prev, cur) => {
-    if (S.isSchema(t[cur])) {
-      prev[cur] = S.optionalWith(t[cur] as any, { exact: true })
-    } else {
-      prev[cur] = makeOpt(t[cur] as any)
-    }
+    prev[cur] = S.optionalKey(t[cur] as any)
     return prev
   }, {} as any)
 }
 
 /** A version of transform which is only a one way mapping of From->To */
-export const transformTo = <To extends Schema.Any, From extends Schema.Any>(
+export const transformTo = <To extends S.Top, From extends S.Top>(
   from: From,
   to: To,
   decode: (
-    fromA: Schema.Type<From>,
-    options: SchemaAST.ParseOptions,
-    ast: SchemaAST.Transformation,
-    fromI: Schema.Encoded<From>
-  ) => Schema.Encoded<To>
+    fromA: From["Type"],
+    options: SchemaAST.ParseOptions
+  ) => To["Encoded"]
 ) =>
-  S.transformOrFail<To, From, never, never>(
-    from,
-    to,
-    {
-      decode: (...args) => Effect.sync(() => decode(...args)),
-      encode: (i, _, ast) =>
-        ParseResult.fail(
-          new ParseResult.Forbidden(
-            ast,
-            i,
-            "One way schema transformation, encoding is not allowed"
+  from.pipe(
+    S.decodeTo(
+      to,
+      SchemaTransformation.transformOrFail({
+        decode: (input: any, options: any) => Effect.sync(() => decode(input, options)),
+        encode: (i: any) =>
+          Effect.fail(
+            new SchemaIssue.Forbidden(
+              Option.some(i),
+              { message: "One way schema transformation, encoding is not allowed" }
+            )
           )
-        )
-    }
+      }) as any
+    )
   )
 
 /** A version of transformOrFail which is only a one way mapping of From->To */
-export const transformToOrFail = <To extends Schema.Any, From extends Schema.Any, RD>(
+export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
   from: From,
   to: To,
   decode: (
-    fromA: Schema.Type<From>,
-    options: SchemaAST.ParseOptions,
-    ast: SchemaAST.Transformation
-  ) => Effect.Effect<Schema.Encoded<To>, ParseResult.ParseIssue, RD>
+    fromA: From["Type"],
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<To["Encoded"], SchemaIssue.Issue, RD>
 ) =>
-  S.transformOrFail<To, From, RD, never>(from, to, {
-    decode,
-    encode: (i, _, ast) =>
-      ParseResult.fail(
-        new ParseResult.Forbidden(
-          ast,
-          i,
-          "One way schema transformation, encoding is not allowed"
-        )
-      )
-  })
+  from.pipe(
+    S.decodeTo(
+      to,
+      SchemaTransformation.transformOrFail({
+        decode: decode as any,
+        encode: (i: any) =>
+          Effect.fail(
+            new SchemaIssue.Forbidden(
+              Option.some(i),
+              { message: "One way schema transformation, encoding is not allowed" }
+            )
+          )
+      }) as any
+    )
+  )
 
-export const provide = <Self extends S.Schema.Any, R>(
+// TODO: v4 migration — S.declare API changed (no [self] + decode/encode pattern)
+// Need to find v4 equivalent for contextual schema wrapping
+export const provide = <Self extends S.Top, R>(
   self: Self,
-  context: Context.Context<R> // TODO: support Layers?
-): S.SchemaClass<S.Schema.Type<Self>, S.Schema.Encoded<Self>, Exclude<S.Schema.Context<Self>, R>> => {
-  const provide = Effect.provide(context)
+  context: ServiceMap.ServiceMap<R>
+): any => {
+  const prov = Effect.provide(context)
   return S
-    .declare([self], {
-      decode: (t) => (n) => provide(ParseResult.decodeUnknown(t)(n)),
-      encode: (t) => (n) => provide(ParseResult.encodeUnknown(t)(n))
-    }) as any
+    .declare((_u: unknown): _u is unknown => true) // placeholder — needs proper v4 declare
+    .pipe(
+      S.decodeTo(
+        self,
+        SchemaTransformation.transformOrFail({
+          decode: (n: any) => prov(SchemaParser.decodeUnknownEffect(self)(n)),
+          encode: (n: any) => prov(SchemaParser.encodeUnknownEffect(self)(n))
+        }) as any
+      ) as any
+    )
+}
+// TODO: v4 migration — ServiceMap.pick and S.declare pattern removed
+export const contextFromServices = <Self extends S.Top, Tags extends readonly any[]>(
+  _self: Self,
+  ..._services: Tags
+): any => {
+  throw new Error("contextFromServices: not yet migrated to v4")
 }
-export const contextFromServices = <Self extends S.Schema.Any, Tags extends readonly Tag<any, any>[]>(
-  self: Self,
-  ...services: Tags
-): Effect.Effect<
-  S.SchemaClass<
-    S.Schema.Type<Self>,
-    S.Schema.Encoded<Self>,
-    Exclude<S.Schema.Context<Self>, { [K in keyof Tags]: Tag.Identifier<Tags[K]> }[number]>
-  >,
-  never,
-  { [K in keyof Tags]: Tag.Identifier<Tags[K]> }[number]
-> =>
-  Effect.gen(function*() {
-    const context = Context.pick(...services)(yield* Effect.context())
-    const provide = Effect.provide(context)
-    return S
-      .declare([self], {
-        decode: (t) => (n) => provide(ParseResult.decodeUnknown(t)(n)),
-        encode: (t) => (n) => provide(ParseResult.encodeUnknown(t)(n))
-      })
-  }) as any

package/src/Schema/moreStrings.ts

@@ -1,7 +1,6 @@
 import { pipe } from "effect"
 import type { Refinement } from "effect-app/Function"
 import { extendM } from "effect-app/utils"
-import type { LazyArbitrary } from "effect/Arbitrary"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"
@@ -11,7 +10,7 @@ import { withDefaultConstructor, withDefaultMake, type WithDefaults } from "./ex
 import { type B } from "./schema.js"
 import type { NonEmptyString255Brand, NonEmptyStringBrand } from "./strings.js"
 
-const nonEmptyString = S.String.pipe(S.nonEmptyString())
+const nonEmptyString = S.NonEmptyString
 
 /**
  * A string that is at least 1 character long and a maximum of 50.
@@ -27,7 +26,7 @@ export type NonEmptyString50 = string & NonEmptyString50Brand
  * A string that is at least 1 character long and a maximum of 50.
  */
 export const NonEmptyString50 = nonEmptyString.pipe(
-  S.maxLength(50),
+  S.check(S.isMaxLength(50)),
   fromBrand(nominal<NonEmptyString50>(), {
     identifier: "NonEmptyString50",
     title: "NonEmptyString50",
@@ -50,7 +49,7 @@ export type NonEmptyString64 = string & NonEmptyString64Brand
  * A string that is at least 1 character long and a maximum of 64.
  */
 export const NonEmptyString64 = nonEmptyString.pipe(
-  S.maxLength(64),
+  S.check(S.isMaxLength(64)),
   fromBrand(nominal<NonEmptyString64>(), {
     identifier: "NonEmptyString64",
     title: "NonEmptyString64",
@@ -74,7 +73,7 @@ export type NonEmptyString80 = string & NonEmptyString80Brand
  */
 
 export const NonEmptyString80 = nonEmptyString.pipe(
-  S.maxLength(80),
+  S.check(S.isMaxLength(80)),
   fromBrand(nominal<NonEmptyString80>(), {
     identifier: "NonEmptyString80",
     title: "NonEmptyString80",
@@ -97,7 +96,7 @@ export type NonEmptyString100 = string & NonEmptyString100Brand
  * A string that is at least 1 character long and a maximum of 100.
  */
 export const NonEmptyString100 = nonEmptyString.pipe(
-  S.maxLength(100),
+  S.check(S.isMaxLength(100)),
   fromBrand(nominal<NonEmptyString100>(), {
     identifier: "NonEmptyString100",
     title: "NonEmptyString100",
@@ -121,8 +120,7 @@ export type Min3String255 = string & Min3String255Brand
  */
 export const Min3String255 = pipe(
   S.String,
-  S.minLength(3),
-  S.maxLength(255),
+  S.check(S.isMinLength(3), S.isMaxLength(255)),
   fromBrand(nominal<Min3String255>(), { identifier: "Min3String255", title: "Min3String255", jsonSchema: {} }),
   withDefaultMake
 )
@@ -142,10 +140,10 @@ const minLength = 6
 const maxLength = 50
 const size = 21
 const length = 10 * size
-const StringIdArb = (): LazyArbitrary<string> => (fc) =>
+const StringIdArb = (): any => (fc: any) =>
   fc
     .uint8Array({ minLength: length, maxLength: length })
-    .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))())
+    .map((_: any) => customRandom(urlAlphabet, size, (size: number) => _.subarray(0, size))())
 
 /**
  * A string that is at least 6 characters long and a maximum of 50.
@@ -153,8 +151,7 @@ const StringIdArb = (): LazyArbitrary<string> => (fc) =>
 export const StringId = extendM(
   pipe(
     S.String,
-    S.minLength(minLength),
-    S.maxLength(maxLength),
+    S.check(S.isMinLength(minLength), S.isMaxLength(maxLength)),
     fromBrand(nominal<StringId>(), {
       identifier: "StringId",
       title: "StringId",
@@ -181,19 +178,19 @@ export function prefixedStringId<Brand extends StringId>() {
   ) => {
     type FullPrefix = `${Prefix}${Separator}`
     const pref = `${prefix}${separator ?? "-"}` as FullPrefix
-    const arb = (): LazyArbitrary<string & Brand> => (fc) =>
+    const arb = (): any => (fc: any) =>
       StringIdArb()(fc).map(
-        (x) => (pref + x.substring(0, 50 - pref.length)) as Brand
+        (x: any) => (pref + x.substring(0, 50 - pref.length)) as Brand
       )
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const s: S.Schema<string & Brand, string> = StringId
+    const s: S.Schema<string & Brand> = StringId
       .pipe(
-        S.filter((x: StringId): x is string & Brand => x.startsWith(pref), {
+        S.refine((x: string): x is string & Brand => x.startsWith(pref), {
           arbitrary: arb,
           identifier: name,
           title: name
         })
-      )
+      ) as any
     const schema = s.pipe(withDefaultMake)
     const make = () => (pref + StringId.make().substring(0, 50 - pref.length)) as Brand
 
@@ -220,10 +217,10 @@ export const brandedStringId = <
   Brand extends StringIdBrand
 >() =>
   withDefaultMake(
-    Object.assign(Object.create(StringId), StringId) as S.Schema<string & Brand, string> & {
+    Object.assign(Object.create(StringId), StringId) as S.Schema<string & Brand> & {
       make: () => string & Brand
-      withDefault: S.PropertySignature<":", string & Brand, never, ":", string, true, never>
-    } & WithDefaults<S.Schema<string & Brand, string>>
+      withDefault: any
+    } & WithDefaults<S.Schema<string & Brand>>
   )
 
 export interface PrefixedStringUtils<
@@ -235,7 +232,7 @@ export interface PrefixedStringUtils<
   readonly unsafeFrom: (str: string) => Brand
   prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => Brand
   readonly prefix: Prefix
-  readonly withDefault: S.PropertySignature<":", Brand, never, ":", string, true, never>
+  readonly withDefault: any
 }
 
 export interface UrlBrand extends Simplify<B.Brand<"Url"> & NonEmptyStringBrand> {}
@@ -249,8 +246,8 @@ const isUrl: Refinement<string, Url> = (s: string): s is Url => {
 export const Url = S
   .String
   .pipe(
-    S.filter(isUrl, {
-      arbitrary: (): LazyArbitrary<Url> => (fc) => fc.webUrl().map((_) => _ as Url),
+    S.refine(isUrl, {
+      arbitrary: (): any => (fc: any) => fc.webUrl().map((_: any) => _ as Url),
       identifier: "Url",
       title: "Url",
       jsonSchema: { format: "uri" }

package/src/Schema/numbers.ts

@@ -10,7 +10,7 @@ export interface PositiveIntBrand
 {}
 export const PositiveInt = extendM(
   S.Int.pipe(
-    S.positive(),
+    S.check(S.isGreaterThan(0)),
     fromBrand(nominal<PositiveInt>(), { identifier: "PositiveInt", title: "PositiveInt", jsonSchema: {} }),
     withDefaultMake
   ),
@@ -21,7 +21,7 @@ export type PositiveInt = number & PositiveIntBrand
 export interface NonNegativeIntBrand extends Simplify<B.Brand<"NonNegativeInt"> & IntBrand & NonNegativeNumberBrand> {}
 export const NonNegativeInt = extendM(
   S.Int.pipe(
-    S.nonNegative(),
+    S.check(S.isGreaterThanOrEqualTo(0)),
     fromBrand(nominal<NonNegativeInt>(), {
       identifier: "NonNegativeInt",
       title: "NonNegativeInt",
@@ -43,7 +43,7 @@ export type Int = number & IntBrand
 export interface PositiveNumberBrand extends Simplify<B.Brand<"PositiveNumber"> & NonNegativeNumberBrand> {}
 export const PositiveNumber = extendM(
   S.Number.pipe(
-    S.positive(),
+    S.check(S.isGreaterThan(0)),
     fromBrand(nominal<PositiveNumber>(), {
       identifier: "PositiveNumber",
       title: "PositiveNumber",
@@ -60,7 +60,7 @@ export const NonNegativeNumber = extendM(
   S
     .Number
     .pipe(
-      S.nonNegative(),
+      S.check(S.isGreaterThanOrEqualTo(0)),
       fromBrand(nominal<NonNegativeNumber>(), {
         identifier: "NonNegativeNumber",
         title: "NonNegativeNumber",

package/src/Schema/phoneNumber.ts

@@ -13,11 +13,11 @@ export type PhoneNumber = string & PhoneNumberBrand
 export const PhoneNumber = S
   .String
   .pipe(
-    S.filter(isValidPhone as Refinement<string, PhoneNumber>, {
+    S.refine(isValidPhone as Refinement<string, PhoneNumber>, {
       identifier: "PhoneNumber",
       title: "PhoneNumber",
       description: "a phone number with at least 7 digits",
-      arbitrary: () => (fc) => Numbers(7, 10)(fc).map((_) => _ as PhoneNumber),
+      arbitrary: () => (fc: any) => Numbers(7, 10)(fc).map((_: any) => _ as PhoneNumber),
       jsonSchema: { format: "phone" }
     }),
     withDefaultMake

package/src/Schema/schema.ts

@@ -1,6 +1,5 @@
-import * as A from "effect/Arbitrary"
 import * as B from "effect/Brand"
-import * as P from "effect/ParseResult"
 import * as AST from "effect/SchemaAST"
+import * as P from "effect/SchemaParser"
 
-export { A, AST, B, P }
+export { AST, B, P }

package/src/Schema/strings.ts

@@ -22,7 +22,7 @@ export type NonEmptyString64k = string & NonEmptyString64kBrand
 export const NonEmptyString64k = S
   .NonEmptyString
   .pipe(
-    S.maxLength(64 * 1024),
+    S.check(S.isMaxLength(64 * 1024)),
     fromBrand(nominal<NonEmptyString64k>(), {
       identifier: "NonEmptyString64k",
       title: "NonEmptyString64k",
@@ -36,7 +36,7 @@ export type NonEmptyString2k = string & NonEmptyString2kBrand
 export const NonEmptyString2k = S
   .NonEmptyString
   .pipe(
-    S.maxLength(2 * 1024),
+    S.check(S.isMaxLength(2 * 1024)),
     fromBrand(nominal<NonEmptyString2k>(), {
       identifier: "NonEmptyString2k",
       title: "NonEmptyString2k",
@@ -50,7 +50,7 @@ export type NonEmptyString255 = string & NonEmptyString255Brand
 export const NonEmptyString255 = S
   .NonEmptyString
   .pipe(
-    S.maxLength(255),
+    S.check(S.isMaxLength(255)),
     fromBrand(nominal<NonEmptyString255>(), {
       identifier: "NonEmptyString255",
       title: "NonEmptyString255",