@wow-two-beta/ui-vue 0.0.5 → 0.0.6

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

@@ -1,21 +0,0 @@
-import { Tone } from '../StyleTokens';
-/** Defines a tone-family — the variant group that picks the same bg/border/text palette. */
-export declare const ToneFamily: {
-    /** Refers to an opaque tone bg + foreground. */
-    readonly Solid: "solid";
-    /** Refers to a muted/tinted bg + tone-readable foreground. */
-    readonly Soft: "soft";
-    /** Refers to a popover bg + tone-accent border. */
-    readonly Surface: "surface";
-    /** Refers to a transparent bg, tone border + tone text. */
-    readonly Outline: "outline";
-    /** Refers to a translucent tone bg + blur. */
-    readonly Glass: "glass";
-    /** Refers to a glass fill + tone-accent border at 50% alpha. */
-    readonly GlassOutline: "glassOutline";
-    /** Refers to a low-alpha tinted fill + neutral border, no shadow. */
-    readonly Subtle: "subtle";
-};
-export type ToneFamily = (typeof ToneFamily)[keyof typeof ToneFamily];
-/** Contains the cross-engine palette: bg / text (+ border where applicable) per tone-family × tone. */
-export declare const Tones: Record<ToneFamily, Record<Tone, string>>;

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

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

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

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

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

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

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

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

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

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

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

@@ -1,33 +0,0 @@
-export { cn } from './cn';
-export { composeEventHandlers } from './composeEventHandlers';
-export { dataAttr } from './dataAttr';
-export { tv, type VariantProps } from './tv';
-export type { ElementType, PolymorphicProps, PolymorphicPropsWithoutRef, PolymorphicRef, } from './polymorphic';
-export { CssExtensions, RadiusToken, SizePreset, AbsolutePositionPreset } from './CssExtensions';
-export type { PaddingToken, SizeValue, PaddingProp, RadiusProp, BoxSizeOverrides, SizeUnion, AbsoluteInsetOverrides, AbsolutePosition, } from './CssExtensions';
-export { ColorExtensions, ColorTone } from './ColorExtensions';
-export type { ColorOverride, ColorProp } from './ColorExtensions';
-export { OptionalExtensions } from './OptionalExtensions';
-export { PressExtensions, type PressEvent } from './PressExtensions';
-export { HtmlElement, ButtonType } from './HtmlExtensions';
-export { Key } from './KeyboardExtensions';
-export { Environment, IS_DEV, IS_PRODUCTION } from './Environment';
-export { TransitionExtensions } from './TransitionExtensions';
-export type { PresenceAnimationDurationProp, PresenceAnimationDuration, } from './TransitionExtensions';
-export { surfaceVariants, SurfaceVariant } from './SurfaceStyles';
-export type { SurfaceVariants, SurfaceTone, SurfaceRadius, SurfacePadding, SurfaceElevation, } from './SurfaceStyles';
-export { Layer, layerStyle, type LayerName } from './Layers';
-export { Equality, type EqualityComparer } from './Equality';
-export { createCollator, compareStrings } from './Compare';
-export { Tone, Size, Radius, Padding } from './StyleTokens';
-export type { Elevation } from './StyleTokens';
-export { Tones, ToneFamily } from './Tones';
-export { Severity } from './Severity';
-export { Orientation } from './Orientation';
-export { Align } from './Align';
-export { Side } from './Side';
-export { CornerPosition } from './CornerPosition';
-export { OverlayPosition } from './OverlayPosition';
-export { ProgressTone } from './ProgressTone';
-export { ElementTag } from './ElementTag';
-export { StatusTone } from './StatusTone';

package/dist/foundation/utils/index.js

@@ -1,67 +0,0 @@
-import { A, C, R, S } from "../../chunks/CssExtensions-BzLJG57F.js";
-import { A as A2 } from "../../chunks/Align-DqFtCY3a.js";
-import { B, H } from "../../chunks/HtmlExtensions-jlKY5f9C.js";
-import { C as C2, a, E, I, b, O } from "../../chunks/Environment-CuQav_mw.js";
-import { C as C3 } from "../../chunks/CornerPosition-FneGck5D.js";
-import { E as E2, L, l } from "../../chunks/index-CEoYQiWL.js";
-import { E as E3 } from "../../chunks/Equality-DIQYQysz.js";
-import { K } from "../../chunks/KeyboardExtensions-CQlkK53D.js";
-import { O as O2 } from "../../chunks/Orientation-u-sYunuG.js";
-import { O as O3 } from "../../chunks/OverlayPosition-BNybkMGG.js";
-import { P, R as R2, S as S2, T } from "../../chunks/StyleTokens-Bkz7Dm5L.js";
-import { P as P2 } from "../../chunks/PressExtensions-DXqhjlR2.js";
-import { P as P3 } from "../../chunks/ProgressTone-BpLPUptx.js";
-import { S as S3 } from "../../chunks/Severity-D0C5oAt-.js";
-import { S as S4, c } from "../../chunks/Side-CSys3p-F.js";
-import { S as S5 } from "../../chunks/StatusTone-BoPK1s09.js";
-import { S as S6, s } from "../../chunks/SurfaceStyles-B6W7zdMi.js";
-import { a as a2, T as T2 } from "../../chunks/Tones-WKBNZ_u2.js";
-import { T as T3 } from "../../chunks/TransitionExtensions-hFi80JX2.js";
-import { c as c2 } from "../../chunks/cn-CzDCF-Ah.js";
-import { c as c3, a as a3 } from "../../chunks/Compare-Du6p-OX1.js";
-import { d } from "../../chunks/dataAttr-7BR67dTj.js";
-import { tv } from "tailwind-variants";
-export {
-  A as AbsolutePositionPreset,
-  A2 as Align,
-  B as ButtonType,
-  C2 as ColorExtensions,
-  a as ColorTone,
-  C3 as CornerPosition,
-  C as CssExtensions,
-  E2 as ElementTag,
-  E as Environment,
-  E3 as Equality,
-  H as HtmlElement,
-  I as IS_DEV,
-  b as IS_PRODUCTION,
-  K as Key,
-  L as Layer,
-  O as OptionalExtensions,
-  O2 as Orientation,
-  O3 as OverlayPosition,
-  P as Padding,
-  P2 as PressExtensions,
-  P3 as ProgressTone,
-  R2 as Radius,
-  R as RadiusToken,
-  S3 as Severity,
-  S4 as Side,
-  S2 as Size,
-  S as SizePreset,
-  S5 as StatusTone,
-  S6 as SurfaceVariant,
-  T as Tone,
-  a2 as ToneFamily,
-  T2 as Tones,
-  T3 as TransitionExtensions,
-  c2 as cn,
-  c3 as compareStrings,
-  c as composeEventHandlers,
-  a3 as createCollator,
-  d as dataAttr,
-  l as layerStyle,
-  s as surfaceVariants,
-  tv
-};
-//# sourceMappingURL=index.js.map

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

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

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

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

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

@@ -1,29 +0,0 @@
-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

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

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

@@ -1,62 +0,0 @@
-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/Messages.d.ts

@@ -1,69 +0,0 @@
-/** 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/ValidationError.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,49 +0,0 @@
-/** 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

@@ -1,69 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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';