pnpm add @validex/core zod   # core is required
pnpm add @validex/nuxt       # optional — Nuxt adapter
pnpm add @validex/fastify    # optional — Fastify adapter

import { Email } from '@validex/core'
const schema = Email()
schema.parse('hello@example.com') // OK
schema.parse('not-an-email')      // throws ZodError

import { Password } from '@validex/core'
const schema = Password({
  length: { min: 10 },
  uppercase: { min: 2 },
  blockCommon: 'basic',
})
schema.parse('ABcdefgh1!') // OK — 10+ chars, 2 uppercase, 1 digit, 1 special

import { z } from 'zod'
import { Email, Password, validate } from '@validex/core'
const schema = z.object({
  email: Email(),
  password: Password(),
})
const result = await validate(schema, {
  email: 'user@example.com',
  password: 'Str0ng!Pass',
})
if (result.success) {
  console.log(result.data) // typed as { email: string; password: string }
} else {
  console.log(result.errors)      // { email: ['...'], password: ['...'] }
  console.log(result.firstErrors) // { email: '...', password: '...' }
}

import { setup, Email, Password } from '@validex/core'
setup({
  rules: {
    email: { blockDisposable: true },
    password: { length: { min: 10 }, special: { min: 2 } },
  },
  i18n: {
    enabled: true,
    t: (key, params) => translate(key, params),
  },
})
// Rules now use your defaults — no need to pass options every time
const emailSchema = Email()
const passwordSchema = Password()

built-in defaults  <  setup() config  <  per-call options

import { setup, Email } from '@validex/core'
setup({ rules: { email: { blockDisposable: true } } })
Email()                              // blockDisposable: true (from setup)
Email({ blockPlusAlias: true })      // blockDisposable: true + blockPlusAlias: true
Email({ blockDisposable: undefined }) // blockDisposable removed for this call

import { resetConfig } from '@validex/core'
resetConfig() // resets to built-in defaults

import { preloadData } from '@validex/core'
await preloadData({
  disposable: true,
  passwords: 'moderate',
  reserved: true,
  phone: 'mobile',
  countryCodes: true,
  currencyCodes: true,
  ibanPatterns: true,
  vatPatterns: true,
  creditCardPrefixes: true,
  postalCodes: true,
})

import { z } from 'zod'
import { Password, sameAs } from '@validex/core'
const schema = z.object({
  password: Password(),
  confirmPassword: z.string(),
}).superRefine(sameAs('confirmPassword', 'password', {
  message: 'Passwords do not match',
}))

import { z } from 'zod'
import { Password, PasswordConfirmation, validate } from '@validex/core'
const schema = z.object({
  password: Password(),
  confirmPassword: PasswordConfirmation(),
})
const result = await validate(schema, {
  password: 'Str0ng!Pass',
  confirmPassword: 'different',
})
// result.firstErrors.confirmPassword → "Password Confirmation must match Password"

import { z } from 'zod'
import { requiredWhen } from '@validex/core'
const schema = z.object({
  accountType: z.string(),
  companyName: z.string().optional(),
}).superRefine(requiredWhen(
  'companyName',
  (data) => data['accountType'] === 'business',
  { message: 'Company name is required for business accounts' },
))

// safeParse — field-level only, no cross-field
const zodResult = schema.safeParse(data)
// validate — runs field-level + cross-field
const result = await validate(schema, data)

import { z } from 'zod'
import '@validex/core'
const schema = z.string().hasUppercase({ min: 2 }).noSpaces().toSlug()

import { hasUppercase, containsEmail, toSlug } from '@validex/core/checks'
hasUppercase('Hello', 1)    // true
containsEmail('hi@test.com') // true
toSlug('Hello World!')       // 'hello-world'

ctx.addIssue({
  code: 'custom',
  params: {
    code: 'disposableBlocked',
    namespace: 'email',
    label: 'Email',
    domain: 'tempmail.com',
  },
})

import { Email, getParams } from '@validex/core'
const schema = Email()
const result = schema.safeParse('user@tempmail.com')
if (!result.success) {
  const params = getParams(result.error.issues[0])
  // { code: 'disposableBlocked', namespace: 'email', label: 'Email',
  //   key: 'validation.messages.email.disposableBlocked', path: [], ... }
}

interface ValidationResult<T> {
  readonly success: boolean
  readonly data?: T                                    // typed parsed data (when success)
  readonly errors: Record<string, readonly string[]>   // dot-path to all messages
  readonly firstErrors: Record<string, string>         // dot-path to first message
  readonly nestedErrors: NestedErrors                  // nested object matching schema shape
  readonly issues: ReadonlyArray<unknown>              // raw Zod issues (escape hatch)
}

import { setup } from '@validex/core'
setup({
  i18n: {
    enabled: true,
    prefix: 'validation',    // default
    separator: '.',          // default
    t: (key, params) => i18next.t(key, params),
  },
})

setup({
  label: {
    fallback: 'derived',  // 'derived' | 'generic' | 'none'
    transform: ({ path, fieldName, defaultLabel }) => {
      return myLabelLookup(fieldName) ?? defaultLabel
    },
  },
})

npx validex fr de --output ./locales
npx validex ja --empty --output ./locales

import { createRule } from '@validex/core'
import { z } from 'zod'
interface HexColorOptions {
  label?: string
  emptyToUndefined?: boolean
  normalize?: boolean
  customFn?: (value: string) => true | string | Promise<true | string>
  allowAlpha?: boolean
}
const HexColor = createRule<HexColorOptions>({
  name: 'hexColor',
  defaults: { allowAlpha: false },
  build: (opts) => {
    const pattern = opts.allowAlpha
      ? /^#[\da-f]{6,8}$/i
      : /^#[\da-f]{6}$/i
    return z.string().regex(pattern)
  },
  messages: {
    invalid: '{{label}} is not a valid hex color',
  },
})
const schema = HexColor({ allowAlpha: true })
schema.parse('#ff00aacc') // OK

import { Email } from '@validex/core'
const schema = Email({
  customFn: (value) => value.endsWith('.org') || 'Must be a .org domain',
})
schema.parse('info@example.org')  // OK
schema.parse('info@example.com')  // throws — "Must be a .org domain"

import { Text } from '@validex/core'
const schema = Text({
  regex: /^[^<>]+$/,
})

pnpm add @validex/nuxt

// nuxt.config.ts
export default defineNuxtConfig({
  modules: ['@validex/nuxt'],
  validex: {
    rules: { email: { blockDisposable: true } },
  },
})

// In a component — useValidation is auto-imported
const { validate, errors, firstErrors, isValid } = useValidation(schema)

pnpm add @validex/fastify

import Fastify from 'fastify'
import { validexPlugin } from '@validex/fastify'
const app = Fastify()
await app.register(validexPlugin, {
  rules: { email: { blockDisposable: true } },
})