@softize/opus 8.6.6

package/src/schema/drivers/zod.ts

@@ -0,0 +1,765 @@
+/**
+ * @softize/opus/schema/zod — Zod-based logical type factories.
+ *
+ * Catálogo de factories que retornam `LogicalType<T>`: um objeto que carrega
+ * o schema Zod subjacente (`zod()`), metadata logical (`meta`), e os métodos
+ * `parse / format / validate` pra operar sobre instâncias do tipo canônico.
+ *
+ * Adapters (DB, UI, OpenAPI) continuam lendo a metadata via `getLogicalType()`
+ * sobre o schema Zod (recuperado por `.zod()`) pra mapear semântica em
+ * comportamento concreto.
+ *
+ * Uso:
+ *   import { z } from 'zod'
+ *   import { t } from '@softize/opus/schema/zod'
+ *
+ *   const Email = t.email()
+ *   Email.parse('  Foo@Bar.COM ')        // → 'foo@bar.com'
+ *   Email.validate('not-an-email')        // → { ok: false, error: '...' }
+ *
+ *   defineAction({
+ *     input: z.object({
+ *       email:  t.email().zod(),
+ *       amount: t.money({ currency: 'BRL' }).zod(),
+ *       paidAt: t.datetime().zod(),
+ *     }),
+ *   })
+ */
+
+import { z, type ZodTypeAny, type ZodSchema } from 'zod'
+import { attachLogicalType, type LogicalTypeMeta } from '../index.ts'
+import {
+  formatDatetime,
+  formatDate,
+  formatDecimal,
+  formatMoney,
+  parseDecimal,
+  parseMoney,
+} from '../format/locale.ts'
+
+// =============================================================================
+// Interface pública: LogicalType<T>
+// =============================================================================
+
+export type ValidateResult<T> =
+  | { ok: true; value: T }
+  | { ok: false; error: string }
+
+export interface FormatOptions {
+  locale?: string
+}
+
+export interface LogicalType<T> {
+  /** Schema Zod subjacente — pra reuso em z.object({ field: t.email().zod() }). */
+  zod(): ZodSchema<T>
+  /** Metadata: { logicalType, params? }. */
+  meta: LogicalTypeMeta
+  /** Parse de input cru (form value, query param, JSON) pro tipo canônico T. */
+  parse(input: unknown): T
+  /**
+   * Format pra display humano. Locale default 'pt-BR' onde aplicável
+   * (datetime, money, percent, decimal). Tipos string/url/uuid/etc
+   * retornam `String(value)`.
+   */
+  format(value: T, options?: FormatOptions): string
+  /** Validação completa. Retorna ok:true com valor parseado, ou ok:false com erro humano. */
+  validate(value: unknown): ValidateResult<T>
+
+  // — Modifiers de coluna (entidade) — encadeáveis, retornam novo LogicalType —
+  /** Metadata de coluna acumulada pelos modifiers. Lida pelo data/migration adapter. */
+  readonly column: ColumnMeta
+  /** Marca como primary key. Convenção: encadeie `.pk()` por último. */
+  pk(): LogicalType<T> & { readonly __pk: true }
+  /** Constraint UNIQUE. */
+  unique(): LogicalType<T>
+  /** Coluna NULL-able. Muda o tipo inferido pra `T | null`. */
+  nullable(): LogicalType<T | null>
+  /** Índice nesta coluna. `using` é hint de tipo (gin, etc) que o adapter resolve. */
+  index(opts?: { using?: string }): LogicalType<T>
+  /** Default no DDL (e no schema). Torna o campo opcional no insert. */
+  default(value: NonNullable<T>): LogicalType<T> & { readonly __hasDefault: true }
+  /** Foreign key pra outra entidade (por nome). `field` default = pk do alvo. */
+  references(entity: string, field?: string): LogicalType<T>
+  /** Doc de negócio do campo (a fonte de entendimento). Encadeável; flui pro manifest. */
+  doc(text: string): LogicalType<T>
+}
+
+/**
+ * Metadata de coluna acumulada pelos modifiers de entidade. Canal separado da
+ * validação (Zod): o data/migration adapter lê isto pra emitir o DDL.
+ */
+export interface ColumnMeta {
+  pk?: boolean
+  unique?: boolean
+  nullable?: boolean
+  index?: boolean | { using?: string }
+  hasDefault?: boolean
+  default?: unknown
+  references?: { entity: string; field?: string }
+  /** Doc de negócio do campo — a fonte de entendimento. Flui pro manifest/lente. */
+  doc?: string
+}
+
+// =============================================================================
+// Helper interno: build LogicalType
+// =============================================================================
+
+interface BuildArgs<T> {
+  logicalType: string
+  params?: Record<string, unknown>
+  zod: ZodSchema<T>
+  parse: (input: unknown) => T
+  format?: (value: T, options?: FormatOptions) => string
+}
+
+interface FieldCore<T> {
+  zod: ZodSchema<T>
+  meta: LogicalTypeMeta
+  parse: (input: unknown) => T
+  format: (value: T, options?: FormatOptions) => string
+}
+
+function build<T>(args: BuildArgs<T>): LogicalType<T> {
+  const meta: LogicalTypeMeta =
+    args.params === undefined
+      ? { logicalType: args.logicalType }
+      : { logicalType: args.logicalType, params: args.params }
+  // Mantém o contrato antigo: metadata anexada ao schema Zod também,
+  // pra adapters (openapi, db, ui) que leem via getLogicalType().
+  attachLogicalType(args.zod as unknown as object, meta)
+
+  const format = args.format ?? ((value: T): string => String(value))
+  return makeField({ zod: args.zod, meta, parse: args.parse, format }, {})
+}
+
+/**
+ * Constrói o `LogicalType` imutável a partir do core + metadata de coluna.
+ * Cada modifier (`pk`, `nullable`, ...) devolve um novo `LogicalType`, sem
+ * mutar o anterior — encadeamento é puro.
+ */
+function makeField<T>(core: FieldCore<T>, column: ColumnMeta): LogicalType<T> {
+  return {
+    zod: () => core.zod,
+    meta: core.meta,
+    parse: core.parse,
+    format: core.format,
+    column,
+    validate(value: unknown): ValidateResult<T> {
+      try {
+        const parsed = core.parse(value)
+        const result = core.zod.safeParse(parsed)
+        if (result.success) return { ok: true, value: result.data }
+        const issue = result.error.issues[0]
+        return { ok: false, error: humanizeIssue(issue) }
+      } catch (err) {
+        return { ok: false, error: humanizeError(err) }
+      }
+    },
+    pk: () =>
+      makeField(core, { ...column, pk: true }) as LogicalType<T> & {
+        readonly __pk: true
+      },
+    unique: () => makeField(core, { ...column, unique: true }),
+    nullable: () =>
+      makeField<T | null>(
+        {
+          zod: core.zod.nullable() as unknown as ZodSchema<T | null>,
+          meta: core.meta,
+          parse: (input) => (input === null || input === undefined ? null : core.parse(input)),
+          format: (value, options) => (value === null ? '' : core.format(value, options)),
+        },
+        { ...column, nullable: true },
+      ),
+    index: (opts) =>
+      makeField(core, {
+        ...column,
+        index: opts?.using !== undefined ? { using: opts.using } : true,
+      }),
+    default: (value) =>
+      makeField(core, { ...column, hasDefault: true, default: value }) as LogicalType<T> & {
+        readonly __hasDefault: true
+      },
+    references: (entity, field) =>
+      makeField(core, {
+        ...column,
+        references: field !== undefined ? { entity, field } : { entity },
+      }),
+    doc: (text) => makeField(core, { ...column, doc: text }),
+  }
+}
+
+function humanizeIssue(issue: z.ZodIssue | undefined): string {
+  /* v8 ignore next */
+  if (issue === undefined) return 'valor inválido'
+  return issue.message
+}
+
+function humanizeError(err: unknown): string {
+  /* v8 ignore next 2 */
+  if (!(err instanceof Error)) return 'valor inválido'
+  return err.message
+}
+
+// =============================================================================
+// Catálogo: primitivos
+// =============================================================================
+
+const string = (): LogicalType<string> =>
+  build({
+    logicalType: 'string',
+    zod: z.string(),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava string')
+    },
+  })
+
+const text = (): LogicalType<string> =>
+  build({
+    logicalType: 'text',
+    zod: z.string(),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava texto')
+    },
+  })
+
+const int = (): LogicalType<number> =>
+  build({
+    logicalType: 'int',
+    zod: z.number().int(),
+    parse: (input) => {
+      if (typeof input === 'number') return input
+      if (typeof input === 'string' && input.trim() !== '') {
+        const n = Number(input)
+        if (!Number.isNaN(n)) return n
+      }
+      throw new Error('esperava inteiro')
+    },
+  })
+
+const bigint_ = (): LogicalType<bigint> =>
+  build({
+    logicalType: 'bigint',
+    zod: z.bigint(),
+    parse: (input) => {
+      if (typeof input === 'bigint') return input
+      if (typeof input === 'number' && Number.isInteger(input)) return BigInt(input)
+      if (typeof input === 'string' && /^-?\d+$/.test(input.trim())) {
+        return BigInt(input.trim())
+      }
+      throw new Error('esperava bigint')
+    },
+  })
+
+interface DecimalParams {
+  precision?: number
+  scale?: number
+}
+
+const decimal = (params?: DecimalParams): LogicalType<string> => {
+  const zodSchema = z.string().regex(/^-?\d+(\.\d+)?$/, 'esperava decimal')
+  return build({
+    logicalType: 'decimal',
+    ...(params !== undefined ? { params: params as Record<string, unknown> } : {}),
+    zod: zodSchema,
+    parse: (input) => {
+      if (typeof input === 'number') return String(input)
+      if (typeof input === 'string') return parseDecimal(input)
+      throw new Error('esperava decimal')
+    },
+    format: (value, options) => formatDecimal(value, options?.locale),
+  })
+}
+
+const boolean = (): LogicalType<boolean> =>
+  build({
+    logicalType: 'boolean',
+    zod: z.boolean(),
+    parse: (input) => {
+      if (typeof input === 'boolean') return input
+      if (input === 1 || input === 0) return input === 1
+      if (typeof input === 'string') {
+        const v = input.trim().toLowerCase()
+        if (v === 'true' || v === '1') return true
+        if (v === 'false' || v === '0') return false
+      }
+      throw new Error('esperava boolean')
+    },
+  })
+
+const json = (): LogicalType<unknown> =>
+  build({
+    logicalType: 'json',
+    zod: z.unknown(),
+    parse: (input) => input,
+  })
+
+// =============================================================================
+// Catálogo: tempo
+// =============================================================================
+
+interface DatetimeParams {
+  precision?: 'second' | 'millisecond'
+  offset?: boolean
+}
+
+const datetime = (params?: DatetimeParams): LogicalType<string> => {
+  const options: { offset: boolean; precision?: number } = {
+    offset: params?.offset ?? true,
+  }
+  if (params?.precision === 'millisecond') options.precision = 3
+  const zodSchema = z.string().datetime(options)
+  return build({
+    logicalType: 'datetime',
+    ...(params !== undefined ? { params: params as Record<string, unknown> } : {}),
+    zod: zodSchema,
+    parse: (input) => {
+      if (input instanceof Date) return input.toISOString()
+      if (typeof input === 'string') return input
+      throw new Error('esperava datetime ISO ou Date')
+    },
+    format: (value, opts) => {
+      if (opts?.locale === undefined) return value
+      return formatDatetime(value, opts.locale)
+    },
+  })
+}
+
+const date = (): LogicalType<string> =>
+  build({
+    logicalType: 'date',
+    zod: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'esperava YYYY-MM-DD'),
+    parse: (input) => {
+      if (input instanceof Date) {
+        // Componentes UTC pra evitar drift de timezone.
+        const y = input.getUTCFullYear()
+        const m = String(input.getUTCMonth() + 1).padStart(2, '0')
+        const d = String(input.getUTCDate()).padStart(2, '0')
+        return `${y}-${m}-${d}`
+      }
+      if (typeof input === 'string') return input
+      throw new Error('esperava data')
+    },
+    format: (value, opts) => {
+      if (opts?.locale === undefined) return value
+      return formatDate(value, opts.locale)
+    },
+  })
+
+const time = (): LogicalType<string> =>
+  build({
+    logicalType: 'time',
+    zod: z
+      .string()
+      .regex(/^([01]\d|2[0-3]):[0-5]\d(:[0-5]\d)?$/, 'esperava HH:mm[:ss]'),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava time')
+    },
+  })
+
+const duration = (): LogicalType<string> =>
+  build({
+    logicalType: 'duration',
+    zod: z.string().duration(),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava duration ISO 8601')
+    },
+  })
+
+const timezone = (): LogicalType<string> =>
+  build({
+    logicalType: 'timezone',
+    zod: z
+      .string()
+      .regex(/^[A-Z][A-Za-z_]+\/[A-Z][A-Za-z_/]+$/, 'esperava IANA tz'),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava timezone')
+    },
+  })
+
+// =============================================================================
+// Catálogo: identificadores & formatos
+// =============================================================================
+
+const email = (): LogicalType<string> => {
+  const zodSchema = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .pipe(z.string().email('email inválido')) as unknown as ZodSchema<string>
+  return build({
+    logicalType: 'email',
+    zod: zodSchema,
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim().toLowerCase()
+      throw new Error('esperava email')
+    },
+  })
+}
+
+interface PhoneParams {
+  country?: string
+}
+
+const phone = (params?: PhoneParams): LogicalType<string> => {
+  const zodSchema = z
+    .string()
+    .regex(/^\+\d{8,15}$/, 'esperava telefone E.164 (+ e 8-15 dígitos)')
+  return build({
+    logicalType: 'phone',
+    ...(params !== undefined ? { params: params as Record<string, unknown> } : {}),
+    zod: zodSchema,
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim()
+      throw new Error('esperava telefone')
+    },
+  })
+}
+
+interface UrlParams {
+  protocols?: string[]
+}
+
+const url = (params?: UrlParams): LogicalType<string> => {
+  const allowed = new Set(params?.protocols ?? ['http', 'https'])
+  const zodSchema = z
+    .string()
+    .url('URL inválida')
+    .refine(
+      (value) => {
+        try {
+          return allowed.has(new URL(value).protocol.replace(':', ''))
+        } catch {
+          /* v8 ignore next */
+          return false
+        }
+      },
+      { message: `protocolo deve ser um de: ${[...allowed].join(', ')}` },
+    )
+  return build({
+    logicalType: 'url',
+    ...(params !== undefined ? { params: params as Record<string, unknown> } : {}),
+    zod: zodSchema as unknown as ZodSchema<string>,
+    parse: (input) => {
+      if (input instanceof URL) return input.toString()
+      if (typeof input === 'string') return input.trim()
+      throw new Error('esperava URL')
+    },
+  })
+}
+
+const uuid = (): LogicalType<string> =>
+  build({
+    logicalType: 'uuid',
+    zod: z.string().uuid('UUID inválido'),
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim().toLowerCase()
+      throw new Error('esperava UUID')
+    },
+  })
+
+const slug = (): LogicalType<string> =>
+  build({
+    logicalType: 'slug',
+    zod: z
+      .string()
+      .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'esperava slug kebab-case'),
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim()
+      throw new Error('esperava slug')
+    },
+  })
+
+// =============================================================================
+// Catálogo: domínio
+// =============================================================================
+
+interface MoneyParams {
+  currency?: string
+}
+
+const money = (params?: MoneyParams): LogicalType<bigint> => {
+  const currencyCode = params?.currency ?? 'BRL'
+  return build({
+    logicalType: 'money',
+    ...(params !== undefined ? { params: params as Record<string, unknown> } : {}),
+    zod: z.bigint(),
+    parse: (input) => {
+      if (typeof input === 'bigint') return input
+      if (typeof input === 'number' && Number.isInteger(input)) return BigInt(input)
+      if (typeof input === 'string') {
+        const cents = parseMoney(input)
+        if (cents !== null) return cents
+      }
+      throw new Error('esperava valor monetário')
+    },
+    format: (value, opts) => formatMoney(value, currencyCode, opts?.locale),
+  })
+}
+
+const currency = (): LogicalType<string> =>
+  build({
+    logicalType: 'currency',
+    zod: z.string().regex(/^[A-Z]{3}$/, 'esperava ISO 4217'),
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim().toUpperCase()
+      throw new Error('esperava código de moeda')
+    },
+  })
+
+const country = (): LogicalType<string> =>
+  build({
+    logicalType: 'country',
+    zod: z.string().regex(/^[A-Z]{2}$/, 'esperava ISO 3166 alpha-2'),
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim().toUpperCase()
+      throw new Error('esperava país')
+    },
+  })
+
+const locale_ = (): LogicalType<string> =>
+  build({
+    logicalType: 'locale',
+    zod: z.string().regex(/^[a-z]{2,3}(-[A-Z]{2})?$/, 'esperava locale BCP 47'),
+    parse: (input) => {
+      if (typeof input === 'string') return input.trim()
+      throw new Error('esperava locale')
+    },
+  })
+
+const percent = (): LogicalType<number> =>
+  build({
+    logicalType: 'percent',
+    // Convenção: 0..100 (display friendly). Schemas que queiram 0..1
+    // podem usar t.decimal() ou similar.
+    zod: z.number(),
+    parse: (input) => {
+      if (typeof input === 'number') return input
+      if (typeof input === 'string') {
+        const cleaned = input.trim().replace('%', '').replace(',', '.')
+        const n = Number(cleaned)
+        if (!Number.isNaN(n)) return n
+      }
+      throw new Error('esperava percent')
+    },
+    format: (value, opts) => {
+      const locale = opts?.locale ?? 'pt-BR'
+      return new Intl.NumberFormat(locale, {
+        style: 'percent',
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2,
+      }).format(value / 100)
+    },
+  })
+
+// =============================================================================
+// Catálogo: texto rico
+// =============================================================================
+
+const markdown = (): LogicalType<string> =>
+  build({
+    logicalType: 'markdown',
+    zod: z.string(),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava markdown')
+    },
+  })
+
+const html = (): LogicalType<string> =>
+  build({
+    logicalType: 'html',
+    zod: z.string(),
+    parse: (input) => {
+      if (typeof input === 'string') return input
+      throw new Error('esperava HTML')
+    },
+  })
+
+// =============================================================================
+// Catálogo: composição
+// =============================================================================
+
+const enum_ = <T extends [string, ...string[]]>(values: T): LogicalType<T[number]> => {
+  const zodSchema = z.enum(values)
+  return build<T[number]>({
+    logicalType: 'enum',
+    params: { values },
+    zod: zodSchema as unknown as ZodSchema<T[number]>,
+    parse: (input) => {
+      if (typeof input === 'string' && (values as readonly string[]).includes(input)) {
+        return input as T[number]
+      }
+      throw new Error(`esperava um de: ${values.join(', ')}`)
+    },
+  })
+}
+
+/**
+ * Aceita ZodSchema ou LogicalType<U>. Internamente extrai o Zod schema
+ * via `.zod()` quando recebe LogicalType.
+ */
+const array = <U>(of: LogicalType<U> | ZodTypeAny): LogicalType<U[]> => {
+  const inner = isLogicalType(of) ? of.zod() : (of as unknown as ZodSchema<U>)
+  const zodSchema = z.array(inner)
+  return build({
+    logicalType: 'array',
+    zod: zodSchema,
+    parse: (input) => {
+      if (Array.isArray(input)) return input as U[]
+      throw new Error('esperava array')
+    },
+  })
+}
+
+const object = <S extends z.ZodRawShape>(
+  shape: S,
+): LogicalType<z.infer<z.ZodObject<S>>> => {
+  const zodSchema = z.object(shape)
+  return build({
+    logicalType: 'object',
+    zod: zodSchema as unknown as ZodSchema<z.infer<z.ZodObject<S>>>,
+    parse: (input) => {
+      if (input !== null && typeof input === 'object') {
+        return input as z.infer<z.ZodObject<S>>
+      }
+      throw new Error('esperava objeto')
+    },
+  })
+}
+
+function isLogicalType(value: unknown): value is LogicalType<unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'zod' in value &&
+    typeof (value as { zod: unknown }).zod === 'function'
+  )
+}
+
+// =============================================================================
+// t.dict — primeira classe
+// =============================================================================
+
+/**
+ * Meta de cada chave de um dict. `label` obrigatório; resto livre. `doc` é o
+ * entendimento de negócio da chave (o que aquele estado significa, quando se
+ * entra/sai) — a fonte rica de consulta rápida; flui pro manifest/lente.
+ */
+export interface DictEntryMeta {
+  label: string
+  doc?: string
+  color?: string
+  icon?: string
+  order?: number
+  [key: string]: unknown
+}
+
+/**
+ * Option pronta pra UI: combina key + meta da entrada.
+ */
+export type DictOption<K extends string, M extends DictEntryMeta> = M & {
+  value: K
+}
+
+export interface DictType<K extends string, M extends DictEntryMeta> {
+  /** Schema Zod equivalente: `z.enum(keys)`. */
+  zod(): z.ZodEnum<[K, ...K[]]>
+  /** Metadata logical: { logicalType: 'dict', params: { keys, entries } }. */
+  meta: LogicalTypeMeta
+  /** Lista de chaves na ordem de declaração. */
+  keys(): K[]
+  /**
+   * Label da chave. Segundo arg é placeholder pra i18n — no v1 sempre retorna
+   * `entries[key].label` (locale ignorado). Documentado como dívida técnica.
+   */
+  labelFor(key: K, locale?: string): string
+  /** Meta completa da chave (label + extras). */
+  metaFor(key: K): M
+  /** Lista pronta pra `<Select options={...} />`: `{ value, ...meta }`. */
+  options(): DictOption<K, M>[]
+  /** True se `key` está no dict. */
+  has(key: string): key is K
+  /** Doc de negócio do dicionário inteiro (o que esse vocabulário representa). */
+  doc?: string
+}
+
+/** Opções do dict: `doc` = o entendimento do vocabulário como um todo. */
+export interface DictOpts {
+  doc?: string
+}
+
+const dict = <const M extends Record<string, DictEntryMeta>>(
+  entries: M,
+  opts?: DictOpts,
+): DictType<Extract<keyof M, string>, M[keyof M]> => {
+  type K = Extract<keyof M, string>
+  const keys = Object.keys(entries) as K[]
+  if (keys.length === 0) {
+    throw new Error('t.dict precisa de pelo menos uma entrada')
+  }
+  const zodSchema = z.enum(keys as [K, ...K[]])
+  const meta: LogicalTypeMeta = {
+    logicalType: 'dict',
+    params: { keys, entries, ...(opts?.doc !== undefined ? { doc: opts.doc } : {}) },
+  }
+  attachLogicalType(zodSchema as unknown as object, meta)
+
+  return {
+    zod: () => zodSchema,
+    meta,
+    ...(opts?.doc !== undefined ? { doc: opts.doc } : {}),
+    keys: () => [...keys],
+    labelFor: (key, _locale) => {
+      // _locale reservado pra i18n futuro; no v1 sempre retorna o label cru.
+      return (entries[key] as M[keyof M]).label
+    },
+    metaFor: (key) => entries[key] as M[keyof M],
+    options: () =>
+      keys.map((k) => ({
+        ...(entries[k] as M[keyof M]),
+        value: k,
+      })) as DictOption<K, M[keyof M]>[],
+    has: (key: string): key is K =>
+      Object.prototype.hasOwnProperty.call(entries, key),
+  }
+}
+
+// =============================================================================
+// Namespace exportado
+// =============================================================================
+
+export const t = {
+  string,
+  text,
+  int,
+  bigint: bigint_,
+  decimal,
+  boolean,
+  json,
+  datetime,
+  date,
+  time,
+  duration,
+  timezone,
+  email,
+  phone,
+  url,
+  uuid,
+  slug,
+  money,
+  currency,
+  country,
+  locale: locale_,
+  percent,
+  markdown,
+  html,
+  enum: enum_,
+  array,
+  object,
+  dict,
+} as const