Built-in Formats

import {FormatEmail, FormatEmailStrict, FormatEmailPunycode} from '@mionjs/type-formats/StringFormats';

import {FormatEmail} from '@mionjs/type-formats/StringFormats';

type UserEmail = FormatEmail;

// Valid
('user@example.com'); // ✓
('user+tag@example.com'); // ✓ (allows + for email aliases)
('user(comment)@test.com'); // ✓

// Invalid
('user@name@example.com'); // ✗ (multiple @)
('@example.com'); // ✗ (missing local part)

import {FormatEmailStrict} from '@mionjs/type-formats/StringFormats';

// Valid
('user@example.com'); // ✓
('user.name@sub.domain.com'); // ✓

// Invalid (stricter than FormatEmail)
('user+tag@example.com'); // ✗ (disallows special chars)
('user(comment)@test.com'); // ✗ (disallows parentheses)

import {FormatEmailPunycode} from '@mionjs/type-formats/StringFormats';

type InternationalEmail = FormatEmailPunycode;

// Valid
('user@xn--80akhbyknj4f.xn--p1ai'); // ✓ (punycode domain)
('user@sub-domain.example.com'); // ✓ (hyphenated domains)

import {FormatUrl, FormatUrlHttp, FormatUrlFile} from '@mionjs/type-formats/StringFormats';

import {FormatUrl, FormatUrlHttp, FormatUrlFile} from '@mionjs/type-formats/StringFormats';

type GeneralUrl = FormatUrl;
type WebUrl = FormatUrlHttp;
type FileUrl = FormatUrlFile;

// FormatUrl - accepts multiple protocols
('http://example.com'); // ✓
('https://example.com'); // ✓
('ftp://example.com'); // ✓
('ws://example.com'); // ✓

// FormatUrlHttp - HTTP/HTTPS only
('http://example.com'); // ✓
('https://example.com'); // ✓
('ftp://example.com'); // ✗
('ws://example.com'); // ✗

// FormatUrlFile - file protocol only
('file://hello.png'); // ✓
('file:///c:/lorem/ipsum.jpg'); // ✓
('http://example.com'); // ✗

import {FormatDomain, FormatDomainStrict} from '@mionjs/type-formats/StringFormats';

import {FormatDomain, FormatDomainStrict} from '@mionjs/type-formats/StringFormats';

type QuickDomain = FormatDomain;
type DetailedDomain = FormatDomainStrict;

// Both validate the same cases
('example.com'); // ✓
('sub.example.com'); // ✓
('example.co.uk'); // ✓

// Invalid for both
('example'); // ✗ (missing TLD)
('example..com'); // ✗ (empty part)
('exa!mple.com'); // ✗ (invalid characters)

import {FormatDomainStrict} from '@mionjs/type-formats/StringFormats';

type SocialMediaDomain = FormatDomainStrict<{
    maxLength: 200;
    minParts: 2;
    maxParts: 3;
    names: {
        allowedValues: {
            val: ['facebook', 'twitter', 'instagram', 'linkedin'];
            errorMessage: 'Only social media domains allowed';
        };
    };
    tld: {
        allowedValues: {
            val: ['com'];
            errorMessage: 'Only .com TLD allowed';
        };
    };
}>;

import {FormatUUIDv4, FormatUUIDv7} from '@mionjs/type-formats/StringFormats';

type UserId = FormatUUIDv4; // Standard UUID v4: xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx
type EventId = FormatUUIDv7; // Time-ordered UUID v7: xxxxxxxx-xxxx-7xxx-xxxx-xxxxxxxxxxxx

import {FormatIP, FormatIPv4, FormatIPv6, FormatIPWithPort} from '@mionjs/type-formats/StringFormats';

type AnyIP = FormatIP; // IPv4 or IPv6
type OnlyV4 = FormatIPv4; // IPv4 only
type OnlyV6 = FormatIPv6; // IPv6 only
type WithPort = FormatIPWithPort; // Any IP with port support

// Examples
('192.168.0.1'); // ✓ FormatIPv4
('2001:0db8:85a3::8a2e:0370:7334'); // ✓ FormatIPv6
('localhost'); // ✓ (when allowLocalHost: true)

import {FormatStringDate} from '@mionjs/type-formats/StringFormats';

// Default ISO format
type ISODate = FormatStringDate; // 'YYYY-MM-DD'

// Custom formats
type EuropeanDate = FormatStringDate<{format: 'DD-MM-YYYY'}>;
type USDate = FormatStringDate<{format: 'MM-DD-YYYY'}>;
type MonthYear = FormatStringDate<{format: 'YYYY-MM'}>;

// Validates leap years correctly
('2000-02-29'); // ✓ (leap year)
('1900-02-29'); // ✗ (not a leap year)

import {FormatStringTime} from '@mionjs/type-formats/StringFormats';

// Default ISO format with timezone
type ISOTime = FormatStringTime; // 'HH:mm:ss[.mmm]TZ'

// Custom formats
type SimpleTime = FormatStringTime<{format: 'HH:mm:ss'}>;
type ShortTime = FormatStringTime<{format: 'HH:mm'}>;
type Duration = FormatStringTime<{format: 'mm:ss'}>;

// ISO time examples
('14:30:00Z'); // ✓ UTC
('14:30:00+05:30'); // ✓ with offset
('14:30:00.123Z'); // ✓ with milliseconds

import {FormatStringDateTime} from '@mionjs/type-formats/StringFormats';

// Default: ISO date + ISO time, separated by 'T'
type ISODateTime = FormatStringDateTime;
// Example: '2023-01-15T14:30:00Z'

// Custom combination
type CustomDateTime = FormatStringDateTime<{
    date: {format: 'DD-MM-YYYY'};
    time: {format: 'HH:mm'};
    splitChar: ' '; // space separator instead of 'T'
}>;
// Example: '15-01-2023 14:30'

// Short datetime
type ShortDateTime = FormatStringDateTime<{
    date: {format: 'MM-DD'};
    time: {format: 'HH'};
}>;
// Example: '01-15T14'

import {
    FormatAlphaNumeric,
    FormatAlpha,
    FormatNumeric,
    FormatLowercase,
    FormatUppercase,
} from '@mionjs/type-formats/StringFormats';

type Username = FormatAlphaNumeric; // Letters and numbers only
type Name = FormatAlpha; // Letters only (supports Unicode)
type Code = FormatNumeric; // Digits only
type Slug = FormatLowercase; // Forced lowercase
type Initials = FormatUppercase; // Forced uppercase

import {FormatString} from '@mionjs/type-formats/StringFormats';

// Username: 3-20 chars, lowercase, trimmed
type Username = FormatString<{
    minLength: 3;
    maxLength: 20;
    lowercase: true;
    trim: true;
}>;

// Slug with pattern validation
const slugRegex = /^[a-z0-9-]+$/;
type Slug = FormatString<{
    minLength: 1;
    maxLength: 100;
    pattern: {
        val: typeof slugRegex;
        errorMessage: 'Slug can only contain lowercase letters, numbers, and hyphens';
        mockSamples: ['my-post', 'hello-world', 'article-123'];
    };
}>;

// Name with allowed characters only
type SafeName = FormatString<{
    minLength: 1;
    maxLength: 50;
    allowedChars: {
        val: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ';
        errorMessage: 'Name can only contain letters and spaces';
    };
    capitalize: true;
}>;

import {
    FormatNumber,
    FormatInteger,
    FormatFloat,
    FormatPositive,
    FormatNegative,
    FormatPositiveInt,
    FormatNegativeInt,
    FormatInt8,
    FormatInt16,
    FormatInt32,
    FormatUInt8,
    FormatUInt16,
    FormatUInt32,
} from '@mionjs/type-formats/NumberFormats';

import {FormatNumber} from '@mionjs/type-formats/NumberFormats';

// Age with valid range
type Age = FormatNumber<{
    min: 0;
    max: 120;
    integer: true;
}>;

// Percentage with decimals
type Percentage = FormatNumber<{
    min: 0;
    max: 100;
}>;

// Price must be multiple of 0.01 (cents)
type Price = FormatNumber<{
    min: 0;
    multipleOf: 1; // multipleOf must be integer
    integer: true; // store as cents
}>;

import {
    FormatBigInt,
    FormatBigPositive,
    FormatBigNegative,
    FormatBigPositiveInt,
    FormatBigNegativeInt,
    FormatBigInt64,
    FormatBigUInt64,
} from '@mionjs/type-formats/BigintFormats';

// Predefined bigint formats
type AccountBalance = FormatBigPositive; // bigint >= 0n
type DebtAmount = FormatBigNegative; // bigint <= 0n
type ItemCount = FormatBigPositiveInt; // positive integer bigint
type Adjustment = FormatBigNegativeInt; // negative integer bigint
type DbBigInt = FormatBigInt64; // signed 64-bit, 8-byte binary
type DbUBigInt = FormatBigUInt64; // unsigned 64-bit, 8-byte binary

// Custom bigint format with all parameters
type Score = FormatBigInt<{
    min: 0n;
    max: 1000000n;
    multipleOf: 10n;
}>;

type Wallet = {
    balance: AccountBalance;
    debt: DebtAmount;
    items: ItemCount;
    adjustment: Adjustment;
    dbId: DbBigInt;
    dbUid: DbUBigInt;
    score: Score;
};