@ts-runtypes/core 0.9.0 → 0.9.2

package/dist/cjs/createRTFBinary.d.ts

@@ -0,0 +1,36 @@
+import type { RunType } from './runtypes/types.ts';
+import { type DataViewSerializer, type DataViewDeserializer, type BinaryInput } from './runtypes/dataView.ts';
+import type { InjectTypeFnArgs } from './index.ts';
+import type { DataOnly } from './runtypes/dataOnly.ts';
+export type ToBinaryFn = (value: unknown, Ser: DataViewSerializer) => DataViewSerializer;
+export type FromBinaryFn<T = unknown> = (ret: unknown, Des: DataViewDeserializer) => T;
+export type BinaryEncoderFn = (value: unknown) => Uint8Array;
+export type BinaryEncoderSizeFn = (value: unknown, size: number) => Uint8Array;
+export type BinaryEncoderIntoFn = (value: unknown, into: ArrayBuffer) => Uint8Array;
+type InitialSizeOptions = BinaryEncoderOptions & {
+    sizeStrategy: 'initialSize';
+};
+type IntoBufferOptions = BinaryEncoderOptions & {
+    sizeStrategy: 'intoBuffer';
+};
+export type BinaryDecoderFn<T = unknown> = (input: BinaryInput | DataViewDeserializer) => T;
+export interface BinaryEncoderOptions {
+    cacheKey?: string;
+    rejectCircularRefs?: boolean;
+    sizeStrategy?: 'dynamic' | 'precalculate' | 'initialSize' | 'intoBuffer';
+}
+export interface BinaryDecoderOptions {
+    cacheKey?: string;
+}
+export declare function createBinaryEncoder<T>(schema: RunType<T>, options: InitialSizeOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderSizeFn;
+export declare function createBinaryEncoder<T>(val: T | undefined, options: InitialSizeOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderSizeFn;
+export declare function createBinaryEncoder<T>(schema: RunType<T>, options: IntoBufferOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderIntoFn;
+export declare function createBinaryEncoder<T>(val: T | undefined, options: IntoBufferOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderIntoFn;
+export declare function createBinaryEncoder<T>(schema: RunType<T>, options?: BinaryEncoderOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderFn;
+export declare function createBinaryEncoder<T>(val?: T, options?: BinaryEncoderOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderFn;
+export type BinarySizerFn = (value: unknown) => number;
+export declare function createBinarySizer<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, 'tb'>): BinarySizerFn;
+export declare function createBinarySizer<T>(val?: T, id?: InjectTypeFnArgs<T, 'tb'>): BinarySizerFn;
+export declare function createBinaryDecoder<T>(schema: RunType<T>, options?: BinaryDecoderOptions, id?: InjectTypeFnArgs<T, 'fb'>): BinaryDecoderFn<DataOnly<T>>;
+export declare function createBinaryDecoder<T>(val?: T, options?: BinaryDecoderOptions, id?: InjectTypeFnArgs<T, 'fb'>): BinaryDecoderFn<DataOnly<T>>;
+export {};

package/dist/cjs/createRTFunctions.d.ts

@@ -0,0 +1,85 @@
+import type { RunType } from './runtypes/types.ts';
+import type { DataOnly } from './runtypes/dataOnly.ts';
+import type { CompTimeFnArgs, InjectTypeFnArgs } from './index.ts';
+import type { ToBinaryFn, FromBinaryFn } from './createRTFBinary.ts';
+export interface ValidateOptions {
+    noLiterals?: boolean;
+    noIsArrayCheck?: boolean;
+    rejectCircularRefs?: boolean;
+}
+export type ValidateFn<T = unknown> = (value: unknown) => value is DataOnly<T>;
+export interface RTPathSegment {
+    key: number;
+    failed?: 'mapKey' | 'mapValue' | 'setKey';
+}
+export type RTValidationErrorPathSegment = string | number | RTPathSegment;
+export interface TypeFormatError {
+    name: string;
+    val: RTValidationErrorPathSegment | boolean | bigint | (RTValidationErrorPathSegment | boolean | bigint)[];
+    formatPath: (string | number)[];
+    isCurrency?: boolean;
+}
+export interface RTValidationError {
+    path: RTValidationErrorPathSegment[];
+    expected: string;
+    format?: TypeFormatError;
+}
+export type GetValidationErrorsFn = (value: unknown, path?: RTValidationErrorPathSegment[], errors?: RTValidationError[]) => RTValidationError[];
+export interface HasUnknownKeysOptions {
+    checkNonRTProps?: boolean;
+}
+export type HasUnknownKeysFn = (value: unknown, options?: HasUnknownKeysOptions) => boolean;
+export type StripUnknownKeysFn = (value: unknown) => unknown;
+export type UnknownKeyErrorsFn = (value: unknown, path?: RTValidationErrorPathSegment[], errors?: RTValidationError[]) => RTValidationError[];
+export type UnknownKeysToUndefinedFn = (value: unknown) => unknown;
+export type FormatTransformValue<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer E)[] ? FormatTransformValue<E>[] : T extends object ? {
+    [K in keyof T]: FormatTransformValue<T[K]>;
+} : T;
+export type FormatTransformFn<T> = (value: FormatTransformValue<T>) => FormatTransformValue<T>;
+export type PrepareForJsonFn = (value: unknown) => unknown;
+export type RestoreFromJsonFn = (value: unknown) => unknown;
+export type StringifyJsonFn = (value: unknown) => string | undefined;
+export type JsonEncoderFn = (value: unknown) => string | undefined;
+export type JsonDecoderFn<T = unknown> = (serialized: string) => T;
+export type JsonEncoderStrategy = 'clone' | 'mutate' | 'direct' | 'compact';
+export type JsonEncoderOptions = {
+    strategy?: JsonEncoderStrategy;
+    rejectCircularRefs?: boolean;
+};
+export type JsonDecoderStrategy = 'strip' | 'preserve' | 'compact';
+export type JsonDecoderOptions = {
+    strategy?: JsonDecoderStrategy;
+};
+export declare const createValidate: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "val">) => ValidateFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "val">) => ValidateFn<T>);
+export declare const createGetValidationErrors: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "verr">) => GetValidationErrorsFn) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "verr">) => GetValidationErrorsFn);
+export declare const createHasUnknownKeys: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn);
+export declare const createStripUnknownKeys: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "suk">) => StripUnknownKeysFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "suk">) => StripUnknownKeysFn);
+export declare const createUnknownKeyErrors: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn);
+export declare const createUnknownKeysToUndefined: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "uku">) => UnknownKeysToUndefinedFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "uku">) => UnknownKeysToUndefinedFn);
+export declare const createFormatTransform: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "fmt">) => FormatTransformFn<T>) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "fmt">) => FormatTransformFn<T>);
+export declare function createJsonEncoder<T>(schema: RunType<T>, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
+export declare function createJsonEncoder<T>(val?: T, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
+export declare function createJsonDecoder<T>(schema: RunType<T>, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
+export declare function createJsonDecoder<T>(val?: T, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
+export interface RTFunctionByKey {
+    val: ValidateFn;
+    verr: GetValidationErrorsFn;
+    huk: HasUnknownKeysFn;
+    suk: StripUnknownKeysFn;
+    uke: UnknownKeyErrorsFn;
+    uku: UnknownKeysToUndefinedFn;
+    fmt: FormatTransformFn<unknown>;
+    jsonEncoder: JsonEncoderFn;
+    jsonDecoder: JsonDecoderFn;
+    tb: ToBinaryFn;
+    fb: FromBinaryFn;
+    pj: PrepareForJsonFn;
+    pjs: PrepareForJsonFn;
+    rj: RestoreFromJsonFn;
+    sj: StringifyJsonFn;
+    ukuw: RestoreFromJsonFn;
+    cj: PrepareForJsonFn;
+    cjr: RestoreFromJsonFn;
+}
+export type RTFunctionKey = keyof RTFunctionByKey;
+export declare function getRTFunction<K extends RTFunctionKey>(injected: unknown, fallback?: RTFunctionByKey[K]): RTFunctionByKey[K];

package/dist/cjs/createRTFunctions.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFormatTransform = exports.createUnknownKeysToUndefined = exports.createUnknownKeyErrors = exports.createStripUnknownKeys = exports.createHasUnknownKeys = exports.createGetValidationErrors = exports.createValidate = void 0;
 exports.createJsonEncoder = createJsonEncoder;
 exports.createJsonDecoder = createJsonDecoder;
+exports.getRTFunction = getRTFunction;
 const rtUtils_ts_1 = require("./runtypes/rtUtils.js");
 const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
 function resolveTupleEntry(fnName, identityFn, val, args, rejectCircularRefs) {
@@ -36,3 +37,7 @@ function createJsonEncoder(valOrSchema, options, id) {
 function createJsonDecoder(valOrSchema, options, id) {
     return resolveTupleEntry('createJsonDecoder', jsonParseFallback, valOrSchema, id);
 }
+function getRTFunction(injected, fallback) {
+    const identityFn = (fallback ?? ((value) => value));
+    return (0, entryTuple_ts_1.resolveEntryTupleFn)('getRTFunction', identityFn, undefined, injected);
+}

package/dist/cjs/enrich/createFriendlyText.d.ts

@@ -0,0 +1,25 @@
+import type { RTValidationError, RTValidationErrorPathSegment } from '../createRTFunctions.ts';
+import type { FriendlyText } from './friendlyText.ts';
+export interface FriendlyMessage {
+    path: string;
+    label: string;
+    message: string;
+}
+export interface FriendlyRenderer {
+    label(path: string | RTValidationErrorPathSegment[]): string;
+    errors(errs: RTValidationError[]): FriendlyMessage[];
+}
+export declare function createFriendlyText<T>(map: FriendlyText<T>): FriendlyRenderer;
+export interface FriendlyI18nOptions<T> {
+    locale: string | {
+        readonly value: string;
+    };
+    translations: Partial<Record<string, FriendlyText<T>>>;
+    currency?: string | {
+        readonly value: string;
+    };
+    sourceLocale?: string;
+    strict?: boolean;
+}
+export declare function resolveLocale<T>(locale: string, translations: Partial<Record<string, FriendlyText<T>>>): string | undefined;
+export declare function createFriendlyTextI18n<T>(source: FriendlyText<T>, options: FriendlyI18nOptions<T>): FriendlyRenderer;

package/dist/cjs/enrich/friendlyText.d.ts

@@ -0,0 +1,50 @@
+export type FriendlyTemplate = string;
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export type PluralTemplate = {
+    other: FriendlyTemplate;
+} & Partial<Record<PluralCategory, FriendlyTemplate>>;
+export type TemplateLeaf = FriendlyTemplate | PluralTemplate;
+type NonFailingParams = 'isCurrency' | 'mockSamples' | 'trim' | 'lowercase' | 'uppercase' | 'capitalize' | 'replace' | 'replaceAll';
+type CountBearingKeys = 'minLength' | 'maxLength' | 'min' | 'max' | 'lt' | 'gt';
+type ConstraintTemplates<P> = {
+    type: FriendlyTemplate;
+} & {
+    [K in Exclude<keyof P & string, NonFailingParams>]: K extends CountBearingKeys ? TemplateLeaf : FriendlyTemplate;
+} & {
+    rt$default?: never;
+};
+type DefaultOnlyTemplates = {
+    rt$default: FriendlyTemplate;
+    type?: never;
+};
+type BareTemplates = DefaultOnlyTemplates | ({
+    type: FriendlyTemplate;
+} & {
+    rt$default?: never;
+});
+export type ErrorTemplates<F = never> = [F] extends [never] ? BareTemplates : F extends {
+    readonly __rtFormatParams?: infer P;
+} ? [NonNullable<P>] extends [object] ? DefaultOnlyTemplates | ConstraintTemplates<NonNullable<P>> : BareTemplates : BareTemplates;
+export interface FriendlyMeta<F = never> {
+    rt$label: string;
+    rt$errors: ErrorTemplates<F>;
+    rt$typeName?: string;
+}
+type FriendlyLeaf = string | number | boolean | bigint | null | undefined | Date | RegExp;
+type _FriendlyDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+export type FriendlyNode<T, Depth extends number = 8> = Depth extends 0 ? FriendlyMeta : T extends FriendlyLeaf ? FriendlyMeta<T> : T extends ReadonlyMap<any, any> ? T extends ReadonlyMap<infer K, infer V> ? FriendlyMeta & {
+    rt$keys: FriendlyNode<K, _FriendlyDepth[Depth]>;
+    rt$values: FriendlyNode<V, _FriendlyDepth[Depth]>;
+} : FriendlyMeta : T extends ReadonlySet<any> ? T extends ReadonlySet<infer U> ? FriendlyMeta & {
+    rt$values: FriendlyNode<U, _FriendlyDepth[Depth]>;
+} : FriendlyMeta : T extends readonly unknown[] ? number extends T['length'] ? FriendlyMeta & {
+    rt$items: FriendlyNode<T[number], _FriendlyDepth[Depth]>;
+} : FriendlyMeta & {
+    rt$slots: {
+        [K in keyof T]: FriendlyNode<T[K], _FriendlyDepth[Depth]>;
+    };
+} : T extends object ? FriendlyMeta & {
+    [K in keyof T]-?: FriendlyNode<T[K], _FriendlyDepth[Depth]>;
+} : FriendlyMeta;
+export type FriendlyText<T> = FriendlyNode<T>;
+export {};

package/dist/cjs/enrich/mockData.d.ts

@@ -0,0 +1,46 @@
+type _MockDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+export type MockNode<T, Depth extends number = 8> = Depth extends 0 ? {
+    pool: T[];
+} : T extends ReadonlyMap<any, any> ? T extends ReadonlyMap<infer K, infer V> ? {
+    rt$keys: MockNode<K, _MockDepth[Depth]>;
+    rt$values: MockNode<V, _MockDepth[Depth]>;
+    rt$size?: number | [number, number];
+} : {
+    pool: T[];
+} : T extends ReadonlySet<any> ? T extends ReadonlySet<infer U> ? {
+    rt$values: MockNode<U, _MockDepth[Depth]>;
+    rt$size?: number | [number, number];
+} : {
+    pool: T[];
+} : T extends readonly unknown[] ? number extends T['length'] ? {
+    rt$items: MockNode<T[number], _MockDepth[Depth]>;
+    rt$length?: number | [number, number];
+} : {
+    rt$slots: {
+        [K in keyof T]: MockNode<T[K], _MockDepth[Depth]>;
+    };
+} : T extends number ? {
+    pool: number[];
+    min?: number;
+    max?: number;
+} : T extends string ? {
+    pool: string[];
+} : T extends Date ? {
+    pool: Date[];
+    min?: Date;
+    max?: Date;
+} : T extends RegExp ? {
+    pool: RegExp[];
+} : T extends boolean ? {
+    pool: boolean[];
+} : T extends bigint ? {
+    pool: bigint[];
+} : T extends object ? {
+    [K in keyof T]-?: MockNode<T[K], _MockDepth[Depth]>;
+} & {
+    rt$optional?: number;
+} : {
+    pool: T[];
+};
+export type MockData<T> = MockNode<T>;
+export {};

package/dist/cjs/formats/bigintFormats.d.ts

@@ -0,0 +1,37 @@
+import { TypeFormat } from '../runtypes/typeFormat.ts';
+export interface BigIntParams {
+    min?: bigint;
+    max?: bigint;
+    lt?: bigint;
+    gt?: bigint;
+    multipleOf?: bigint;
+}
+export type BigInt<P extends BigIntParams = {}, BrandName extends string = never> = TypeFormat<bigint, 'bigintFormat', P, BrandName>;
+export type BigPositive = BigInt<{
+    min: 0n;
+}>;
+export type BigNegative = BigInt<{
+    max: 0n;
+}>;
+export type BigPositiveInt = BigInt<{
+    min: 0n;
+    multipleOf: 1n;
+}>;
+export type BigNegativeInt = BigInt<{
+    max: 0n;
+    multipleOf: 1n;
+}>;
+export type BigInt64 = BigInt<{
+    min: -9223372036854775808n;
+    max: 9223372036854775807n;
+}>;
+export type BigUInt64 = BigInt<{
+    min: 0n;
+    max: 18446744073709551615n;
+}>;
+export declare const bigPositive: (id?: import("../markers.ts").InjectRunTypeId<BigPositive> | undefined) => import("../index.ts").RunType<BigPositive>;
+export declare const bigNegative: (id?: import("../markers.ts").InjectRunTypeId<BigNegative> | undefined) => import("../index.ts").RunType<BigNegative>;
+export declare const bigPositiveInt: (id?: import("../markers.ts").InjectRunTypeId<BigPositiveInt> | undefined) => import("../index.ts").RunType<BigPositiveInt>;
+export declare const bigNegativeInt: (id?: import("../markers.ts").InjectRunTypeId<BigNegativeInt> | undefined) => import("../index.ts").RunType<BigNegativeInt>;
+export declare const bigInt64: (id?: import("../markers.ts").InjectRunTypeId<BigInt64> | undefined) => import("../index.ts").RunType<BigInt64>;
+export declare const bigUInt64: (id?: import("../markers.ts").InjectRunTypeId<BigUInt64> | undefined) => import("../index.ts").RunType<BigUInt64>;

package/dist/cjs/formats/datetime/dateFormats.d.ts

@@ -0,0 +1,10 @@
+import { TypeFormat } from '../../runtypes/typeFormat.ts';
+import type { MinMax, DateTimeBound } from './dateTimeParams.ts';
+export type NativeDateParams = MinMax<DateTimeBound>;
+export type Date<P extends NativeDateParams = {}, BrandName extends string = never> = TypeFormat<globalThis.Date, 'nativeDate', P, BrandName>;
+export type DateFuture = Date<{
+    min: 'now';
+}>;
+export type DatePast = Date<{
+    max: 'now';
+}>;

package/dist/cjs/formats/datetime/dateTime-pure-fns.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/formats/datetime/dateTimeParams.d.ts

@@ -0,0 +1,10 @@
+export type RelativeNow = 'now' | `now+P${string}` | `now-P${string}`;
+export type DateBound = string;
+export type TimeBound = string;
+export type DateTimeBound = string;
+export interface MinMax<Bound extends string = string> {
+    min?: Bound;
+    max?: Bound;
+    gt?: Bound;
+    lt?: Bound;
+}

package/dist/cjs/formats/datetime/stringDateTimeFormats.d.ts

@@ -0,0 +1,33 @@
+import { TypeFormat } from '../../runtypes/typeFormat.ts';
+import type { MinMax, DateBound, TimeBound, DateTimeBound } from './dateTimeParams.ts';
+export type DateFmt = 'ISO' | 'YYYY-MM-DD' | 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'YYYY-MM' | 'MM-DD' | 'DD-MM';
+export interface DateParams extends MinMax<DateBound> {
+    format: DateFmt;
+}
+export type DEFAULT_DATE_PARAMS = {
+    format: 'ISO';
+};
+export type StringDate<P extends Partial<DateParams> = DEFAULT_DATE_PARAMS> = TypeFormat<string, 'date', P, never>;
+export type TimeFmt = 'ISO' | 'HH:mm:ss[.mmm]TZ' | 'HH:mm:ss[.mmm]' | 'HH:mm:ss' | 'HH:mm' | 'mm:ss' | 'HH' | 'mm' | 'ss';
+export interface TimeParams extends MinMax<TimeBound> {
+    format: TimeFmt;
+}
+export type DEFAULT_TIME_FORMAT_PARAMS = {
+    format: 'ISO';
+};
+export type StringTime<P extends Partial<TimeParams> = DEFAULT_TIME_FORMAT_PARAMS> = TypeFormat<string, 'time', P, never>;
+export interface DateTimeParams extends MinMax<DateTimeBound> {
+    date: DateParams;
+    time: TimeParams;
+    splitChar: string;
+}
+export type DEFAULT_DATE_TIME_PARAMS = {
+    date: {
+        format: 'ISO';
+    };
+    time: {
+        format: 'ISO';
+    };
+    splitChar: 'T';
+};
+export type StringDateTime<P extends Partial<DateTimeParams> = DEFAULT_DATE_TIME_PARAMS> = TypeFormat<string, 'dateTime', P, never>;

package/dist/cjs/formats/datetime/temporalFormats.d.ts

@@ -0,0 +1,70 @@
+import type { MinMax } from './dateTimeParams.ts';
+import type { TemporalBuilderFn, TemporalInstanceBuilderFn } from '../../runtypes/builderTypes.ts';
+type TemporalInstanceOf<K extends string> = typeof globalThis extends {
+    Temporal: Record<K, {
+        prototype: infer I;
+    }>;
+} ? I : unknown;
+type TInstant = TemporalInstanceOf<'Instant'>;
+type TZonedDateTime = TemporalInstanceOf<'ZonedDateTime'>;
+type TPlainDate = TemporalInstanceOf<'PlainDate'>;
+type TPlainTime = TemporalInstanceOf<'PlainTime'>;
+type TPlainDateTime = TemporalInstanceOf<'PlainDateTime'>;
+type TPlainYearMonth = TemporalInstanceOf<'PlainYearMonth'>;
+type TPlainMonthDay = TemporalInstanceOf<'PlainMonthDay'>;
+type TDuration = TemporalInstanceOf<'Duration'>;
+export type Instant<P extends MinMax = MinMax> = TInstant & {
+    readonly __rtFormatName?: 'temporalInstant';
+    readonly __rtFormatParams?: P;
+};
+export type ZonedDateTime<P extends MinMax = MinMax> = TZonedDateTime & {
+    readonly __rtFormatName?: 'temporalZonedDateTime';
+    readonly __rtFormatParams?: P;
+};
+export type PlainDate<P extends MinMax = MinMax> = TPlainDate & {
+    readonly __rtFormatName?: 'temporalPlainDate';
+    readonly __rtFormatParams?: P;
+};
+export type PlainTime<P extends MinMax = MinMax> = TPlainTime & {
+    readonly __rtFormatName?: 'temporalPlainTime';
+    readonly __rtFormatParams?: P;
+};
+export type PlainDateTime<P extends MinMax = MinMax> = TPlainDateTime & {
+    readonly __rtFormatName?: 'temporalPlainDateTime';
+    readonly __rtFormatParams?: P;
+};
+export type PlainYearMonth<P extends MinMax = MinMax> = TPlainYearMonth & {
+    readonly __rtFormatName?: 'temporalPlainYearMonth';
+    readonly __rtFormatParams?: P;
+};
+export interface TemporalBaseByFormatName {
+    temporalInstant: TInstant;
+    temporalZonedDateTime: TZonedDateTime;
+    temporalPlainDate: TPlainDate;
+    temporalPlainTime: TPlainTime;
+    temporalPlainDateTime: TPlainDateTime;
+    temporalPlainYearMonth: TPlainYearMonth;
+    temporalPlainMonthDay: TPlainMonthDay;
+    temporalDuration: TDuration;
+}
+declare module '../../runtypes/dataOnly.ts' {
+    interface DataOnlyNativeExtra {
+        temporalInstant: TInstant;
+        temporalZonedDateTime: TZonedDateTime;
+        temporalPlainDate: TPlainDate;
+        temporalPlainTime: TPlainTime;
+        temporalPlainDateTime: TPlainDateTime;
+        temporalPlainYearMonth: TPlainYearMonth;
+        temporalPlainMonthDay: TPlainMonthDay;
+        temporalDuration: TDuration;
+    }
+}
+export declare const instant: TemporalBuilderFn<"temporal.instant">;
+export declare const zonedDateTime: TemporalBuilderFn<"temporal.zonedDateTime">;
+export declare const plainDate: TemporalBuilderFn<"temporal.plainDate">;
+export declare const plainTime: TemporalBuilderFn<"temporal.plainTime">;
+export declare const plainDateTime: TemporalBuilderFn<"temporal.plainDateTime">;
+export declare const plainYearMonth: TemporalBuilderFn<"temporal.plainYearMonth">;
+export declare const plainMonthDay: TemporalInstanceBuilderFn<"temporal.plainMonthDay">;
+export declare const duration: TemporalInstanceBuilderFn<"temporal.duration">;
+export {};

package/dist/cjs/formats/datetime/temporalFormats.js

@@ -11,7 +11,7 @@ function temporalBuilder(tag) {
     return build;
 }
 function temporalInstanceBuilder(tag) {
-    return (id) => (0, builderCore_ts_1.builderResult)(id, { type: tag, formatParams: {} });
+    return ((id) => (0, builderCore_ts_1.builderResult)(id, { type: tag, formatParams: {} }));
 }
 exports.instant = temporalBuilder('temporal.instant');
 exports.zonedDateTime = temporalBuilder('temporal.zonedDateTime');

package/dist/cjs/formats/index.d.ts

@@ -0,0 +1,16 @@
+import './string/string-formats-pure-fns.ts';
+import './datetime/dateTime-pure-fns.ts';
+import '../mocking/mockStringFormat.ts';
+import '../mocking/mockNumberFormat.ts';
+import '../mocking/mockBigIntFormat.ts';
+import './string/string-patterns.ts';
+export type * from './string/stringFormats.ts';
+export type * from './datetime/dateTimeParams.ts';
+export type * from './datetime/stringDateTimeFormats.ts';
+export type * from './datetime/dateFormats.ts';
+export type * from './numberFormats.ts';
+export type * from './bigintFormats.ts';
+export { string, number, currency, bigInt, date, brand } from './scalars.ts';
+export { alpha, alphaNumeric, numeric, lowercase, uppercase, capitalize, uuidv4, uuidv7, ip, ipv4, ipv6, ipWithPort, ipv4WithPort, ipv6WithPort, domain, domainUnicode, domainPunycode, domainStrict, email, emailPunycode, emailStrict, url, urlHttp, urlFile, stringDate, stringTime, stringDateTime, } from './string/stringFormats.ts';
+export { integer, float, positive, negative, positiveInt, negativeInt, int8, int16, int32, uint8, uint16, uint32, } from './numberFormats.ts';
+export { bigPositive, bigNegative, bigPositiveInt, bigNegativeInt, bigInt64, bigUInt64 } from './bigintFormats.ts';

package/dist/cjs/formats/numberFormats.d.ts

@@ -0,0 +1,77 @@
+import { TypeFormat } from '../runtypes/typeFormat.ts';
+export interface NumberParams {
+    integer?: boolean;
+    float?: boolean;
+    min?: number;
+    max?: number;
+    lt?: number;
+    gt?: number;
+    multipleOf?: number;
+    isCurrency?: boolean;
+}
+export type Number<P extends NumberParams = {}, BrandName extends string = never> = TypeFormat<number, 'numberFormat', P, BrandName>;
+export type Currency<P extends NumberParams = {}, BrandName extends string = never> = Number<P & {
+    isCurrency: true;
+}, BrandName>;
+export type Integer = Number<{
+    integer: true;
+}>;
+export type Float = Number<{
+    float: true;
+}>;
+export type Positive = Number<{
+    min: 0;
+}>;
+export type Negative = Number<{
+    max: 0;
+}>;
+export type PositiveInt = Number<{
+    min: 0;
+    integer: true;
+}>;
+export type NegativeInt = Number<{
+    max: 0;
+    integer: true;
+}>;
+export type Int8 = Number<{
+    integer: true;
+    min: -128;
+    max: 127;
+}>;
+export type Int16 = Number<{
+    integer: true;
+    min: -32768;
+    max: 32767;
+}>;
+export type Int32 = Number<{
+    integer: true;
+    min: -2147483648;
+    max: 2147483647;
+}>;
+export type UInt8 = Number<{
+    integer: true;
+    min: 0;
+    max: 255;
+}>;
+export type UInt16 = Number<{
+    integer: true;
+    min: 0;
+    max: 65535;
+}>;
+export type UInt32 = Number<{
+    integer: true;
+    min: 0;
+    max: 4294967295;
+}>;
+export declare const integer: (id?: import("../markers.ts").InjectRunTypeId<Integer> | undefined) => import("../index.ts").RunType<Integer>;
+export declare const float: (id?: import("../markers.ts").InjectRunTypeId<Float> | undefined) => import("../index.ts").RunType<Float>;
+export declare const positive: (id?: import("../markers.ts").InjectRunTypeId<Positive> | undefined) => import("../index.ts").RunType<Positive>;
+export declare const negative: (id?: import("../markers.ts").InjectRunTypeId<Negative> | undefined) => import("../index.ts").RunType<Negative>;
+export declare const positiveInt: (id?: import("../markers.ts").InjectRunTypeId<PositiveInt> | undefined) => import("../index.ts").RunType<PositiveInt>;
+export declare const negativeInt: (id?: import("../markers.ts").InjectRunTypeId<NegativeInt> | undefined) => import("../index.ts").RunType<NegativeInt>;
+export declare const int8: (id?: import("../markers.ts").InjectRunTypeId<Int8> | undefined) => import("../index.ts").RunType<Int8>;
+export declare const int16: (id?: import("../markers.ts").InjectRunTypeId<Int16> | undefined) => import("../index.ts").RunType<Int16>;
+export declare const int32: (id?: import("../markers.ts").InjectRunTypeId<Int32> | undefined) => import("../index.ts").RunType<Int32>;
+export declare const uint8: (id?: import("../markers.ts").InjectRunTypeId<UInt8> | undefined) => import("../index.ts").RunType<UInt8>;
+export declare const uint16: (id?: import("../markers.ts").InjectRunTypeId<UInt16> | undefined) => import("../index.ts").RunType<UInt16>;
+export declare const uint32: (id?: import("../markers.ts").InjectRunTypeId<UInt32> | undefined) => import("../index.ts").RunType<UInt32>;

package/dist/cjs/formats/scalars.d.ts

@@ -0,0 +1,32 @@
+import { brand } from '../runtypes/builderCore.ts';
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+import type { LeafType, BrandArg, ExactParams } from '../runtypes/builderTypes.ts';
+import type { StringParamsValueFirst } from './string/stringFormats.ts';
+import type { NumberParams, Currency } from './numberFormats.ts';
+import type { BigIntParams } from './bigintFormats.ts';
+import type { NativeDateParams } from './datetime/dateFormats.ts';
+export { brand };
+export declare function string(id?: InjectRunTypeId<string>): RunType<string>;
+export declare function string<const P extends StringParamsValueFirst>(formatParams: CompTimeArgs<ExactParams<P, StringParamsValueFirst>>, id?: InjectRunTypeId<LeafType<'stringFormat', P>>): RunType<LeafType<'stringFormat', P>>;
+export declare function string<const P extends StringParamsValueFirst, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, StringParamsValueFirst>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'stringFormat', P, B>>): RunType<LeafType<'stringFormat', P, B>>;
+export declare function number(id?: InjectRunTypeId<number>): RunType<number>;
+export declare function number<const P extends NumberParams>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, id?: InjectRunTypeId<LeafType<'numberFormat', P>>): RunType<LeafType<'numberFormat', P>>;
+export declare function number<const P extends NumberParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'numberFormat', P, B>>): RunType<LeafType<'numberFormat', P, B>>;
+export declare function currency(id?: InjectRunTypeId<Currency>): RunType<Currency>;
+export declare function currency<const P extends NumberParams>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, id?: InjectRunTypeId<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}>>): RunType<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}>>;
+export declare function currency<const P extends NumberParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}, B>>): RunType<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}, B>>;
+export declare function bigInt(id?: InjectRunTypeId<bigint>): RunType<bigint>;
+export declare function bigInt<const P extends BigIntParams>(formatParams: CompTimeArgs<ExactParams<P, BigIntParams>>, id?: InjectRunTypeId<LeafType<'bigintFormat', P>>): RunType<LeafType<'bigintFormat', P>>;
+export declare function bigInt<const P extends BigIntParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, BigIntParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'bigintFormat', P, B>>): RunType<LeafType<'bigintFormat', P, B>>;
+export declare function date(id?: InjectRunTypeId<Date>): RunType<Date>;
+export declare function date<const P extends NativeDateParams>(formatParams: CompTimeArgs<ExactParams<P, NativeDateParams>>, id?: InjectRunTypeId<LeafType<'nativeDate', P>>): RunType<LeafType<'nativeDate', P>>;
+export declare function date<const P extends NativeDateParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, NativeDateParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'nativeDate', P, B>>): RunType<LeafType<'nativeDate', P, B>>;

package/dist/cjs/formats/string/string-formats-pure-fns.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/formats/string/string-patterns.d.ts

@@ -0,0 +1,59 @@
+export declare const DOMAIN_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,63}$";
+    readonly mockSamples: readonly ["mion.io", "example.com", "mionkit.io", "sub.example.co.uk", "wiki.org"];
+}>;
+export declare const DOMAIN_UNICODE_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^(?:[\\p{L}\\p{N}](?:[\\p{L}\\p{N}-]{0,61}[\\p{L}\\p{N}])?\\.)+[a-zA-Z]{2,63}$";
+    readonly flags: "u";
+    readonly mockSamples: readonly ["mion.io", "example.com", "mionkit.io", "sub.example.co.uk", "wiki.org"];
+}>;
+export declare const DOMAIN_PUNYCODE_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z0-9-]{2,63}$";
+    readonly mockSamples: readonly ["xn--e1afmkfd.xn--p1ai", "example.com"];
+}>;
+export declare const DOMAIN_NAME_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[a-zA-Z0-9-]+$";
+    readonly mockSamples: readonly ["domain", "mion", "example", "wiki", "mionkit"];
+}>;
+export declare const DOMAIN_TLD_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[a-zA-Z]+(\\.[a-zA-Z]+)?$";
+    readonly mockSamples: readonly ["com", "org", "net", "io"];
+}>;
+export declare const EMAIL_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[^\\s@]{1,64}@(?:[a-zA-Z0-9-]{1,63}\\.)+[a-zA-Z]{2,63}$";
+    readonly mockSamples: readonly ["john@example.com", "jane.doe@mion.io", "contact@test.org"];
+}>;
+export declare const EMAIL_PUNYCODE_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[^\\s@]{1,64}@(?:[a-zA-Z0-9-]{1,63}\\.)+[a-zA-Z0-9-]{2,63}$";
+    readonly mockSamples: readonly ["john@example.xn--fiqs8s"];
+}>;
+export declare const URL_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^(?:https?|ftps?|wss?):\\/\\/[^\\s/$.?#-][^\\s]*$";
+    readonly flags: "i";
+    readonly mockSamples: readonly ["https://example.com", "http://mion.io/path", "ftp://files.example.org"];
+}>;
+export declare const URL_HTTP_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^https?:\\/\\/[^\\s/$.?#-][^\\s]*$";
+    readonly flags: "i";
+    readonly mockSamples: readonly ["https://example.com", "http://mion.io/a/b"];
+}>;
+export declare const URL_FILE_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^file:\\/\\/\\/?(?:[a-zA-Z]:)?[^\\s/$.?#-][^\\s]*$";
+    readonly flags: "i";
+    readonly mockSamples: readonly ["file:///etc/hosts", "file:///var/log/app.log"];
+}>;
+export declare const ALPHA_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[\\p{L}]+$";
+    readonly flags: "u";
+    readonly mockSamples: readonly ["abc", "Hello", "World"];
+}>;
+export declare const ALPHANUMERIC_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[\\p{L}\\p{N}]+$";
+    readonly flags: "u";
+    readonly mockSamples: readonly ["abc123", "Test42", "XYZ0"];
+}>;
+export declare const NUMERIC_PATTERN: import("../../runtypes/formatPattern.ts").FormatPattern<{
+    readonly source: "^[\\p{N}]+$";
+    readonly flags: "u";
+    readonly mockSamples: readonly ["123", "007", "42"];
+}>;