Function

class Username extends TinyTypeOf<string>() {}

class Age extends TinyTypeOf<number>() {}

import { and, ensure, isDefined, isGreaterThan, isInteger, TinyType } from 'tiny-types';

class AgeInYears extends TinyType {
    constructor(public readonly value: number) {
        ensure('AgeInYears', value, and(isDefined(), isInteger(), isGreaterThan(18));
    }
}

import { endsWith, ensure, TinyType } from 'tiny-types';

class TextFileName extends TinyType {
    constructor(public readonly value: string) {
        super();

        ensure('TextFileName', value, endsWith('.txt'));
    }
}

import { ensure, isDefined } from 'tiny-types'

const username = 'jan-molak'
ensure('Username', username, isDefined());

import { TinyType, ensure, isDefined, isInteger, isInRange } from 'tiny-types'

class Age extends TinyType {
  constructor(public readonly value: number) {
    ensure('Age', value, isDefined(), isInteger(), isInRange(0, 125));
  }
}

import { ensure, hasLengthOf, TinyType } from 'tiny-types';

class Tuple extends TinyType {
  constructor(public readonly values: any[]) {
     super();
     ensure('Tuple', values, hasLengthOf(2));
  }
}

import { ensure, hasLengthOf, TinyType } from 'tiny-types';

class Username extends TinyType {
  constructor(public readonly value: string) {
     super();
     ensure('Username', value, hasLengthOf(8));
  }
}

import { ensure, isArray, TinyType, TinyTypeOf } from 'tiny-types';

class Name extends TinyTypeOf<string>() {}

class Names extends TinyType {
  constructor(public readonly values: Name[]) {
     super();
     ensure('Names', values, isArray());
  }
}

import { ensure, isBoolean, TinyType } from 'tiny-types';

class MarketingOptIn extends TinyType {
    constructor(public readonly value: boolean) {
        ensure('MarketingOptIn', value, isBoolean());
    }
}

import { ensure, isDefined, TinyType } from 'tiny-types';

class Name extends TinyType {
    constructor(public readonly value: string) {
      ensure('Name', value, isDefined());
    }
}

import { ensure, isEqualTo, TinyType, TinyTypeOf } from 'tiny-types';

class AccountId         extends TinyTypeOf<number>() {}
class Command           extends TinyTypeOf<AccountId>() {}
class UpgradeAccount    extends Command {}

class AccountsService {
    constructor(public readonly loggedInUser: AccountId) {}
    handle(command: Command) {
        ensure('AccountId', command.value, isEqualTo(this.loggedInUser));
    }
 }

import { ensure, isEqualTo, TinyType } from 'tiny-types';

class Admin extends TinyType {
    constructor(public readonly id: number) {
        ensure('Admin::id', id, isEqualTo(1));
    }
}

import { ensure, isFunction, TinyType } from 'tiny-types';

function myFunction(callback: (error?: Error) => void): void {
    ensure('callback', callback, isFunction());
}

import { ensure, isGreaterThan, TinyType } from 'tiny-types';

class AgeInYears extends TinyType {
    constructor(public readonly value: number) {
        ensure('Age in years', value, isGreaterThan(0));
    }
}

import { ensure, isGreaterThanOrEqualTo, TinyType } from 'tiny-types';

class AgeInYears extends TinyType {
    constructor(public readonly value: number) {
        ensure('Age in years', value, isGreaterThanOrEqualTo(18));
    }
}

import { ensure, isInRange, TinyType } from 'tiny-types';

class InvestmentLengthInYears extends TinyType {
    constructor(public readonly value: number) {
        super();
        ensure('InvestmentLengthInYears', value, isInRange(1, 5));
    }
}

import { ensure, isInstanceOf, TinyType } from 'tiny-types';

class Birthday extends TinyType {
    constructor(public readonly value: Date) {
        ensure('Date', value, isInstanceOf(Date));
    }
}

import { ensure, isInteger, TinyType } from 'tiny-types';

class AgeInYears extends TinyType {
    constructor(public readonly value: number) {
        ensure('Age in years', value, isInteger());
    }
}

import { ensure, isLessThan, TinyType } from 'tiny-types';

class InvestmentPeriodInYears extends TinyType {
    constructor(public readonly value: number) {
        ensure('Investment period in years', value, isLessThan(50));
    }
}

import { ensure, isLessThanOrEqualTo, TinyType } from 'tiny-types';

class InvestmentPeriod extends TinyType {
    constructor(public readonly value: number) {
        ensure('InvestmentPeriod', value, isLessThanOrEqualTo(50));
    }
}

import { ensure, isString, TinyType } from 'tiny-types';

class FirstName extends TinyType {
    constructor(public readonly value: string) {
        ensure('FirstName', value, isNotBlank());
    }
}

import { ensure, isNumber, TinyType } from 'tiny-types';

class Percentage extends TinyType {
    constructor(public readonly value: number) {
        ensure('Percentage', value, isNumber());
    }
}

import { ensure, isOneOf, TinyType } from 'tiny-types';

class StreetLight extends TinyType {
    constructor(public readonly value: string) {
        super();

        ensure('StreetLight', value, isOneOf('red', 'yellow', 'green'));
    }
}

 import { ensure, isPlainObject } from 'tiny-types';

 ensure('plain object', {}, isPlainObject());

import { ensure, isString, TinyType } from 'tiny-types';

class FirstName extends TinyType {
    constructor(public readonly value: string) {
        ensure('FirstName', value, isString());
    }
}

import { ensure, matches, TinyType } from 'tiny-types';


class CompanyEmailAddress extends TinyType {
    constructor(public readonly value: string) {
        super();
        ensure('EmailAddress', value, matches(/[a-z]+\.[a-z]+@example\.org/));
    }
}

import { ensure, isEqualTo, isGreaterThan, isLessThan, or } from 'tiny-type'l

class Percentage extends TinyType {
    constructor(public readonly value: number) {
        ensure('Percentage', value, or(isEqualTo(0), isGreaterThan(0)), or(isLessThan(100), isEqualTo(100));
    }
}

import { ensure, isGreaterThan, property, TinyType } from 'tiny-types';

class Name extends TinyType {
    constructor(public readonly value: string) {
        super();
        ensure('Name', value, property('length', isGreaterThan(3)));
    }
}

import { ensure, startsWith, TinyType } from 'tiny-types';

class Username extends TinyType {
    constructor(public readonly value: string) {
        super();

        ensure('Username', value, startsWith('usr'));
    }
}