@temelyos/zod 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -1,501 +1,25 @@
-import { ZodArray, ZodCatch, ZodCodec, ZodDate, ZodDefault, ZodEnum, ZodFile, ZodIntersection, ZodLazy, ZodNonOptional, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodPipe, ZodPromise, ZodRawShape, ZodRecord, ZodString, ZodSuccess, ZodTransform, ZodType, ZodUnion, ZodUnknown, core, z } from "zod";
-export interface NumberBounds {
-  integer?: boolean;
-  max?: number;
-  min?: number;
-}
-/** A number, optionally whole and bounded; a refusal names its bounds as the message's `{0}` and `{1}`. */
-export declare function boundedNumber({ integer, max, min }: NumberBounds): z.ZodNumber;
-/** The schemas {@link withCodecParts} named for a codec; undefined for any other schema. */
-export declare function codecParts(schema: ZodType): readonly ZodType[] | undefined;
-/**
- * A codec that builds its schemas at run time (from a model's fields, or a result's columns),
- * with those schemas named, so a reader can check what it encodes and decodes its values by.
- */
-export declare function withCodecParts<T extends ZodType>(codec: T, schemas: readonly ZodType[]): T;
-/** A lower-case ISO 4217 code: `usd`, never `USD` or `$`. */
-export declare const CurrencyCodePattern: RegExp;
-/** A field that takes a lower-case ISO 4217 code. `missing` is the caller's, for a field nobody filled in. */
-export declare function currencyCode(missing: string, invalid?: string): z.ZodString;
-export interface GetZodFieldPathsOptions {
-  /**
-   * When `true`, arrays are treated as terminal leaves and NOT descended (no
-   * `items.token`-style paths are emitted). Defaults to `false` — arrays are
-   * descended via their element type, matching how `getPathValues` fans out
-   * across arrays at runtime.
-   *
-   * Callers whose downstream path-consumer cannot fan out across arrays — e.g.
-   * `getSensitivePaths`, whose redact step (`splitSensitive`) walks plain objects
-   * only and would silently skip an array-borne path — should set this to `true`.
-   */
-  skipArrays?: boolean;
-}
-export interface ZodFieldPath {
-  /** The field's schema as its object declares it, wrappers kept: what says whether it may be absent. */
-  declared: ZodType;
-  /** Dotted path to the field within the schema, e.g. `auth.apiKey`. */
-  path: string;
-  /** The field's schema with wrapper types (see `unwrapField`) removed. A codec is left whole: ask `isDateSchema` what it holds. */
-  schema: ZodType;
-}
-/**
- * Enumerates the dotted paths of every field reachable by descending `ZodObject`
- * shapes and the branches of `ZodUnion` / `ZodDiscriminatedUnion` (Zod v4 reports
- * both as `def.type === 'union'`). A field declared in more than one union branch
- * is reported once per branch — callers that need uniqueness should dedupe by
- * `path`.
- *
- * Wrapper types (optional/nullable/default/catch/nonoptional/prefault/readonly/lazy) are always unwrapped.
- * Arrays are descended via their element type by default (emitting non-indexed
- * paths like `items.token`, the way `getPathValues` fans out at runtime); pass
- * `{ skipArrays: true }` to stop at arrays instead. Records and other leaves are
- * never descended. Each field is reported with its unwrapped `schema`, which lets
- * callers read per-field metadata (e.g. `sensitive()` markers) without re-walking
- * wrappers, and as its object `declared` it, wrappers kept, which says whether it
- * may be absent (`isOptionalOutput`).
- *
- * The schema-space analogue of `getPathValues` (which extracts values at a path
- * from a runtime object).
- */
-export declare function getZodFieldPaths(schema: ZodType, options?: GetZodFieldPathsOptions): ZodFieldPath[];
-/**
- * Unwraps optional/nullable/default/catch/nonoptional/prefault/readonly/lazy wrappers. Unlike `getInnerType`,
- * arrays are unwrapped to their element type only when `shouldSkipArrays` is
- * false; when true it stops at arrays, leaving them terminal.
- *
- * A wrapper chain that closes on itself (`const Self = z.lazy(() => Self.array())`
- * unwraps lazy → array → lazy → …) stops at the node that repeats — it has no
- * inner type left to reach. The guard has to live here: `collectFieldPaths`'s own
- * one is only consulted after unwrapping has already returned. `seen` is per
- * top-level call, so it never suppresses an unrelated sibling.
- */
-export declare function unwrapField(schema: ZodType, shouldSkipArrays: boolean, seen?: Set<ZodType>): ZodType;
-export type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
-export type UnwrapZodType<T> = T extends ZodOptional<infer U> ? UnwrapZodType<U> : T extends ZodNullable<infer U> ? UnwrapZodType<U> : T extends ZodDefault<infer U> ? UnwrapZodType<U> : T extends ZodCatch<infer U> ? UnwrapZodType<U> : T extends ZodLazy<infer U> ? UnwrapZodType<U> : T extends ZodArray<infer U> ? ZodArray<UnwrapZodType<U>> : T;
-export type ZodWrapper = ZodCatch | ZodDefault | ZodLazy | ZodNonOptional | ZodNullable | ZodOptional | ZodPromise | ZodSuccess;
-interface BaseFieldSettings<T> {
-  default?: T;
-  isOptional?: boolean;
-  isVisible?: boolean;
-  label?: string;
-}
-declare const stringFieldSettingsSchema: ZodObject<{
-  default: z.ZodOptional<ZodString>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  maxLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  minLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  regExp: z.ZodOptional<z.ZodUnion<readonly [z.ZodInstanceOf<RegExp>, ZodObject<{
-    message: ZodString;
-    value: z.ZodInstanceOf<RegExp>;
-  }, core.$strip>]>>;
-}, core.$strip>;
-type StringFieldSettings = z.infer<typeof stringFieldSettingsSchema>;
-declare const numberFieldSettingsSchema: ZodObject<{
-  default: z.ZodOptional<ZodNumber>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  max: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  min: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-}, core.$strip>;
-type NumberFieldSettings = z.infer<typeof numberFieldSettingsSchema>;
-declare const fileFieldSettingsSchema: ZodObject<{
-  default: z.ZodOptional<z.ZodInstanceOf<File>>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  maxBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  minBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-}, core.$strip>;
-type FileFieldSettings = z.infer<typeof fileFieldSettingsSchema>;
-declare const dropdownFieldSettingsSchema: ZodObject<{
-  default: z.ZodOptional<ZodString>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  values: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<ZodString>, z.ZodRecord<ZodString, z.ZodUnion<readonly [ZodString, ZodNumber]>>]>>;
-}, core.$strip>;
-type DropdownFieldSettings = z.infer<typeof dropdownFieldSettingsSchema>;
-export declare const AnyFieldSettingsSchema: z.ZodUnion<readonly [ZodObject<{
-  default: z.ZodOptional<ZodString>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  maxLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  minLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  regExp: z.ZodOptional<z.ZodUnion<readonly [z.ZodInstanceOf<RegExp>, ZodObject<{
-    message: ZodString;
-    value: z.ZodInstanceOf<RegExp>;
-  }, core.$strip>]>>;
-}, core.$strip>, ZodObject<{
-  default: z.ZodOptional<ZodNumber>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  max: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  min: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-}, core.$strip>, ZodObject<{
-  default: z.ZodOptional<z.ZodInstanceOf<File>>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  maxBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-  minBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
-    message: ZodString;
-    value: ZodNumber;
-  }, core.$strip>]>>;
-}, core.$strip>, ZodObject<{
-  default: z.ZodOptional<ZodString>;
-  isOptional: z.ZodOptional<z.ZodBoolean>;
-  isVisible: z.ZodOptional<z.ZodBoolean>;
-  label: z.ZodOptional<ZodString>;
-  values: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<ZodString>, z.ZodRecord<ZodString, z.ZodUnion<readonly [ZodString, ZodNumber]>>]>>;
-}, core.$strip>]>;
-type AnyFieldSettings = z.infer<typeof AnyFieldSettingsSchema>;
-type FieldSettings<T extends ZodObject<ZodRawShape>> = { [K in keyof T['shape']]?: UnwrapZodType<T['shape'][K]> extends ZodString ? StringFieldSettings : UnwrapZodType<T['shape'][K]> extends ZodNumber ? NumberFieldSettings : UnwrapZodType<T['shape'][K]> extends ZodEnum<any> ? DropdownFieldSettings : UnwrapZodType<T['shape'][K]> extends ZodFile ? FileFieldSettings : BaseFieldSettings<z.infer<T['shape'][K]>>; };
-export declare function applyFieldSettings<T extends ZodRawShape>(schema: ZodObject<T>, fields?: FieldSettings<ZodObject<T>>): ZodObject<T>;
-/** Text whose every `{token}` names one of `keys`, with no stray braces. */
-export declare function formatTemplate(keys: readonly string[]): z.ZodString;
-/**
- * Twenty-four lower-case hex characters: the shape of every id on the wire and in a zod model.
- *
- * Named for the shape rather than for Mongo, because the shape is all a model can see — the
- * Mingo driver mints the same ids without Mongo anywhere near them. Lower case only, which is
- * what every driver here produces, so anything else is a value nothing in the platform minted.
- */
-export declare const HexString24Pattern: RegExp;
-/** What an id field says when nothing was chosen, and when what came is not an id. */
-export interface HexString24Messages {
-  /** Defaults to "Invalid id.". */
-  invalid?: string;
-  /** `false` when nothing chosen is an answer: absent, `null` and `''` then all read as unset. */
-  missing: false | string;
-}
-/**
- * A field holding one id.
- *
- * The message is the CALLER's, as `timeZone`'s is: "Select an owner." belongs to the form asking
- * for an owner, not here. It answers for nothing chosen: absent, `null`, or the empty string a
- * cleared select sends. A value that is there but is not an id says "Invalid id.", or `invalid`
- * when the caller names one. Left out entirely, zod says what it says about a pattern, which is
- * unreadable, and the reason a request schema should pass one.
- *
- * `{ missing: false }`, or `false` for short, is the field that may be left unset: absent, `null`
- * and `''` pass through as they came, so the repository can tell a clear (`''`) from a field left
- * alone.
- */
-export declare function hexString24(messages?: string | {
-  invalid?: string;
-  missing: string;
-}): z.ZodString;
-export declare function hexString24(messages: false | {
-  invalid?: string;
-  missing: false;
-}): z.ZodOptional<z.ZodNullable<z.ZodString>>;
-/**
- * An id with nothing said about whose it is.
- *
- * For a stored model, where the field is a shape rather than a question put to a person: a
- * polymorphic subject's `id`, a join's `_id`. A request that a person fills in wants
- * `hexString24(message)` instead, so a mistyped id reads as something other than a regex.
- */
-export declare const HexString24: z.ZodString;
-/** Whether a field holds a date: `z.date()`, an {@link isoDate} or an {@link isoDay}, under any wrappers. */
-export declare function isDateSchema(schema: ZodType): boolean;
-/**
- * A date field that also takes its ISO date-time string, as a value that came through JSON
- * arrives.
- *
- * Typed `Date` on both sides although it accepts a string at runtime: a form validator is a
- * `StandardSchemaV1<FormValues>`, and `z.input` reading `string | Date` would fail it. The cost
- * is `z.encode`, whose declared result is `Date` but which returns the ISO string, which only
- * matters where a value is about to be serialized.
- *
- * A factory, so each field has its own instance to describe, wrap and default. A `message`
- * replaces the refusal's, as `z.date(message)` does.
- */
-export declare function isoDate(message?: string): z.ZodCodec<z.ZodCustom<Date, Date>, z.ZodDate>;
-/**
- * A calendar day: `YYYY-MM-DD` on the wire, that day's UTC midnight as a `Date`, and the UTC day
- * again when encoded. Typed `Date` on both sides, as {@link isoDate} is, and marked `dateOnly`,
- * the metadata a date-only field carries.
- *
- * Refuses anything else (a date-time, a day no calendar has, a `Date` with a time of day) with
- * the issue `z.date()` raises, or `message`.
- */
-export declare function isoDay(message?: string): z.ZodCodec<z.ZodCustom<Date, Date>, z.ZodDate>;
-/** JSON held as text, strict or loose (`parseLooseJson`). A blank value is left to the field's own required rule. */
-export declare const JsonText: z.ZodString;
-/** The values of an enum field, or of the elements of an array of one. */
-type EnumValue<T extends z.ZodType> = Extract<z.output<T> extends readonly (infer TElement)[] ? TElement : z.output<T>, string>;
-/** How a field is named where the product names fields generically, such as the workflow criteria editor. */
-export interface FieldLabel<TValue extends string = string> {
-  /** A dictionary key naming each value of an enum field, by value. */
-  options?: Record<TValue, string>;
-  /** The kind of record the value is the id of, such as `users`; the editor offers a search of that kind for it. */
-  reference?: string;
-  /** A dictionary key naming the field. */
-  title: string;
-}
-/** The label a field carries, read through the optional/nullable/default wrappers declared around it. */
-export declare function fieldLabel(schema: z.ZodType): FieldLabel | undefined;
-/** A field, labelled. The label carries into the JSON Schema; validation is unchanged. */
-export declare function labelled<T extends z.ZodType>(schema: T, label: FieldLabel<EnumValue<T>>): T;
-/**
- * A field that takes an ISO 639-1 language, optionally with its region (`fr`, `fr-CA`), that
- * this runtime can name.
- *
- * The message is the caller's, as `timeZone`'s is: the i18n extractor harvests a plain zod
- * message where it is written. `whenEmpty` is separate for a form that distinguishes a field
- * nobody filled in from one filled in wrongly; left out, one message answers for both.
- */
-export declare function languageCode(message: string, whenEmpty?: string): z.ZodString;
-/** Text in each language, by language code: `{ en: 'Sales', fr: 'Ventes' }`. */
-export type LocalizedString = Record<string, string>;
-export type LocalizedStringArray = Record<string, string[]>;
-/**
- * A localized value with nothing said about it: any record of language → text, blank included.
- *
- * For a stored model, where a row saved before a rule must still read. A field a person fills
- * in wants `localizedString(messages)` instead, so a blank one is refused in words.
- */
-export declare const LocalizedString: z.ZodRecord<z.ZodString, z.ZodString>;
-export declare const LocalizedStringArray: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
-/** As {@link LocalizedString}, or a plain string — what a write model takes for a localized field. */
-export declare const LocalizedStringInput: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
-export declare const LocalizedStringArrayInput: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>]>;
-export type LocalizedStringArrayInput = z.infer<typeof LocalizedStringArrayInput>;
-export type LocalizedStringInput = z.infer<typeof LocalizedStringInput>;
-/** What a localized field says when it has no text, and when what came is not text at all. */
-export interface LocalizedStringMessages {
-  invalid: string;
-  /** `false` when no text is an answer: absent, `null` and blank then all read as unset. */
-  missing: false | string;
-}
-/**
- * Whether a localized value has text: a string that isn't blank, or text in at least one
- * language. `undefined`, `null`, `''`, `'   '`, `{}` and `{ en: '', fr: ' ' }` have none.
- */
-export declare function hasLocalizedText(value: unknown): boolean;
-/** Whether a localized value is at most `max` characters, as a string or in every language it names. */
-export declare function isLocalizedTextWithin(value: unknown, max: number): boolean;
-/**
- * A form's localized field — a record, one entry per language — that needs text in some language.
- *
- * The messages are the CALLER's, as `hexString24`'s are: "Name is required." belongs to the form
- * asking for a name.
- *
- * One message answers for every case. `{ missing, invalid }` tells them apart: `missing` for no
- * text at all — absent, `null`, or blank in every language — and `invalid` for a value that is
- * there but is not text.
- *
- * `{ missing: false, invalid }` is the field that may be left empty: absent, `null` and blank
- * pass through as they came, so the repository can tell a clear from a field left alone.
- */
-export declare function localizedString(messages?: string | {
-  invalid: string;
-  missing: string;
-}): typeof LocalizedString;
-export declare function localizedString(messages: {
-  invalid: string;
-  missing: false;
-}): z.ZodOptional<z.ZodNullable<typeof LocalizedString>>;
-/**
- * A model's localized field — a record or a plain string — that needs text in some language, with
- * {@link localizedString}'s forms and messages; on a `partial()` update model, whenever it is sent.
- * The refine guards the endpoint only: repository writes skip refines.
- */
-export declare function localizedStringInput(messages?: string | {
-  invalid: string;
-  missing: string;
-}): typeof LocalizedStringInput;
-export declare function localizedStringInput(messages: {
-  invalid: string;
-  missing: false;
-}): z.ZodOptional<z.ZodNullable<typeof LocalizedStringInput>>;
-/**
- * The write-model fields that let a required localized name through blank — for a guard spec to
- * assert is empty.
- *
- * For every exported model `X` with an `AddX` or `UpdateX` beside it: a field `X` requires, and
- * that takes both a string and a locale record, is a required localized name. Its write models
- * must refuse `''` and `{ en: '' }`, which {@link localizedStringInput} does. Returns
- * `UpdateRole.name`-style paths for each one that doesn't. Read from the schemas rather than the
- * source, so it sees what a write actually accepts.
- */
-export declare function findUncheckedLocalizedFields(models: Record<string, unknown>): string[];
-/**
- * Recursively merges two ZodRawShape objects into a single shape,
- * combining overlapping keys into unions where applicable.
- */
-export type ZodMergeShapes<T extends ZodRawShape, U extends ZodRawShape> = { [K in keyof T | keyof U]: K extends keyof T & keyof U ? T[K] extends ZodObject<ZodRawShape> ? U[K] extends ZodObject<ZodRawShape> ? ZodObject<ZodMergeShapes<T[K]['shape'], U[K]['shape']>> : T[K] | U[K] : T[K] | U[K] : K extends keyof T ? T[K] : K extends keyof U ? U[K] : never; };
-/**
- * Adds a Zod type to an existing ZodUnion.
- */
-export declare function addToUnion<TUnion extends ZodUnion, TAny extends ZodType>(union: TUnion, object: TAny): ZodUnion;
-/**
- * Deeply merges two ZodRawShape objects into one.
- */
-export declare function mergeShapes<T extends ZodRawShape, U extends ZodRawShape>(shapeA: T, shapeB: U): ZodMergeShapes<T, U>;
-export declare function nullish<TShape extends Record<string, z.ZodType>>(fields: z.ZodObject<TShape>): z.ZodObject<{ -readonly [P in keyof { [TKey in keyof TShape]: z.ZodOptional<z.ZodNullable<TShape[TKey]>>; }]: { [TKey in keyof TShape]: z.ZodOptional<z.ZodNullable<TShape[TKey]>>; }[P]; }, z.core.$strip>;
-/**
- * Whether {@link toFieldPath} can follow `path` through `schema`: every segment is reached through objects and
- * arrays (and the wrappers and unions around them), with no pipe, transform, intersection, tuple, record or loose
- * (`any`, `unknown`, `custom`) node before the last. The path may end at one.
- */
-export declare function isFollowablePath(schema: ZodType, path: string): boolean;
-/**
- * `path` with `.$[]` after every segment that `schema` types as an array, except the last:
- * `settings.pages.defaultAccessLevels` -> `settings.pages.$[].defaultAccessLevels`. Returns
- * `path` unchanged when no segment before the last is an array.
- *
- * At a union, every arm is followed; a segment is an array when any arm types it as one.
- */
-export declare function toAllPositionalPath(schema: ZodType, path: string): string;
-/**
- * The field path `path` names in `schema`, its array positions left out:
- * `lines.0.attachments.$[].title` -> `lines.attachments.title`. A numeric segment is dropped
- * only where `schema` has an array, so a record's key stays: `budgets.2026` is unchanged.
- * `$`, `$[]` and `$[id]` are always positions.
- */
-export declare function toFieldPath(schema: ZodType, path: string): string;
-export declare const RegExpPattern: z.ZodString;
-/** A key, identifier or channel in {@link SlugPattern}. `missing` is the field's own message for an empty value, and the only one an empty value gets. */
-export declare function slug(missing?: string): z.ZodString;
-/** A slug with nothing said about an empty value beyond what any other wrong value gets. */
-export declare const Slug: z.ZodString;
-export declare function stripEmptyFields<T extends ZodType>(schema: T, values: z.input<T>): z.infer<T>;
-/**
- * `value` cut down to the fields `schema` declares, at every depth: through arrays, optionals, nullables, defaults,
- * catches, lazies and the objects of a union or an intersection, merged. Nothing is parsed, so no checks, codecs or defaults run, and a
- * value that doesn't fit its field is copied as it is. `value` itself is picked by its keys, whatever its prototype.
- */
-export declare function stripToSchema<T extends z.ZodObject>(schema: T, value: object): z.output<T>;
-/**
- * A field that takes an IANA zone this runtime can actually format in.
- *
- * The check belongs at the write boundary: an unsupported zone is stored happily and then
- * throws a `RangeError` inside `Intl` on every later read, far from whatever put it there.
- *
- * The message is the CALLER's, as `objectId`'s is, for two reasons. A domain says what it
- * wants in its own words — "Select a valid time zone." on a form, "Invalid time zone." on a
- * public booking — and the i18n extractor harvests a plain zod message where it is written,
- * so a sentence buried in here would reach no dictionary. `whenEmpty` is separate for a form
- * that distinguishes a field nobody filled in from one filled in wrongly; left out, one
- * message answers for both.
- */
-export declare function timeZone(message: string, whenEmpty?: string): z.ZodString;
-/**
- * A JSON Schema document, as {@link toJsonSchema} produces.
- *
- * An object rather than `unknown` because these schemas exist to be READ: an editor
- * walks `properties` to build its field pickers. As `unknown`, every consumer casts
- * before it can index - at exactly the boundary that was supposed to describe the value.
- *
- * Deliberately not modelled more precisely than "a JSON object". JSON Schema is
- * recursive and open-ended, and restating its grammar here would be a second, worse
- * copy of a specification we do not own.
- */
-export declare const JsonSchemaDocument: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-export type JsonSchemaDocument = z.infer<typeof JsonSchemaDocument>;
-export interface ToJsonSchemaOptions {
-  /** Describe what the schema accepts (`input`) or what it produces (`output`, the default). */
-  io?: 'input' | 'output';
-  /**
-   * What to do with a type JSON Schema cannot describe (bigint, Map, a transform...).
-   * `throw`, the default, fails the conversion; `any` describes it as `{}`, for a
-   * consumer that would rather offer a loose schema than none.
-   */
-  unrepresentable?: 'any' | 'throw';
-}
-/**
- * `z.toJSONSchema`, with dates described rather than refused.
- *
- * zod has no JSON Schema for `z.date()` and throws on it by default, so one date field
- * anywhere in a schema fails the whole conversion - which is how one event with a
- * `startAt` blanked the workflow editor, and why every domain model's schema endpoint
- * answered 500. Here a date is `{ type: 'string', format: 'date-time' }`, the node
- * `z.iso.datetime()` produces, so a reader sees the same field either way, and an
- * `isoDate()` reads the same as `z.date()` on either side; an `isoDay()` is a `format: 'date'`
- * string on either side. The value
- * itself is untouched: a schema that takes a `Date` still takes a `Date`.
- *
- * Use this rather than `z.toJSONSchema`; the lint rule `no-restricted-properties`
- * points there.
- */
-export declare function toJsonSchema(schema: z.ZodType, options?: ToJsonSchemaOptions): JsonSchemaDocument;
-export declare const ZOD_WRAPPER_TYPES: string[];
-export declare function getInnerType(schema: ZodType): ZodType;
-export declare function isFieldNullable(schema: ZodType): boolean;
-/**
- * Whether `schema` is declared `.optional()`, looking only through `.optional()` and `.nullable()`: what a form or a
- * write may leave empty. For whether a parsed value may lack the field, through any wrapper, use {@link isOptionalOutput}.
- */
-export declare function isFieldOptional(schema: ZodType): boolean;
-/**
- * Whether a value typed by what `schema` outputs may lack the field: optional through any wrapper (lazy, readonly, a
- * union with an optional member), as zod decides it, not filled by a default; and `any` or `unknown`, whose type takes
- * `undefined` already. What a read typed by the schema may lack; for a field declared `.optional()`, {@link isFieldOptional}.
- */
-export declare function isOptionalOutput(schema: ZodType): boolean;
-export declare function isZodAny(obj: unknown): obj is ZodType;
-export declare function isZodArray(obj: unknown): obj is ZodArray<ZodType>;
-export declare function isZodCatch<T extends ZodType>(obj: unknown): obj is ZodCatch<T>;
-/** A codec, as `z.codec` builds: a pipe that can also run backwards. Read it as its `out`, what it decodes to. */
-export declare function isZodCodec(obj: unknown): obj is ZodCodec;
-export declare function isZodDate(obj: unknown): obj is ZodDate;
-export declare function isZodDefault(obj: unknown): obj is ZodDefault;
-export declare function isZodEnum(obj: unknown): obj is ZodEnum;
-export declare function isZodIntersection(obj: unknown): obj is ZodIntersection<ZodType, ZodType>;
-export declare function isZodLazy(obj: unknown): obj is ZodLazy;
-export declare function isZodNullable(obj: unknown): obj is ZodNullable<ZodType>;
-export declare function isZodNumber(obj: unknown): obj is ZodNumber;
-export declare function isZodObject(obj: unknown, isLoose?: boolean): obj is ZodObject;
-export declare function isZodObjectLoose(obj: ZodObject): boolean;
-export declare function isZodOptional(obj: unknown): obj is ZodOptional<ZodType>;
-export declare function isZodPipe(obj: unknown): obj is ZodPipe;
-export declare function isZodRecord(obj: unknown): obj is ZodRecord;
-export declare function isZodString(obj: unknown): obj is ZodString;
-export declare function isZodTransform(obj: unknown): obj is ZodTransform;
-export declare function isZodType(obj: unknown): obj is ZodType;
-export declare function isZodUnion(obj: unknown): obj is ZodUnion<ZodType[]>;
-export declare function isZodUnknown(obj: unknown): obj is ZodUnknown;
-export declare function isZodWrapper(obj: unknown): obj is ZodWrapper;
-export declare const NonNegativeInteger: import("zod").ZodNumber;
-export declare const PositiveInteger: import("zod").ZodNumber;
-export type { AnyFieldSettings, DropdownFieldSettings, FieldSettings, NumberFieldSettings, StringFieldSettings };
+import { NumberBounds, boundedNumber } from "./bounded-number.js";
+import { codecParts, withCodecParts } from "./codec-parts.js";
+import { CurrencyCodePattern, currencyCode } from "./currency-code.js";
+import { GetZodFieldPathsOptions, ZodFieldPath, getZodFieldPaths, unwrapField } from "./field-paths.js";
+import { AnyFieldSettings, AnyFieldSettingsSchema, DropdownFieldSettings, FieldSettings, NumberFieldSettings, StringFieldSettings, applyFieldSettings } from "./field-settings.js";
+import { formatTemplate } from "./format-template.js";
+import { HexString24, HexString24Messages, HexString24Pattern, hexString24 } from "./hex-string-24.js";
+import { isDateSchema, isoDate, isoDay } from "./iso-date.js";
+import { JsonText } from "./json-text.js";
+import { FieldLabel, fieldLabel, labelled } from "./labelled.js";
+import { languageCode } from "./language-code.js";
+import { LocalizedString, LocalizedStringArray, LocalizedStringArrayInput, LocalizedStringInput, LocalizedStringMessages, findUncheckedLocalizedFields, hasLocalizedText, isLocalizedTextWithin, localizedString, localizedStringInput } from "./localized-string.js";
+import { ZodMergeShapes, addToUnion, mergeShapes } from "./merge.js";
+import { nullish } from "./nullish.js";
+import { isFollowablePath, toAllPositionalPath, toFieldPath } from "./positional-paths.js";
+import { RegExpPattern } from "./reg-exp-pattern.js";
+import { Slug, slug } from "./slug.js";
+import { stripEmptyFields } from "./strip-empty-fields.js";
+import { stripToSchema } from "./strip-to-schema.js";
+import { timeZone } from "./time-zone.js";
+import { JsonSchemaDocument, ToJsonSchemaOptions, toJsonSchema } from "./to-json-schema.js";
+import { Mutable, UnwrapZodType, ZodWrapper } from "./types.js";
+import { ZOD_WRAPPER_TYPES, getInnerType, isFieldNullable, isFieldOptional, isOptionalOutput, isZodAny, isZodArray, isZodCatch, isZodCodec, isZodDate, isZodDefault, isZodEnum, isZodIntersection, isZodLazy, isZodNullable, isZodNumber, isZodObject, isZodObjectLoose, isZodOptional, isZodPipe, isZodRecord, isZodString, isZodTransform, isZodType, isZodUnion, isZodUnknown, isZodWrapper } from "./utilities.js";
+import { NonNegativeInteger, PositiveInteger } from "./whole-number.js";
+export { type AnyFieldSettings, AnyFieldSettingsSchema, CurrencyCodePattern, type DropdownFieldSettings, FieldLabel, type FieldSettings, GetZodFieldPathsOptions, HexString24, HexString24Messages, HexString24Pattern, JsonSchemaDocument, JsonText, LocalizedString, LocalizedStringArray, LocalizedStringArrayInput, LocalizedStringInput, LocalizedStringMessages, Mutable, NonNegativeInteger, NumberBounds, type NumberFieldSettings, PositiveInteger, RegExpPattern, Slug, type StringFieldSettings, ToJsonSchemaOptions, UnwrapZodType, ZOD_WRAPPER_TYPES, ZodFieldPath, ZodMergeShapes, ZodWrapper, addToUnion, applyFieldSettings, boundedNumber, codecParts, currencyCode, fieldLabel, findUncheckedLocalizedFields, formatTemplate, getInnerType, getZodFieldPaths, hasLocalizedText, hexString24, isDateSchema, isFieldNullable, isFieldOptional, isFollowablePath, isLocalizedTextWithin, isOptionalOutput, isZodAny, isZodArray, isZodCatch, isZodCodec, isZodDate, isZodDefault, isZodEnum, isZodIntersection, isZodLazy, isZodNullable, isZodNumber, isZodObject, isZodObjectLoose, isZodOptional, isZodPipe, isZodRecord, isZodString, isZodTransform, isZodType, isZodUnion, isZodUnknown, isZodWrapper, isoDate, isoDay, labelled, languageCode, localizedString, localizedStringInput, mergeShapes, nullish, slug, stripEmptyFields, stripToSchema, timeZone, toAllPositionalPath, toFieldPath, toJsonSchema, unwrapField, withCodecParts };