@mionjs/run-types 0.8.10 → 0.13.2

package/dist/cjs/formats/string/string-patterns.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE16_PATTERN = exports.BASE32_PATTERN = exports.BASE64_PATTERN = exports.NUMERIC_PATTERN = exports.ALPHANUMERIC_PATTERN = exports.ALPHA_PATTERN = exports.HOSTNAME_PATTERN = exports.URI_TEMPLATE_PATTERN = exports.IRI_REFERENCE_PATTERN = exports.IRI_PATTERN = exports.URI_REFERENCE_PATTERN = exports.URI_PATTERN = exports.RELATIVE_JSON_POINTER_PATTERN = exports.JSON_POINTER_PATTERN = exports.STRING_DURATION_PATTERN = exports.URL_FILE_PATTERN = exports.URL_HTTP_PATTERN = exports.URL_PATTERN = exports.EMAIL_PUNYCODE_PATTERN = exports.EMAIL_PATTERN = exports.DOMAIN_TLD_PATTERN = exports.DOMAIN_NAME_PATTERN = exports.DOMAIN_PUNYCODE_PATTERN = exports.DOMAIN_UNICODE_PATTERN = exports.DOMAIN_PATTERN = void 0;
+const formatPattern_ts_1 = require("../../runtypes/formatPattern.js");
+exports.DOMAIN_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,63}$',
+    mockSamples: ['mion.io', 'example.com', 'mionkit.io', 'sub.example.co.uk', 'wiki.org'],
+});
+exports.DOMAIN_UNICODE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[\\p{L}\\p{N}](?:[\\p{L}\\p{N}-]{0,61}[\\p{L}\\p{N}])?\\.)+[a-zA-Z]{2,63}$',
+    flags: 'u',
+    mockSamples: ['mion.io', 'example.com', 'mionkit.io', 'sub.example.co.uk', 'wiki.org'],
+});
+exports.DOMAIN_PUNYCODE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z0-9-]{2,63}$',
+    mockSamples: ['xn--e1afmkfd.xn--p1ai', 'example.com'],
+});
+exports.DOMAIN_NAME_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[a-zA-Z0-9-]+$',
+    mockSamples: ['domain', 'mion', 'example', 'wiki', 'mionkit'],
+});
+exports.DOMAIN_TLD_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[a-zA-Z]+(\\.[a-zA-Z]+)?$',
+    mockSamples: ['com', 'org', 'net', 'io'],
+});
+exports.EMAIL_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[^\\s@]{1,64}@(?:[a-zA-Z0-9-]{1,63}\\.)+[a-zA-Z]{2,63}$',
+    mockSamples: ['john@example.com', 'jane.doe@mion.io', 'contact@test.org'],
+});
+exports.EMAIL_PUNYCODE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[^\\s@]{1,64}@(?:[a-zA-Z0-9-]{1,63}\\.)+[a-zA-Z0-9-]{2,63}$',
+    mockSamples: ['john@example.xn--fiqs8s'],
+});
+exports.URL_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:https?|ftps?|wss?):\\/\\/[^\\s/$.?#-][^\\s]*$',
+    flags: 'i',
+    mockSamples: ['https://example.com', 'http://mion.io/path', 'ftp://files.example.org'],
+});
+exports.URL_HTTP_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^https?:\\/\\/[^\\s/$.?#-][^\\s]*$',
+    flags: 'i',
+    mockSamples: ['https://example.com', 'http://mion.io/a/b'],
+});
+exports.URL_FILE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^file:\\/\\/\\/?(?:[a-zA-Z]:)?[^\\s/$.?#-][^\\s]*$',
+    flags: 'i',
+    mockSamples: ['file:///etc/hosts', 'file:///var/log/app.log'],
+});
+exports.STRING_DURATION_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^P(?:\\d+W|(?:\\d+Y(?:\\d+M(?:\\d+D)?)?|\\d+M(?:\\d+D)?|\\d+D)(?:T(?:\\d+H(?:\\d+M(?:\\d+S)?)?|\\d+M(?:\\d+S)?|\\d+S))?|T(?:\\d+H(?:\\d+M(?:\\d+S)?)?|\\d+M(?:\\d+S)?|\\d+S))$',
+    mockSamples: ['P4DT12H30M5S', 'P1Y2M3D', 'PT1H30M', 'P2W', 'PT0S'],
+});
+exports.JSON_POINTER_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:\\/(?:[^~\\/]|~[01])*)*$',
+    mockSamples: ['', '/foo', '/foo/0', '/a~1b', '/c~0d'],
+});
+exports.RELATIVE_JSON_POINTER_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~\\/]|~[01])*)*)$',
+    mockSamples: ['0', '1/foo', '2#', '0/a~1b'],
+});
+exports.URI_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: "^[A-Za-z][A-Za-z0-9+\\-.]*:(?:\\/\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:]|%[0-9A-Fa-f]{2})*@)?(?:\\[[0-9A-Fa-f:.]+\\]|(?:[A-Za-z0-9\\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*)(?::[0-9]*)?(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*|\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*)?|(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*|)(?:\\?(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?]|%[0-9A-Fa-f]{2})*)?(?:#(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?]|%[0-9A-Fa-f]{2})*)?$",
+    flags: 'u',
+    mockSamples: ['https://example.com/path', 'mailto:ada@example.com', 'urn:isbn:0451450523', 'ftp://files.example.org/pub'],
+});
+exports.URI_REFERENCE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: "^(?:[A-Za-z][A-Za-z0-9+\\-.]*:(?:\\/\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:]|%[0-9A-Fa-f]{2})*@)?(?:\\[[0-9A-Fa-f:.]+\\]|(?:[A-Za-z0-9\\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*)(?::[0-9]*)?(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*|\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*)?|(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*|)|(?:\\/\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:]|%[0-9A-Fa-f]{2})*@)?(?:\\[[0-9A-Fa-f:.]+\\]|(?:[A-Za-z0-9\\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*)(?::[0-9]*)?(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*|\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*)?|(?:[A-Za-z0-9\\-._~!$&'()*+,;=@]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*|))(?:\\?(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?]|%[0-9A-Fa-f]{2})*)?(?:#(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?]|%[0-9A-Fa-f]{2})*)?$",
+    flags: 'u',
+    mockSamples: ['/relative/path', '../up', '#fragment', 'https://example.com'],
+});
+exports.IRI_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: "^[A-Za-z][A-Za-z0-9+\\-.]*:(?:\\/\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*@)?(?:\\[[0-9A-Fa-f:.]+\\]|(?:[A-Za-z0-9\\-._~!$&'()*+,;=\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)(?::[0-9]*)?(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*|\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*)?|(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*|)(?:\\?(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)?(?:#(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)?$",
+    flags: 'u',
+    mockSamples: ['https://example.com/päth', 'https://例え.テスト/ページ', 'mailto:ada@example.com'],
+});
+exports.IRI_REFERENCE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: "^(?:[A-Za-z][A-Za-z0-9+\\-.]*:(?:\\/\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*@)?(?:\\[[0-9A-Fa-f:.]+\\]|(?:[A-Za-z0-9\\-._~!$&'()*+,;=\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)(?::[0-9]*)?(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*|\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*)?|(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*|)|(?:\\/\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*@)?(?:\\[[0-9A-Fa-f:.]+\\]|(?:[A-Za-z0-9\\-._~!$&'()*+,;=\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)(?::[0-9]*)?(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*|\\/(?:(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*)?|(?:[A-Za-z0-9\\-._~!$&'()*+,;=@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})+(?:\\/(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)*|))(?:\\?(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)?(?:#(?:[A-Za-z0-9\\-._~!$&'()*+,;=:@\\/?\\u{A0}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFEF}\\u{10000}-\\u{EFFFD}]|%[0-9A-Fa-f]{2})*)?$",
+    flags: 'u',
+    mockSamples: ['/relative/päth', '#フラグ', 'https://例え.テスト'],
+});
+exports.URI_TEMPLATE_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[^\\x00-\\x20"\'<>\\\\^\\x60{|}\\x7F]|\\{[+#./;?&=,!@|]?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})(?:\\.?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2}))*(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})(?:\\.?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2}))*(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$',
+    mockSamples: ['http://example.com/{id}', 'http://example.com/~{username}/', 'http://example.com/search{?q,lang}', '{/path*}'],
+});
+exports.HOSTNAME_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$',
+    mockSamples: ['example.com', 'hostname', 'sub.example.co.uk', 'h0stn4me', 'a--b.com'],
+});
+exports.ALPHA_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[\\p{L}]+$',
+    flags: 'u',
+    mockSamples: ['abc', 'Hello', 'World'],
+});
+exports.ALPHANUMERIC_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[\\p{L}\\p{N}]+$',
+    flags: 'u',
+    mockSamples: ['abc123', 'Test42', 'XYZ0'],
+});
+exports.NUMERIC_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^[\\p{N}]+$',
+    flags: 'u',
+    mockSamples: ['123', '007', '42'],
+});
+exports.BASE64_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$',
+    mockSamples: ['', 'QQ==', 'QUJD', 'SGVsbG8='],
+});
+exports.BASE32_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[A-Z2-7]{8})*(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}=)?$',
+    mockSamples: ['', 'MY======', 'MZXQ===='],
+});
+exports.BASE16_PATTERN = (0, formatPattern_ts_1.registerFormatPattern)({
+    source: '^(?:[0-9A-Fa-f]{2})*$',
+    mockSamples: ['', '48656C6C6F', 'DEADBEEF'],
+});

package/dist/cjs/formats/string/stringFormats.d.ts

@@ -0,0 +1,489 @@
+import { TypeFormat } from '../../runtypes/typeFormat.ts';
+import type { FormatNameOf, FormatParamsOf, FormatBrandNameOf, FormatBrand, NominalBrand } from '../../runtypes/typeFormat.ts';
+import type { FormatPattern, StringPatternArgs } from '../../runtypes/formatPattern.ts';
+import type { ALPHA_PATTERN, ALPHANUMERIC_PATTERN, NUMERIC_PATTERN, DOMAIN_PATTERN, DOMAIN_UNICODE_PATTERN, DOMAIN_PUNYCODE_PATTERN, DOMAIN_NAME_PATTERN, DOMAIN_TLD_PATTERN, EMAIL_PATTERN, EMAIL_PUNYCODE_PATTERN, URL_PATTERN, URL_HTTP_PATTERN, URL_FILE_PATTERN, BASE64_PATTERN, BASE32_PATTERN, BASE16_PATTERN, HOSTNAME_PATTERN, STRING_DURATION_PATTERN, JSON_POINTER_PATTERN, RELATIVE_JSON_POINTER_PATTERN, URI_PATTERN, URI_REFERENCE_PATTERN, IRI_PATTERN, IRI_REFERENCE_PATTERN, URI_TEMPLATE_PATTERN } from './string-patterns.ts';
+import type { RunType } from '../../runtypes/types.ts';
+import type { BrandArg, ExactParams } from '../../runtypes/builderTypes.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../../markers.ts';
+import type { StringDate, StringTime, StringDateTime, DateParams, TimeParams, DateTimeParams } from '../datetime/stringDateTimeFormats.ts';
+export type PatternParam = FormatPattern | StringPatternArgs;
+export type Samples = string | readonly string[];
+export interface AllowedCharsParam {
+    val: string;
+    ignoreCase?: boolean;
+    errorMessage?: string;
+    desc?: string;
+    mockSamples?: Samples;
+}
+export interface DisallowedCharsParam {
+    val: string;
+    ignoreCase?: boolean;
+    errorMessage?: string;
+    desc?: string;
+    mockSamples: string;
+}
+export interface AllowedValuesParam {
+    val: readonly string[];
+    ignoreCase?: boolean;
+    errorMessage?: string;
+    desc?: string;
+    mockSamples?: Samples;
+}
+export interface DisallowedValuesParam {
+    val: readonly string[];
+    ignoreCase?: boolean;
+    errorMessage?: string;
+    desc?: string;
+    mockSamples: Samples;
+}
+export interface StringTransformParams {
+    trim?: boolean;
+    lowercase?: boolean;
+    uppercase?: boolean;
+    capitalize?: boolean;
+    replace?: {
+        searchValue: string;
+        replaceValue: string;
+    };
+    replaceAll?: {
+        searchValue: string;
+        replaceValue: string;
+    };
+}
+export interface CreditCardTransformParams extends StringTransformParams {
+    stripSeparators?: boolean;
+}
+export interface TransformParamsByFormat {
+    stringFormat: StringTransformParams;
+    email: StringTransformParams;
+    domain: StringTransformParams;
+    url: StringTransformParams;
+    ip: StringTransformParams;
+    creditCard: CreditCardTransformParams;
+}
+export type TransformParamsOf<T> = [FormatNameOf<T>] extends [never] ? StringTransformParams : FormatNameOf<T> extends keyof TransformParamsByFormat ? TransformParamsByFormat[FormatNameOf<T>] : never;
+export interface StringParams {
+    maxLength?: number;
+    minLength?: number;
+    length?: number;
+    pattern?: PatternParam;
+    allowedChars?: AllowedCharsParam;
+    disallowedChars?: DisallowedCharsParam;
+    allowedValues?: AllowedValuesParam;
+    disallowedValues?: DisallowedValuesParam;
+    mockSamples?: readonly string[];
+    contentEncoding?: 'base64' | 'base32' | 'base16';
+    contentMediaType?: 'application/json';
+    transform?: StringTransformParams;
+}
+export type StringParamsValueFirst = Omit<StringParams, 'pattern'> & {
+    pattern?: StringPatternArgs;
+};
+export type String<P extends StringParams = {}, BrandName extends string = never> = TypeFormat<string, 'stringFormat', P, BrandName>;
+export type Alpha<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', {
+    pattern: typeof ALPHA_PATTERN;
+}, P>;
+export type AlphaNumeric<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', {
+    pattern: typeof ALPHANUMERIC_PATTERN;
+}, P>;
+export type Numeric<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', {
+    pattern: typeof NUMERIC_PATTERN;
+}, P>;
+export type Lowercase<P extends Override<StringParams, 'transform'> = {}> = PresetFormat<'stringFormat', {
+    transform: {
+        lowercase: true;
+    };
+}, P>;
+export type Uppercase<P extends Override<StringParams, 'transform'> = {}> = PresetFormat<'stringFormat', {
+    transform: {
+        uppercase: true;
+    };
+}, P>;
+export type Capitalize<P extends Override<StringParams, 'transform'> = {}> = PresetFormat<'stringFormat', {
+    transform: {
+        capitalize: true;
+    };
+}, P>;
+export type Base64<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', {
+    pattern: typeof BASE64_PATTERN;
+}, P>;
+export type Base32<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', {
+    pattern: typeof BASE32_PATTERN;
+}, P>;
+export type Base16<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', {
+    pattern: typeof BASE16_PATTERN;
+}, P>;
+type DEFAULT_JSON_CONTENT_PARAMS = {
+    contentMediaType: 'application/json';
+    mockSamples: readonly [
+        '{}',
+        '[]',
+        'null',
+        '{"id":42,"name":"Ada Lovelace","active":true,"score":-1500}',
+        '{"user":{"id":7,"roles":["admin","editor"],"meta":{"seen":null}}}',
+        '[{"sku":"A-1","qty":2},{"sku":"B-7","qty":11}]',
+        '{"text":"quote \\" backslash \\\\ newline \\n","unicode":"héllo ✓"}'
+    ];
+};
+type DEFAULT_JSON_CONTENT_BASE64_PARAMS = {
+    contentEncoding: 'base64';
+    contentMediaType: 'application/json';
+    mockSamples: readonly [
+        'e30=',
+        'W10=',
+        'eyJpZCI6NDIsIm5hbWUiOiJBZGEgTG92ZWxhY2UiLCJhY3RpdmUiOnRydWV9',
+        'eyJ1c2VyIjp7ImlkIjo3LCJyb2xlcyI6WyJhZG1pbiIsImVkaXRvciJdfX0=',
+        'W3sic2t1IjoiQS0xIiwicXR5IjoyfSx7InNrdSI6IkItNyIsInF0eSI6MTF9XQ==',
+        'eyJ1bmljb2RlIjoiaMOpbGxvIOKckyIsIm5pbCI6bnVsbH0='
+    ];
+};
+export type JsonContent<P extends Override<StringParams> = {}> = PresetFormat<'stringFormat', DEFAULT_JSON_CONTENT_PARAMS, P>;
+export type JsonContentBase64<P extends Override<StringParams> = {}> = PresetFormat<'stringFormat', DEFAULT_JSON_CONTENT_BASE64_PARAMS, P>;
+export interface UUIDParams {
+    version: '4' | '7' | 'any';
+}
+export type UUID = TypeFormat<string, 'uuid', {
+    version: 'any';
+}, never>;
+export type UUIDv4 = TypeFormat<string, 'uuid', {
+    version: '4';
+}, never>;
+export type UUIDv7 = TypeFormat<string, 'uuid', {
+    version: '7';
+}, never>;
+export type IpErrorType = 'address' | 'port';
+export interface IPParams {
+    version: 4 | 6 | 'any';
+    allowLocalHost?: boolean;
+    allowPort?: boolean;
+    transform?: StringTransformParams;
+}
+type DEFAULT_IP_PARAMS = {
+    version: 'any';
+    allowLocalHost: false;
+};
+type DEFAULT_IPV4_PARAMS = {
+    version: 4;
+    allowLocalHost: false;
+};
+type DEFAULT_IPV6_PARAMS = {
+    version: 6;
+    allowLocalHost: false;
+};
+type DEFAULT_IP_PORT_PARAMS = {
+    version: 'any';
+    allowLocalHost: false;
+    allowPort: true;
+};
+type DEFAULT_IPV4_PORT_PARAMS = {
+    version: 4;
+    allowLocalHost: false;
+    allowPort: true;
+};
+type DEFAULT_IPV6_PORT_PARAMS = {
+    version: 6;
+    allowLocalHost: false;
+    allowPort: true;
+};
+export type IP<P extends Override<IPParams> = {}> = PresetFormat<'ip', DEFAULT_IP_PARAMS, P>;
+export type IPv4<P extends Override<IPParams, 'version'> = {}> = PresetFormat<'ip', DEFAULT_IPV4_PARAMS, P>;
+export type IPv6<P extends Override<IPParams, 'version'> = {}> = PresetFormat<'ip', DEFAULT_IPV6_PARAMS, P>;
+export type IPWithPort<P extends Override<IPParams, 'allowPort'> = {}> = PresetFormat<'ip', DEFAULT_IP_PORT_PARAMS, P>;
+export type IPv4WithPort<P extends Override<IPParams, 'version' | 'allowPort'> = {}> = PresetFormat<'ip', DEFAULT_IPV4_PORT_PARAMS, P>;
+export type IPv6WithPort<P extends Override<IPParams, 'version' | 'allowPort'> = {}> = PresetFormat<'ip', DEFAULT_IPV6_PORT_PARAMS, P>;
+export interface DomainPartParams {
+    maxLength?: number;
+    minLength?: number;
+    pattern?: PatternParam | {
+        source: string;
+        flags?: string;
+    };
+    allowedValues?: AllowedValuesParam;
+    disallowedValues?: DisallowedValuesParam;
+    mockSamples?: Samples;
+}
+export type DomainErrorType = 'label' | 'tld' | 'punycode' | 'bidi' | 'length';
+export interface DomainParams {
+    maxLength?: number;
+    minLength?: number;
+    pattern?: PatternParam | {
+        val: RegExp;
+    };
+    mockSamples?: readonly string[];
+    allowedValues?: AllowedValuesParam;
+    transform?: StringTransformParams;
+}
+export interface DomainPartsParams extends DomainParams {
+    maxParts?: number;
+    minParts?: number;
+    names?: DomainPartParams;
+    tld?: DomainPartParams;
+}
+type DEFAULT_DOMAIN_PARAMS = {
+    pattern: typeof DOMAIN_PATTERN;
+    maxLength: 253;
+    minLength: 5;
+};
+type DEFAULT_DOMAIN_UNICODE_PARAMS = {
+    pattern: typeof DOMAIN_UNICODE_PATTERN;
+    maxLength: 253;
+    minLength: 5;
+};
+type DEFAULT_DOMAIN_PUNYCODE_PARAMS = {
+    pattern: typeof DOMAIN_PUNYCODE_PATTERN;
+    maxLength: 253;
+    minLength: 5;
+};
+export type Domain<P extends Override<DomainParams> = {}> = PresetFormat<'domain', DEFAULT_DOMAIN_PARAMS, P>;
+export type DomainUnicode<P extends Override<DomainParams, 'pattern'> = {}> = PresetFormat<'domain', DEFAULT_DOMAIN_UNICODE_PARAMS, P>;
+export type DomainPunycode<P extends Override<DomainParams, 'pattern'> = {}> = PresetFormat<'domain', DEFAULT_DOMAIN_PUNYCODE_PARAMS, P>;
+export type DEFAULT_DOMAIN_PARTS_PARAMS = {
+    maxParts: 6;
+    minParts: 2;
+    maxLength: 253;
+    minLength: 5;
+    names: {
+        maxLength: 63;
+        minLength: 2;
+        pattern: typeof DOMAIN_NAME_PATTERN;
+    };
+    tld: {
+        maxLength: 12;
+        minLength: 2;
+        pattern: typeof DOMAIN_TLD_PATTERN;
+    };
+};
+export type DomainParts<P extends Override<DomainPartsParams, 'names' | 'tld'> = {}> = PresetFormat<'domain', DEFAULT_DOMAIN_PARTS_PARAMS, P>;
+type FormatDefaults<Defaults extends object, P> = [keyof P] extends [never] ? Defaults : {
+    [K in keyof Defaults | keyof P]: K extends keyof P ? P[K] : K extends keyof Defaults ? Defaults[K] : never;
+};
+export type PresetFormat<Tag extends string, Defaults extends object, P = {}> = TypeFormat<string, Tag, FormatDefaults<Defaults, P>, never>;
+export type Override<Params, Pinned extends keyof Params = never> = Omit<Partial<Params>, Pinned>;
+export type Transform<T extends string, P extends TransformParamsOf<T>> = [FormatNameOf<T>] extends [never] ? TypeFormat<string, 'stringFormat', {
+    transform: P;
+}, never> : TypeFormat<string, FormatNameOf<T>, FormatDefaults<FormatParamsOf<T> & object, {
+    transform: P;
+}>, FormatBrandNameOf<T>>;
+export type EmailErrorType = 'format' | 'localPart' | 'domain' | 'addressLiteral' | 'length';
+export interface EmailParams {
+    maxLength?: number;
+    minLength?: number;
+    pattern?: PatternParam | {
+        val: RegExp;
+    };
+    mockSamples?: readonly string[];
+    transform?: StringTransformParams;
+}
+export interface EmailPartsParams extends EmailParams {
+    localPart?: StringParams;
+    domain?: DomainPartsParams;
+}
+type DEFAULT_EMAIL_PARAMS = {
+    pattern: typeof EMAIL_PATTERN;
+    maxLength: 254;
+    minLength: 7;
+};
+type DEFAULT_EMAIL_ADDRESS_PARAMS = {
+    emailRfc: 'ascii';
+    maxLength: 254;
+    mockSamples: ['joe.bloggs@example.com', 'jane@mion.io', 'contact@test.org'];
+};
+type DEFAULT_IDN_EMAIL_PARAMS = {
+    emailRfc: 'unicode';
+    maxLength: 254;
+    mockSamples: ['joe.bloggs@example.com', 'δοκιμή@example.com'];
+};
+type DEFAULT_EMAIL_PUNYCODE_PARAMS = {
+    pattern: typeof EMAIL_PUNYCODE_PATTERN;
+    maxLength: 254;
+    minLength: 7;
+};
+export type Email<P extends Override<EmailParams> = {}> = PresetFormat<'email', DEFAULT_EMAIL_PARAMS, P>;
+export type EmailAddress<P extends Override<EmailParams, 'pattern'> = {}> = PresetFormat<'email', DEFAULT_EMAIL_ADDRESS_PARAMS, P>;
+export type IdnEmail<P extends Override<EmailParams, 'pattern'> = {}> = PresetFormat<'email', DEFAULT_IDN_EMAIL_PARAMS, P>;
+export type EmailPunycode<P extends Override<EmailParams, 'pattern'> = {}> = PresetFormat<'email', DEFAULT_EMAIL_PUNYCODE_PARAMS, P>;
+export type DEFAULT_EMAIL_PARTS_PARAMS = {
+    maxLength: 254;
+    localPart: {
+        maxLength: 64;
+        minLength: 1;
+        disallowedChars: {
+            val: ' ()<>[]:;\\,{}|+@';
+            errorMessage: 'Invalid characters in email local part';
+            mockSamples: 'abcdefghijklmnopqrstuvwxyz0123456789._-';
+        };
+    };
+    domain: DEFAULT_DOMAIN_PARTS_PARAMS;
+};
+export type EmailParts<P extends Override<EmailPartsParams, 'localPart' | 'domain'> = {}> = PresetFormat<'email', DEFAULT_EMAIL_PARTS_PARAMS, P>;
+export interface UrlParams {
+    maxLength?: number;
+    minLength?: number;
+    pattern?: PatternParam | {
+        val: RegExp;
+    };
+    mockSamples?: readonly string[];
+    transform?: StringTransformParams;
+}
+type DEFAULT_URI_PARAMS = {
+    pattern: typeof URI_PATTERN;
+};
+type DEFAULT_URI_REFERENCE_PARAMS = {
+    pattern: typeof URI_REFERENCE_PATTERN;
+};
+type DEFAULT_IRI_PARAMS = {
+    pattern: typeof IRI_PATTERN;
+};
+type DEFAULT_IRI_REFERENCE_PARAMS = {
+    pattern: typeof IRI_REFERENCE_PATTERN;
+};
+type DEFAULT_URI_TEMPLATE_PARAMS = {
+    pattern: typeof URI_TEMPLATE_PATTERN;
+};
+type DEFAULT_HOSTNAME_PARAMS = {
+    pattern: typeof HOSTNAME_PATTERN;
+    maxLength: 253;
+    idna: 'ascii';
+};
+type DEFAULT_IDN_HOSTNAME_PARAMS = {
+    maxLength: 253;
+    idna: 'unicode';
+};
+type DEFAULT_STRING_DURATION_PARAMS = {
+    pattern: typeof STRING_DURATION_PATTERN;
+};
+type DEFAULT_REGEX_PARAMS = {
+    isRegex: true;
+    mockSamples: ['^[a-z]+$', '\\d{4}-\\d{2}-\\d{2}', '(foo|bar)+', '^.*$'];
+};
+type DEFAULT_JSON_POINTER_PARAMS = {
+    pattern: typeof JSON_POINTER_PATTERN;
+};
+type DEFAULT_RELATIVE_JSON_POINTER_PARAMS = {
+    pattern: typeof RELATIVE_JSON_POINTER_PATTERN;
+};
+type DEFAULT_URL_PARAMS = {
+    pattern: typeof URL_PATTERN;
+    maxLength: 2048;
+};
+type DEFAULT_URL_HTTP_PARAMS = {
+    pattern: typeof URL_HTTP_PATTERN;
+    maxLength: 2048;
+};
+type DEFAULT_URL_FILE_PARAMS = {
+    pattern: typeof URL_FILE_PATTERN;
+    maxLength: 2048;
+};
+export type StringUrl<P extends Override<UrlParams> = {}> = PresetFormat<'url', DEFAULT_URL_PARAMS, P>;
+export type StringUrlHttp<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_URL_HTTP_PARAMS, P>;
+export type StringUrlFile<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_URL_FILE_PARAMS, P>;
+type UrlInstance = typeof globalThis extends {
+    URL: {
+        prototype: infer I;
+    };
+} ? I : never;
+export type UrlObjectParams = Omit<UrlParams, 'transform'>;
+export type UrlObjectFormat<P extends object, BrandName extends string = never> = UrlInstance & FormatBrand<'nativeUrl', P> & ([BrandName] extends [never] ? unknown : NominalBrand<BrandName>);
+export type Url<P extends UrlObjectParams = {}, BrandName extends string = never> = UrlObjectFormat<P, BrandName>;
+export type UrlHttp<P extends Override<UrlObjectParams, 'pattern'> = {}> = UrlObjectFormat<FormatDefaults<DEFAULT_URL_HTTP_PARAMS, P>>;
+export type UrlFile<P extends Override<UrlObjectParams, 'pattern'> = {}> = UrlObjectFormat<FormatDefaults<DEFAULT_URL_FILE_PARAMS, P>>;
+export type Uri<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_URI_PARAMS, P>;
+export type UriReference<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_URI_REFERENCE_PARAMS, P>;
+export type Iri<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_IRI_PARAMS, P>;
+export type IriReference<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_IRI_REFERENCE_PARAMS, P>;
+export type UriTemplate<P extends Override<UrlParams, 'pattern'> = {}> = PresetFormat<'url', DEFAULT_URI_TEMPLATE_PARAMS, P>;
+export type Hostname<P extends Override<DomainParams, 'pattern'> = {}> = PresetFormat<'domain', DEFAULT_HOSTNAME_PARAMS, P>;
+export type IdnHostname<P extends Override<DomainParams, 'pattern'> = {}> = PresetFormat<'domain', DEFAULT_IDN_HOSTNAME_PARAMS, P>;
+export type StringDuration<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', DEFAULT_STRING_DURATION_PARAMS, P>;
+export type RegexString<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', DEFAULT_REGEX_PARAMS, P>;
+export type JsonPointer<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', DEFAULT_JSON_POINTER_PARAMS, P>;
+export type RelativeJsonPointer<P extends Override<StringParams, 'pattern'> = {}> = PresetFormat<'stringFormat', DEFAULT_RELATIVE_JSON_POINTER_PARAMS, P>;
+export interface PresetFormatBuilder<Tag extends string, Defaults extends object, Params> {
+    (id?: InjectRunTypeId<PresetFormat<Tag, Defaults>>): RunType<PresetFormat<Tag, Defaults>>;
+    <const P extends Params>(formatParams: CompTimeArgs<ExactParams<P, Params>>, id?: InjectRunTypeId<PresetFormat<Tag, Defaults, P>>): RunType<PresetFormat<Tag, Defaults, P>>;
+}
+export declare function presetFormatBuilder<Tag extends string, Defaults extends object, Params>(tag: Tag): PresetFormatBuilder<Tag, Defaults, Params>;
+export declare const alpha: PresetFormatBuilder<"stringFormat", {
+    pattern: typeof ALPHA_PATTERN;
+}, Override<StringParams, "pattern">>;
+export declare const alphaNumeric: PresetFormatBuilder<"stringFormat", {
+    pattern: typeof ALPHANUMERIC_PATTERN;
+}, Override<StringParams, "pattern">>;
+export declare const numeric: PresetFormatBuilder<"stringFormat", {
+    pattern: typeof NUMERIC_PATTERN;
+}, Override<StringParams, "pattern">>;
+export declare const base64: PresetFormatBuilder<"stringFormat", {
+    pattern: typeof BASE64_PATTERN;
+}, Override<StringParams, "pattern">>;
+export declare const base32: PresetFormatBuilder<"stringFormat", {
+    pattern: typeof BASE32_PATTERN;
+}, Override<StringParams, "pattern">>;
+export declare const base16: PresetFormatBuilder<"stringFormat", {
+    pattern: typeof BASE16_PATTERN;
+}, Override<StringParams, "pattern">>;
+export declare const jsonContent: PresetFormatBuilder<"stringFormat", DEFAULT_JSON_CONTENT_PARAMS, Override<StringParams, never>>;
+export declare const jsonContentBase64: PresetFormatBuilder<"stringFormat", DEFAULT_JSON_CONTENT_BASE64_PARAMS, Override<StringParams, never>>;
+export declare const lowercase: PresetFormatBuilder<"stringFormat", {
+    transform: {
+        lowercase: true;
+    };
+}, Override<StringParams, "transform">>;
+export declare const uppercase: PresetFormatBuilder<"stringFormat", {
+    transform: {
+        uppercase: true;
+    };
+}, Override<StringParams, "transform">>;
+export declare const capitalize: PresetFormatBuilder<"stringFormat", {
+    transform: {
+        capitalize: true;
+    };
+}, Override<StringParams, "transform">>;
+export declare function transform<T extends string, const P extends TransformParamsOf<T>>(runType: RunType<T>, transformParams: CompTimeArgs<ExactParams<P, TransformParamsOf<T>>>, id?: InjectRunTypeId<Transform<T, P>>): RunType<Transform<T, P>>;
+export declare const uuid: (id?: InjectRunTypeId<UUID> | undefined) => RunType<UUID>;
+export declare const uuidv4: (id?: InjectRunTypeId<UUIDv4> | undefined) => RunType<UUIDv4>;
+export declare const uuidv7: (id?: InjectRunTypeId<UUIDv7> | undefined) => RunType<UUIDv7>;
+export declare const ip: PresetFormatBuilder<"ip", DEFAULT_IP_PARAMS, Override<IPParams, never>>;
+export declare const ipv4: PresetFormatBuilder<"ip", DEFAULT_IPV4_PARAMS, Override<IPParams, "version">>;
+export declare const ipv6: PresetFormatBuilder<"ip", DEFAULT_IPV6_PARAMS, Override<IPParams, "version">>;
+export declare const ipWithPort: PresetFormatBuilder<"ip", DEFAULT_IP_PORT_PARAMS, Override<IPParams, "allowPort">>;
+export declare const ipv4WithPort: PresetFormatBuilder<"ip", DEFAULT_IPV4_PORT_PARAMS, Override<IPParams, "version" | "allowPort">>;
+export declare const ipv6WithPort: PresetFormatBuilder<"ip", DEFAULT_IPV6_PORT_PARAMS, Override<IPParams, "version" | "allowPort">>;
+export declare const uri: PresetFormatBuilder<"url", DEFAULT_URI_PARAMS, Override<UrlParams, "pattern">>;
+export declare const uriReference: PresetFormatBuilder<"url", DEFAULT_URI_REFERENCE_PARAMS, Override<UrlParams, "pattern">>;
+export declare const iri: PresetFormatBuilder<"url", DEFAULT_IRI_PARAMS, Override<UrlParams, "pattern">>;
+export declare const iriReference: PresetFormatBuilder<"url", DEFAULT_IRI_REFERENCE_PARAMS, Override<UrlParams, "pattern">>;
+export declare const uriTemplate: PresetFormatBuilder<"url", DEFAULT_URI_TEMPLATE_PARAMS, Override<UrlParams, "pattern">>;
+export declare const hostname: PresetFormatBuilder<"domain", DEFAULT_HOSTNAME_PARAMS, Override<DomainParams, "pattern">>;
+export declare const idnHostname: PresetFormatBuilder<"domain", DEFAULT_IDN_HOSTNAME_PARAMS, Override<DomainParams, "pattern">>;
+export declare const stringDuration: PresetFormatBuilder<"stringFormat", DEFAULT_STRING_DURATION_PARAMS, Override<StringParams, "pattern">>;
+export declare const regexString: PresetFormatBuilder<"stringFormat", DEFAULT_REGEX_PARAMS, Override<StringParams, "pattern">>;
+export declare const jsonPointer: PresetFormatBuilder<"stringFormat", DEFAULT_JSON_POINTER_PARAMS, Override<StringParams, "pattern">>;
+export declare const relativeJsonPointer: PresetFormatBuilder<"stringFormat", DEFAULT_RELATIVE_JSON_POINTER_PARAMS, Override<StringParams, "pattern">>;
+export declare const domain: PresetFormatBuilder<"domain", DEFAULT_DOMAIN_PARAMS, Override<DomainParams, never>>;
+export declare const domainUnicode: PresetFormatBuilder<"domain", DEFAULT_DOMAIN_UNICODE_PARAMS, Override<DomainParams, "pattern">>;
+export declare const domainPunycode: PresetFormatBuilder<"domain", DEFAULT_DOMAIN_PUNYCODE_PARAMS, Override<DomainParams, "pattern">>;
+export declare const domainParts: PresetFormatBuilder<"domain", DEFAULT_DOMAIN_PARTS_PARAMS, Override<DomainPartsParams, "tld" | "names">>;
+export declare const email: PresetFormatBuilder<"email", DEFAULT_EMAIL_PARAMS, Override<EmailParams, never>>;
+export declare const emailAddress: PresetFormatBuilder<"email", DEFAULT_EMAIL_ADDRESS_PARAMS, Override<EmailParams, "pattern">>;
+export declare const idnEmail: PresetFormatBuilder<"email", DEFAULT_IDN_EMAIL_PARAMS, Override<EmailParams, "pattern">>;
+export declare const emailPunycode: PresetFormatBuilder<"email", DEFAULT_EMAIL_PUNYCODE_PARAMS, Override<EmailParams, "pattern">>;
+export declare const emailParts: PresetFormatBuilder<"email", DEFAULT_EMAIL_PARTS_PARAMS, Override<EmailPartsParams, "domain" | "localPart">>;
+export declare const stringUrl: PresetFormatBuilder<"url", DEFAULT_URL_PARAMS, Override<UrlParams, never>>;
+export declare const stringUrlHttp: PresetFormatBuilder<"url", DEFAULT_URL_HTTP_PARAMS, Override<UrlParams, "pattern">>;
+export declare const stringUrlFile: PresetFormatBuilder<"url", DEFAULT_URL_FILE_PARAMS, Override<UrlParams, "pattern">>;
+export declare function url(id?: InjectRunTypeId<UrlInstance>): RunType<UrlInstance>;
+export declare function url<const P extends UrlObjectParams>(formatParams: CompTimeArgs<ExactParams<P, UrlObjectParams>>, id?: InjectRunTypeId<Url<P>>): RunType<Url<P>>;
+export declare function url<const P extends UrlObjectParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, UrlObjectParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<Url<P, B>>): RunType<Url<P, B>>;
+export interface UrlObjectPresetBuilder<Defaults extends object> {
+    (id?: InjectRunTypeId<UrlObjectFormat<Defaults>>): RunType<UrlObjectFormat<Defaults>>;
+    <const P extends Override<UrlObjectParams, 'pattern'>>(formatParams: CompTimeArgs<ExactParams<P, Override<UrlObjectParams, 'pattern'>>>, id?: InjectRunTypeId<UrlObjectFormat<FormatDefaults<Defaults, P>>>): RunType<UrlObjectFormat<FormatDefaults<Defaults, P>>>;
+}
+export declare const urlHttp: UrlObjectPresetBuilder<DEFAULT_URL_HTTP_PARAMS>;
+export declare const urlFile: UrlObjectPresetBuilder<DEFAULT_URL_FILE_PARAMS>;
+export declare function stringDate(id?: InjectRunTypeId<StringDate>): RunType<StringDate>;
+export declare function stringDate<const P extends Partial<DateParams>>(formatParams: CompTimeArgs<ExactParams<P, Partial<DateParams>>>, id?: InjectRunTypeId<StringDate<P>>): RunType<StringDate<P>>;
+export declare function stringTime(id?: InjectRunTypeId<StringTime>): RunType<StringTime>;
+export declare function stringTime<const P extends Partial<TimeParams>>(formatParams: CompTimeArgs<ExactParams<P, Partial<TimeParams>>>, id?: InjectRunTypeId<StringTime<P>>): RunType<StringTime<P>>;
+export declare function stringDateTime(id?: InjectRunTypeId<StringDateTime>): RunType<StringDateTime>;
+export declare function stringDateTime<const P extends Partial<DateTimeParams>>(formatParams: CompTimeArgs<ExactParams<P, Partial<DateTimeParams>>>, id?: InjectRunTypeId<StringDateTime<P>>): RunType<StringDateTime<P>>;
+export {};