Validation

dist/
  user.dto.js                             # tsgo output
  user.dto.CreateUserDto.tsgonest.js      # companion
  user.dto.CreateUserDto.tsgonest.d.ts    # companion types

// validate — returns a result object, never throws
export function validateCreateUserDto(input: unknown): {
  success: boolean;
  data?: CreateUserDto;
  errors?: Array<{ path: string; expected: string; received: string }>;
};

// assert — throws TsgonestValidationError on failure, returns validated data
export function assertCreateUserDto(input: unknown): CreateUserDto;

// serialize — fast JSON serialization (see Serialization docs)
export function serializeCreateUserDto(input: CreateUserDto): string;

// schema — Standard Schema v1 wrapper (see Standard Schema section)
export function schemaCreateUserDto(): StandardSchemaV1<CreateUserDto>;

const result = validateCreateUserDto(input);

if (!result.success) {
  console.log(result.errors);
  // [
  //   { path: "input.email", expected: "string (email)", received: "string" },
  //   { path: "input.age", expected: "number", received: "string" }
  // ]
}

try {
  const dto = assertCreateUserDto(input);
  // dto is guaranteed to be valid CreateUserDto
} catch (err) {
  // TsgonestValidationError with structured error details
}

export interface CreateUserDto {
  /**
   * @minLength 1
   * @maxLength 255
   * @transform trim
   */
  name: string;

  /** @format email */
  email: string;

  /**
   * @minimum 0
   * @maximum 150
   */
  age: number;

  /** @pattern ^https?:\/\/ */
  website?: string;
}

import { Min, Max, Email, Trim, Pattern } from '@tsgonest/types';

export interface CreateUserDto {
  name: string & Trim & Min<1> & Max<255>;
  email: string & Email;
  age: number & Min<0> & Max<150>;
  website?: string & Pattern<"^https?:\\/\\/">;
}

import { Email } from '@tsgonest/types';

export interface MixedDto {
  /** @minLength 1 */
  name: string;
  email: string & Email; // branded type
}

import { Email, Uuid, IPv4, DateTime, Jwt } from '@tsgonest/types';

export interface UserSessionDto {
  userId: string & Uuid;
  email: string & Email;
  ipAddress: string & IPv4;
  loginAt: string & DateTime;
  token: string & Jwt;
}

import { Trim, ToLowerCase, Min, Email } from '@tsgonest/types';

export interface SignupDto {
  // "  John  " -> "John", then validate minLength >= 1
  name: string & Trim & Min<1>;

  // "User@Example.COM" -> "user@example.com", then validate email format
  email: string & ToLowerCase & Email;
}

import { Coerce, Min, Max } from '@tsgonest/types';

export interface PaginationQuery {
  page: number & Coerce & Min<1>;     // "3" -> 3
  limit: number & Coerce & Max<100>;  // "50" -> 50
  active: boolean & Coerce;           // "true" -> true
}

import { Default } from '@tsgonest/types';

export interface PreferencesDto {
  theme?: string & Default<"light">;
  pageSize?: number & Default<20>;
  notifications?: boolean & Default<true>;
}

export interface PreferencesDto {
  /** @default "light" */
  theme?: string;

  /** @default 20 */
  pageSize?: number;
}

import { Min, Max, Format, Pattern } from '@tsgonest/types';

export interface StrictDto {
  age: number & Min<{ value: 0, error: "Age cannot be negative" }>
              & Max<{ value: 150, error: "Age must be realistic" }>;

  email: string & Format<{ type: "email", error: "Must be a valid email address" }>;

  slug: string & Pattern<{ value: "^[a-z0-9-]+$", error: "Slug must be lowercase alphanumeric with hyphens" }>;
}

import { Email, Error } from '@tsgonest/types';

export interface ContactDto {
  email: string & Email & Error<"Invalid email address">;
}

export function isValidCard(value: string): boolean {
  // Luhn algorithm implementation
  let sum = 0;
  let isEven = false;
  for (let i = value.length - 1; i >= 0; i--) {
    let digit = parseInt(value[i], 10);
    if (isEven) {
      digit *= 2;
      if (digit > 9) digit -= 9;
    }
    sum += digit;
    isEven = !isEven;
  }
  return sum % 10 === 0;
}

import { Validate } from '@tsgonest/types';
import { isValidCard } from '../validators/credit-card';

export interface PaymentDto {
  cardNumber: string & Validate<typeof isValidCard>;
}

export interface PaymentDto {
  cardNumber: string & Validate<{
    fn: typeof isValidCard,
    error: "Invalid credit card number"
  }>;
}

import { Min, Max, Email } from '@tsgonest/types';

export interface AddressDto {
  street: string & Min<1>;
  city: string & Min<1>;
  zipCode: string & Pattern<"^\\d{5}$">;
}

export interface CreateUserDto {
  name: string & Min<1> & Max<255>;
  email: string & Email;
  address: AddressDto; // nested validation is generated automatically
}

export interface UpdateUserDto {
  name?: string & Min<1> & Max<255>;
  email?: string & Email;
  age?: number & Min<0>;
}

import { MinItems, MaxItems, Unique, Min, Email } from '@tsgonest/types';

export interface BulkInviteDto {
  emails: (string & Email)[] & MinItems<1> & MaxItems<100> & Unique;
}

export interface OrderDto {
  items: OrderItemDto[] & MinItems<1>;
}

export interface OrderItemDto {
  productId: string;
  quantity: number & Min<1>;
}

// Simple union
export interface FlexibleDto {
  value: string | number;
}

// Discriminated union — optimized with switch statement
export interface CatDto {
  type: 'cat';
  meows: boolean;
}

export interface DogDto {
  type: 'dog';
  barks: boolean;
}

export type PetDto = CatDto | DogDto;

export enum Role {
  Admin = 'admin',
  User = 'user',
  Guest = 'guest',
}

export interface CreateUserDto {
  name: string;
  role: Role;
}

export interface CoordinateDto {
  position: [number, number]; // [latitude, longitude]
}

import { schemaCreateUserDto } from '../dist/user.dto.CreateUserDto.tsgonest';

// Works with any Standard Schema consumer
const schema = schemaCreateUserDto();

// schema.~standard.validate(input)
// schema.~standard.vendor = "tsgonest"
// schema.~standard.version = 1

/**
 * @tsgonest-ignore
 */
export interface InternalDto {
  secret: string;
}

{
  "transforms": {
    "exclude": ["LegacyDto", "Internal*", "*Response"]
  }
}