@wow-two-beta/ui-vue 0.0.2

package/dist/foundation/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/foundation/utils/polymorphic/index.d.ts

@@ -0,0 +1 @@
+export * from './polymorphic';

package/dist/foundation/utils/polymorphic/polymorphic.d.ts

@@ -0,0 +1,29 @@
+import { Component, ComponentPublicInstance, IntrinsicElementAttributes } from 'vue';
+/**
+ * The value set accepted by an `as` prop — an intrinsic tag name or any Vue
+ * component. Rendered through `<component :is="as">`.
+ */
+export type ElementType = keyof IntrinsicElementAttributes | Component;
+/** Resolve the attribute bag for `C` — intrinsic tags map to their DOM attributes; components fall back to an open bag. */
+type AttributesOf<C extends ElementType> = C extends keyof IntrinsicElementAttributes ? IntrinsicElementAttributes[C] : Record<string, unknown>;
+/**
+ * Props for a polymorphic component (`as` prop). Use only when a component
+ * meaningfully changes its DOM element — most components should use `Slot`/`asChild`
+ * instead.
+ */
+export type PolymorphicProps<C extends ElementType, P = object> = P & Omit<AttributesOf<C>, keyof P | 'as'> & {
+    as?: C;
+};
+/**
+ * Vue props never carry a `ref` — template refs are bound by the parent, not
+ * passed down. Kept as an alias of `PolymorphicProps` so consumers porting
+ * from the React package keep compiling.
+ */
+export type PolymorphicPropsWithoutRef<C extends ElementType, P = object> = PolymorphicProps<C, P>;
+/**
+ * The value a template ref receives when bound to a polymorphic element —
+ * a DOM element for intrinsic tags, a component instance otherwise. Pair with
+ * `useTemplateRef<PolymorphicRef<C>>(...)`.
+ */
+export type PolymorphicRef<C extends ElementType> = C extends keyof IntrinsicElementAttributes ? Element : ComponentPublicInstance;
+export {};

package/dist/foundation/utils/tv/index.d.ts

@@ -0,0 +1 @@
+export * from './tv';

package/dist/foundation/utils/tv/tv.d.ts

@@ -0,0 +1 @@
+export { tv, type VariantProps } from 'tailwind-variants';

package/dist/foundation/validation/Composites.d.ts

@@ -0,0 +1,62 @@
+import { Validator, Infer } from './Validator';
+/** A map of property name to the validator for that property. */
+export type ObjectShape = Readonly<Record<string, Validator<unknown>>>;
+/** Flattens an intersection into a single readable object type in editor tooltips and `.d.ts` output. */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+};
+/** Keys whose validator admits `undefined` — these become optional properties on the output type. */
+type OptionalKeys<TShape extends ObjectShape> = {
+    [K in keyof TShape]-?: undefined extends Infer<TShape[K]> ? K : never;
+}[keyof TShape];
+/** Keys whose validator requires a value. */
+type RequiredKeys<TShape extends ObjectShape> = Exclude<keyof TShape, OptionalKeys<TShape>>;
+/**
+ * The object type a shape validates to. A member built with `.optional()` becomes an optional PROPERTY
+ * (`name?: string`), not merely `name: string | undefined`, so the output type matches what the runtime
+ * actually produces — an absent optional key stays absent.
+ */
+export type InferObject<TShape extends ObjectShape> = Prettify<{
+    [K in RequiredKeys<TShape>]: Infer<TShape[K]>;
+} & {
+    [K in OptionalKeys<TShape>]?: Infer<TShape[K]>;
+}>;
+/** The tuple type a fixed-length list of validators validates to. */
+export type InferTuple<TValidators extends readonly unknown[]> = {
+    -readonly [K in keyof TValidators]: Infer<TValidators[K]>;
+};
+/** A validator for arrays of `TItem`, carrying the length refinements. */
+export declare class ArrayValidator<TItem> extends Validator<TItem[]> {
+    /** Requires at least `limit` items. */
+    min(limit: number, message?: string): this;
+    /** Requires at most `limit` items. */
+    max(limit: number, message?: string): this;
+    /** Requires exactly `exact` items. */
+    length(exact: number, message?: string): this;
+}
+/**
+ * Validates an object against a shape, reporting every failing property. Unknown keys are STRIPPED: the
+ * output carries only declared properties, so a validated payload cannot smuggle extra fields past the
+ * boundary into storage or a log.
+ */
+export declare function object<TShape extends ObjectShape>(shape: TShape, message?: string): Validator<InferObject<TShape>>;
+/** Validates every item against `item`, reporting each failure at its own index. */
+export declare function array<TItem>(item: Validator<TItem>, message?: string): ArrayValidator<TItem>;
+/**
+ * Validates every value of an open-keyed object against `value`, reporting each failure under its key.
+ * Keys are not validated — only own enumerable string keys are visited, which is what `Object.entries`
+ * gives and what a JSON payload can carry.
+ */
+export declare function record<TValue>(value: Validator<TValue>, message?: string): Validator<Record<string, TValue>>;
+/**
+ * Accepts a value matching any one of `validators`, tried in order — the first match wins, so order
+ * matters when branches overlap. A total failure reports ONE issue naming the alternatives rather than
+ * every branch's issues; see the header note.
+ */
+export declare function union<const TValidators extends readonly Validator<unknown>[]>(validators: TValidators, message?: string): Validator<Infer<TValidators[number]>>;
+/**
+ * Validates a fixed-length, positionally-typed array. A length mismatch is reported once at the tuple's
+ * own path; a wrong element type is reported at that element's index.
+ */
+export declare function tuple<const TValidators extends readonly Validator<unknown>[]>(validators: TValidators, message?: string): Validator<InferTuple<TValidators>>;
+export {};

package/dist/foundation/validation/Formats.d.ts

@@ -0,0 +1,9 @@
+import { StringValidator } from './Primitives';
+/** Accepts an email-shaped string. Pragmatic check — see the header for what it deliberately does not do. */
+export declare function email(message?: string): StringValidator;
+/** Accepts any string the `URL` constructor parses. Any scheme passes — restrict further if it reaches an `href`. */
+export declare function url(message?: string): StringValidator;
+/** Accepts a canonical RFC 4122 UUID, any case. Rejects the nil UUID — see the header. */
+export declare function uuid(message?: string): StringValidator;
+/** Accepts a `YYYY-MM-DD` calendar date that actually exists. Not a full ISO 8601 timestamp. */
+export declare function isoDate(message?: string): StringValidator;

package/dist/foundation/validation/Messages.d.ts

@@ -0,0 +1,69 @@
+/** A field-level failure widened to carry its machine tag — the channel a catalogue can key on. */
+export interface FieldIssue {
+    /** The authoring or server message. Always present; used verbatim when no catalogue entry matches. */
+    readonly message: string;
+    /** The normalized rule code (`required`, `min`, `pattern`, …). Absent when the source reported none. */
+    readonly code?: string;
+    /** The rule's own operands (`{ max: 50 }`), normalized to the vocabulary's names. */
+    readonly params?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The rule codes this ecosystem speaks. The client's own validators report a subset (`type`, `min`,
+ * `pattern`, …); the rest arrive from the server. Kept as one flat union because a catalogue keys on it
+ * and a split would mean two lookups for one concept.
+ */
+export declare const VALIDATION_CODES: readonly ["required", "type", "mustBeNull", "mustBeEmpty", "min", "max", "length", "integer", "precision", "greaterThan", "lessThan", "between", "betweenExclusive", "equal", "notEqual", "literal", "oneOf", "union", "pattern", "email", "url", "uuid", "isoDate", "creditCard", "custom", "transform", "internal"];
+/** A member of the shared rule-code vocabulary. */
+export type ValidationCode = (typeof VALIDATION_CODES)[number];
+/**
+ * Maps FluentValidation's `ErrorCode` onto the shared vocabulary. Covers the built-in validators whose
+ * failures reach a form; anything absent falls through with its raw code, which simply misses the
+ * catalogue and renders the server's own message.
+ */
+export declare const FLUENT_VALIDATION_CODES: Readonly<Record<string, ValidationCode>>;
+/**
+ * Maps FluentValidation's message placeholders onto the vocabulary's param names, so one catalogue entry
+ * reads the same operand whichever side reported it. Unlisted placeholders pass through unchanged —
+ * `PropertyName` deliberately among them, since the label is resolved from the form, not the payload.
+ */
+export declare const FLUENT_VALIDATION_PARAMS: Readonly<Record<string, string>>;
+/** What a catalogue entry renders from. */
+export interface ValidationMessageContext {
+    /** The normalized rule code that failed. */
+    readonly code: string;
+    /** The rule's operands, vocabulary-named. Empty when the source reported none. */
+    readonly params: Readonly<Record<string, unknown>>;
+    /** The form path the failure is filed under; `''` for a form-level failure. */
+    readonly path: string;
+    /** The field's display label, when the form named one. Absent means render label-free. */
+    readonly label?: string;
+    /** The originating message — return this to defer to the source. */
+    readonly message: string;
+}
+/** Renders one rule code into user-facing text. */
+export type ValidationMessageEntry = (context: ValidationMessageContext) => string;
+/** A code → renderer table. Partial by design: an unlisted code falls back to the source's message. */
+export type ValidationMessageCatalogue = Readonly<Record<string, ValidationMessageEntry>>;
+/** Resolves one issue at one path into the string a field renders. */
+export type ResolveValidationMessage = (issue: FieldIssue, path: string) => string;
+/**
+ * The English voice for the vocabulary. Entries are FRAGMENTS, not sentences — a field message renders
+ * under its own labelled control, so "must be at least 2 characters" reads correctly and repeating the
+ * label there is noise. A form that supplies `labels` gets the label prefixed by `createMessageResolver`,
+ * which is the form-level and cross-field case where the fragment alone would be unaddressed.
+ *
+ * An entry that cannot render (its operand never arrived) returns `context.message`, so a half-populated
+ * payload degrades to the source's wording instead of to "must be at most undefined".
+ */
+export declare const defaultValidationMessages: ValidationMessageCatalogue;
+/**
+ * Builds the resolver the form engines call for every message they are about to render.
+ *
+ * Resolution order per issue: the caller's catalogue → {@link defaultValidationMessages} → the issue's
+ * own message. A known label is prefixed to the rendered fragment; an unlabelled field renders the
+ * fragment alone, which is what every message in this SDK did before a catalogue existed.
+ *
+ * `catalogue` is MERGED over the defaults rather than replacing them, so overriding one code's wording —
+ * or translating a handful — never silently drops the rest of the vocabulary.
+ */
+export declare function createMessageResolver(catalogue?: ValidationMessageCatalogue, labels?: Readonly<Record<string, string>>): ResolveValidationMessage;

package/dist/foundation/validation/Primitives.d.ts

@@ -0,0 +1,49 @@
+import { Validator } from './Validator';
+/** A validator for `string` values, carrying the string-specific refinements. */
+export declare class StringValidator extends Validator<string> {
+    /** Requires at least `limit` characters (UTF-16 code units, matching `String.length`). */
+    min(limit: number, message?: string): this;
+    /** Requires at most `limit` characters. */
+    max(limit: number, message?: string): this;
+    /** Requires exactly `exact` characters. */
+    length(exact: number, message?: string): this;
+    /**
+     * Requires the value to match `regex`.
+     *
+     * A `g` or `y` regex carries `lastIndex` between calls, so testing the same input twice alternates
+     * pass and fail — a validator that is stateful is a bug generator. Those flags are stripped from a
+     * private clone; the caller's regex is never mutated.
+     */
+    pattern(regex: RegExp, message?: string, code?: string): this;
+}
+/** A validator for finite `number` values, carrying the numeric refinements. */
+export declare class NumberValidator extends Validator<number> {
+    /** Requires a value greater than or equal to `limit`. */
+    min(limit: number, message?: string): this;
+    /** Requires a value less than or equal to `limit`. */
+    max(limit: number, message?: string): this;
+    /** Requires a whole number — rejects any fractional part. */
+    integer(message?: string): this;
+}
+/** A validator for valid `Date` instances, carrying the chronological refinements. */
+export declare class DateValidator extends Validator<Date> {
+    /** Requires an instant at or after `limit`. */
+    min(limit: Date, message?: string): this;
+    /** Requires an instant at or before `limit`. */
+    max(limit: Date, message?: string): this;
+}
+/** Accepts any `string`. Chain `.min()`, `.max()`, `.length()`, or `.pattern()` to constrain it. */
+export declare function string(message?: string): StringValidator;
+/** Accepts any finite `number` — rejects `NaN` and `±Infinity`, which break every downstream comparison. */
+export declare function number(message?: string): NumberValidator;
+/** Accepts `true` or `false`. Rejects the strings `"true"` / `"false"` — see the no-coercion note. */
+export declare function boolean(message?: string): Validator<boolean>;
+/**
+ * Accepts a `Date` instance holding a real instant. An Invalid Date (`new Date('nonsense')`) is still a
+ * `Date` and still passes `instanceof`, so its time value is checked too. Use `isoDate()` for strings.
+ */
+export declare function date(message?: string): DateValidator;
+/** Accepts exactly `expected`, compared by `===`. The output narrows to the literal type. */
+export declare function literal<const TValue extends string | number | boolean | null>(expected: TValue, message?: string): Validator<TValue>;
+/** Accepts any member of `values`, compared by `===`. The output narrows to the union of the literals. */
+export declare function oneOf<const TValues extends readonly (string | number | boolean)[]>(values: TValues, message?: string): Validator<TValues[number]>;

package/dist/foundation/validation/StandardSchema.d.ts

@@ -0,0 +1,55 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}

package/dist/foundation/validation/ValidationError.d.ts

@@ -0,0 +1,14 @@
+import { ValidationIssue } from './ValidationResult';
+import { Validator } from './Validator';
+/** The error `assertValid` throws, carrying every issue found rather than only the summarized first. */
+export declare class ValidationError extends Error {
+    /** Every issue from the failed run, in traversal order, each with its own path. */
+    readonly issues: readonly ValidationIssue[];
+    /** Wraps the issues; `message` overrides the generated summary when a call site has better copy. */
+    constructor(issues: readonly ValidationIssue[], message?: string);
+}
+/**
+ * Validates `value` and returns the parsed output, throwing `ValidationError` if it fails. The typed
+ * escape hatch for callers that want a throw — everything else in this slice stays total.
+ */
+export declare function assertValid<TOutput>(validator: Validator<TOutput>, value: unknown): TOutput;

package/dist/foundation/validation/ValidationResult.d.ts

@@ -0,0 +1,49 @@
+/** A single segment of an issue path — an object key or an array index. */
+export type PathSegmentKey = string | number;
+/** One reason a value was rejected, addressed at the exact spot it failed. */
+export interface ValidationIssue {
+    /** Location of the failure relative to the validated root: `['items', 0, 'name']`. Empty at the root. */
+    readonly path: readonly PathSegmentKey[];
+    /** Human-readable, display-ready explanation of the failure. Never contains the rejected value. */
+    readonly message: string;
+    /** Stable machine tag for the rule that failed (`type`, `min`, `pattern`, `union`, `custom`, …). */
+    readonly code?: string;
+    /**
+     * The rule's own operands — `{ min: 2, unit: 'characters' }` for `string().min(2)`.
+     *
+     * Present so a message CATALOGUE can re-render the failure in another voice or another language
+     * (`Messages.ts`). `message` already reads correctly on its own; without the operands beside it, a
+     * catalogue could only ever emit parameterless text, which is a catalogue that cannot replace the
+     * message it exists to replace. Holds operands only — never the rejected value, for the same reason
+     * `describeType` exists.
+     */
+    readonly params?: Readonly<Record<string, unknown>>;
+}
+/** The outcome of validating a value: the parsed output, or every issue found. Never a thrown error. */
+export type ValidationResult<T> = {
+    /** Discriminant: the value satisfied the validator. */
+    readonly valid: true;
+    /** The parsed output, after any `.default()` fallback and `.transform()` mapping. */
+    readonly value: T;
+} | {
+    /** Discriminant: the value was rejected. */
+    readonly valid: false;
+    /** Every issue found, in traversal order — not just the first. */
+    readonly issues: readonly ValidationIssue[];
+};
+/** Builds a success result carrying the parsed (and possibly transformed) output. */
+export declare function valid<T>(value: T): ValidationResult<T>;
+/** Builds a failure result from the issues collected during the traversal. */
+export declare function invalid<T>(issues: readonly ValidationIssue[]): ValidationResult<T>;
+/**
+ * Names a value's type for an error message. Total and hostile-input safe: a `Proxy` may trap
+ * `getPrototypeOf` (which `instanceof` calls) and throw, so the object probes are guarded — a message
+ * is never worth a second failure. `NaN` reports as `NaN` rather than `number`, since "expected number,
+ * received number" reads as a bug.
+ */
+export declare function describeType(value: unknown): string;
+/**
+ * Renders an issue path in the familiar display form: `['items', 0, 'name']` → `items[0].name`.
+ * A root-level issue (empty path) renders as the empty string — callers decide how to label the root.
+ */
+export declare function formatIssuePath(path: readonly PathSegmentKey[]): string;

package/dist/foundation/validation/Validator.d.ts

@@ -0,0 +1,69 @@
+import { StandardSchemaV1 } from './StandardSchema';
+import { PathSegmentKey, ValidationResult } from './ValidationResult';
+/** Parses an unknown value sitting at `path` inside the validated structure. Must not throw. */
+export type ParseFn<TOutput> = (value: unknown, path: readonly PathSegmentKey[]) => ValidationResult<TOutput>;
+/** The `vendor` reported by every validator's Standard Schema props. */
+export declare const VALIDATION_VENDOR = "wow-two-beta";
+/** Extracts the output type of a validator: `Infer<typeof user>` → `{ name: string }`. */
+export type Infer<TValidator> = TValidator extends Validator<infer TOutput> ? TOutput : never;
+/** Converts a slice result into the Standard Schema result shape (`{ value }` or `{ issues }`). */
+export declare function toStandardResult<TOutput>(result: ValidationResult<TOutput>): StandardSchemaV1.Result<TOutput>;
+/**
+ * A total, composable validator for one shape of value. Build one with `string()`, `object({…})`, etc.
+ * rather than constructing it directly; the constructor is public only so a caller can define a
+ * validator this slice does not ship.
+ */
+export declare class Validator<TOutput> implements StandardSchemaV1<TOutput, TOutput> {
+    /** Phantom carrier for `Infer`. Never assigned, never read — erased at compile time. */
+    readonly __output: TOutput;
+    /** Human-facing name of the accepted shape, used in messages and in composite type names. */
+    readonly typeName: string;
+    /** Standard Schema props — lets this validator be handed to any spec consumer unchanged. */
+    readonly '~standard': StandardSchemaV1.Props<TOutput, TOutput>;
+    /** The total parse function this validator wraps. */
+    protected readonly parseFn: ParseFn<TOutput>;
+    /** Wraps a parse function under a display name. Prefer the builders (`string()`, `object()`, …). */
+    constructor(typeName: string, parseFn: ParseFn<TOutput>);
+    /** Validates `value` from the root. Total — returns a result, never throws. */
+    validate(value: unknown): ValidationResult<TOutput>;
+    /**
+     * Validates `value` as if it sat at `path` inside a larger structure, so nested issues carry their
+     * full address. Composites call this to thread the path; prefer `validate` at ordinary call sites.
+     */
+    parseAt(value: unknown, path: readonly PathSegmentKey[]): ValidationResult<TOutput>;
+    /** Accepts `undefined` as-is; any other value must satisfy this validator. Widens to `TOutput | undefined`. */
+    optional(): Validator<TOutput | undefined>;
+    /** Accepts `null` as-is; any other value must satisfy this validator. Widens to `TOutput | null`. */
+    nullable(): Validator<TOutput | null>;
+    /**
+     * Substitutes `fallback` when the value is `undefined`, narrowing the output back to a defined type.
+     *
+     * `null` is NOT defaulted. An explicit `null` is a value the caller chose — in a JSON payload it means
+     * "known to be empty", which is different from "absent" — so it keeps flowing into this validator and
+     * is rejected unless the validator is also `.nullable()`. Matches zod's split.
+     */
+    default(fallback: Exclude<TOutput, undefined>): Validator<Exclude<TOutput, undefined>>;
+    /**
+     * Adds a custom check that runs only after this validator accepts the value, so `check` always sees a
+     * fully parsed `TOutput`. Returns the same validator class, keeping type-specific methods chainable.
+     * A `check` that throws is reported as this same failure rather than propagating.
+     *
+     * `params` carries the rule's operands onto the issue so a message catalogue can re-render it
+     * (`Messages.ts`). Pass the limits the check compares against, never the value it rejected.
+     */
+    refine(check: (value: TOutput) => boolean, message: string, code?: string, params?: Readonly<Record<string, unknown>>): this;
+    /**
+     * Maps the parsed value to another shape. Runs strictly AFTER validation, so `map` receives a valid
+     * `TOutput`. A `map` that throws becomes an issue, preserving totality. The result is a base
+     * `Validator<TNext>` — type-specific methods do not survive a change of output type.
+     */
+    transform<TNext>(map: (value: TOutput) => TNext): Validator<TNext>;
+    /** Rebuilds this validator's own class around a new parse function, keeping the chain's static type. */
+    protected derive(parseFn: ParseFn<TOutput>): this;
+}
+/**
+ * Presents a validator as a bare Standard Schema object. Every validator already implements the spec —
+ * this is sugar for a call site that reads better handing over a plain `{ '~standard': … }` than the
+ * whole validator (and for narrowing the surface a consumer sees).
+ */
+export declare function toStandardSchema<TOutput>(validator: Validator<TOutput>): StandardSchemaV1<TOutput, TOutput>;

package/dist/foundation/validation/index.d.ts

@@ -0,0 +1,8 @@
+export { type PathSegmentKey, type ValidationIssue, type ValidationResult, valid, invalid, describeType, formatIssuePath, } from './ValidationResult';
+export { type StandardSchemaV1 } from './StandardSchema';
+export { type ParseFn, type Infer, Validator, VALIDATION_VENDOR, toStandardResult, toStandardSchema, } from './Validator';
+export { StringValidator, NumberValidator, DateValidator, string, number, boolean, date, literal, oneOf, } from './Primitives';
+export { type ObjectShape, type InferObject, type InferTuple, ArrayValidator, object, array, record, union, tuple, } from './Composites';
+export { email, url, uuid, isoDate } from './Formats';
+export { ValidationError, assertValid } from './ValidationError';
+export { type FieldIssue, type ValidationCode, type ValidationMessageContext, type ValidationMessageEntry, type ValidationMessageCatalogue, type ResolveValidationMessage, VALIDATION_CODES, FLUENT_VALIDATION_CODES, FLUENT_VALIDATION_PARAMS, defaultValidationMessages, createMessageResolver, } from './Messages';