export declare const compose: <A>(...transforms: Array<Transform<A>>) => Transform<A>

import { Schema, Effect, pipe } from "effect"
import { define, compose } from "effect-builder/Builder"

const UserSchema = Schema.Struct({
  name: Schema.String,
  age: Schema.Number,
  roles: Schema.Array(Schema.String).annotations({ default: ["user"] })
})

const User = define(UserSchema)

const result = Effect.gen(function* () {
  return yield* pipe(
    compose(
      User.name("John"),
      User.age(25),
      User.roles.modify((roles) => [...roles, "admin"])
    ),
    User.build
  )
}).pipe(Effect.runSync)

console.log("Created user:", result)
// {
//   name: "John",
//   age: 25,
//   roles: ["admin"]
// }

export declare const createBuilderLenses: <A>(schema: Schema.Struct<any>) => BuilderLens<A>

export declare const define: <F extends Schema.Struct.Fields>(
  schema: Schema.Struct<F>,
  defaults?: Partial<SchemaType<F>>
) => Builder<F, Schema.Schema.Context<F[keyof F]>>

import { Schema, Effect, pipe } from "effect"
import { define, compose } from "effect-builder/Builder"

const UserSchema = Schema.Struct({
  name: Schema.String
})

const User = define(UserSchema)

const result = Effect.gen(function* () {
  return yield* pipe(compose(User.name("John")), User.build)
}).pipe(Effect.runSync)

console.log("Created user:", result)
// {

export declare class BuilderError

export declare class ValidationError

export type Builder<F extends Schema.Struct.Fields, R> = BuilderOp<F, R> &
  Omit<BuilderLens<SchemaType<F>>, keyof BuilderOp<F, R>>

export type BuilderLens<A> = {
  readonly [K in keyof A]: {
    (value: A[K]): Transform<A>
    readonly get: (s: Partial<A>) => A[K] | undefined
    readonly modify: (f: (value: A[K]) => A[K]) => Transform<A>
  }
}

export interface BuilderOp<F extends Schema.Struct.Fields, R> {
  readonly schema: Schema.Struct<F>
  readonly Default: Partial<SchemaType<F>>
  readonly field: <K extends keyof SchemaType<F>>(key: K) => Lens<SchemaType<F>, SchemaType<F>[K]>
  readonly when: (
    predicate: (a: Partial<SchemaType<F>>) => boolean,
    ifTrue: Transform<SchemaType<F>>,
    ifFalse?: Transform<SchemaType<F>>
  ) => Transform<SchemaType<F>>
  readonly build: (transform: Transform<SchemaType<F>>) => Effect.Effect<SchemaType<F>, ValidationError, R>
}

export interface Lens<S, A> {
  readonly get: (s: Partial<S>) => A | undefined
  readonly set: <V extends A>(value: V) => Transform<S>
  readonly modify: (f: (value: A) => A) => Transform<S>
}

export type Transform<A> = (a: Partial<A>) => Partial<A>