Built-in Formats

import {StrEmail, StrEmailStrict, StrEmailPunycode} from '@mionkit/type-formats/FormatsString';

import {StrEmail} from '@mionkit/type-formats/FormatsString';

type UserEmail = StrEmail;

// 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 {StrEmailStrict} from '@mionkit/type-formats/FormatsString';

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

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

import {StrEmailPunycode} from '@mionkit/type-formats/FormatsString';

type InternationalEmail = StrEmailPunycode;

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

import {StrUrl, StrUrlHttp, StrUrlFile} from '@mionkit/type-formats/FormatsString';

import {StrUrl, StrUrlHttp, StrUrlFile} from '@mionkit/type-formats/FormatsString';

type GeneralUrl = StrUrl;
type WebUrl = StrUrlHttp;
type FileUrl = StrUrlFile;

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

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

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

import {StrDomain, StrDomainStrict} from '@mionkit/type-formats/FormatsString';

import {StrDomain, StrDomainStrict} from '@mionkit/type-formats/FormatsString';

type QuickDomain = StrDomain;
type DetailedDomain = StrDomainStrict;

// 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 {StrDomainStrict} from '@mionkit/type-formats/FormatsString';

type SocialMediaDomain = StrDomainStrict<{
    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 {StrUUIDv4, StrUUIDv7} from '@mionkit/type-formats/FormatsString';

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

import {StrIP, StrIPv4, StrIPv6, StrIPWithPort} from '@mionkit/type-formats/FormatsString';

type AnyIP = StrIP; // IPv4 or IPv6
type OnlyV4 = StrIPv4; // IPv4 only
type OnlyV6 = StrIPv6; // IPv6 only
type WithPort = StrIPWithPort; // Any IP with port support

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

import {StrDate} from '@mionkit/type-formats/FormatsString';

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

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

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

import {StrTime} from '@mionkit/type-formats/FormatsString';

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

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

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

import {StrDateTime} from '@mionkit/type-formats/FormatsString';

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

// Custom combination
type CustomDateTime = StrDateTime<{
    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 = StrDateTime<{
    date: {format: 'MM-DD'};
    time: {format: 'HH'};
}>;
// Example: '01-15T14'

import {StrAlphaNumeric, StrAlpha, StrNumeric, StrLowercase, StrUppercase} from '@mionkit/type-formats/FormatsString';

type Username = StrAlphaNumeric; // Letters and numbers only
type Name = StrAlpha; // Letters only (supports Unicode)
type Code = StrNumeric; // Digits only
type Slug = StrLowercase; // Forced lowercase
type Initials = StrUppercase; // Forced uppercase

import {StrFormat} from '@mionkit/type-formats/FormatsString';

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

// Slug with pattern validation
const slugRegex = /^[a-z0-9-]+$/;
type Slug = StrFormat<{
    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 = StrFormat<{
    minLength: 1;
    maxLength: 50;
    allowedChars: {
        val: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ';
        errorMessage: 'Name can only contain letters and spaces';
    };
    capitalize: true;
}>;

import {
    NumFormat,
    NumInteger,
    NumFloat,
    NumPositive,
    NumNegative,
    NumPositiveInt,
    NumNegativeInt,
    NumInt8,
    NumInt16,
    NumInt32,
    NumUInt8,
    NumUInt16,
    NumUInt32,
} from '@mionkit/type-formats/FormatsNumber';

import {NumFormat} from '@mionkit/type-formats/FormatsNumber';

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

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

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