GeezerVison

interface Foo {
  a: 0
  b: 1
}
var x: "a" | "b";
var y: Foo;
var z = y[x]; // Is this Foo["a" | "b"] or 0 | 1 (rather than relying on a nonexistant index signature for the type or being any)?

interface Foo { a: 0, b: 1 }

function f1(foo: Foo, x: "a" | "b") {
    const c = foo[x];  // Ok, type 0 | 1
    foo[x] = c;  // Error, absent index signatures an index expresion must be of a unit type
}

function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]) {
    obj[key] = value;
}

function f2(foo: Foo, x: "a" | "b") {
    const c = foo[x];  // Ok, type 0 | 1
    setProperty(foo, x, c);  // Ok
}

type A<T extends {[K in "test"]: any}> = T["test"]
type B<T extends {test: any}> = T["test"]
type C<T extends {test: any}, K extends keyof T> = T[K]

type A1 = A<{test: number}>
type B1 = B<{test: number}>
type C1 = C<{test: number}, "test">

type IOnChangesObject<T> = {[P in keyof T]: ng.IChangesObject<T[P]>}

$onChanges(changesObj: IOnChangesObject<Ctrl>) { 
//both private and public attributes should work on changesObj
}

type Foo<T> = T & {
    Test: () => void;
}
type Foo1<T> = keyof Foo<T>;

type Foo2 = Foo1<{ prop: string }>;

const thing = {
  a: 'foo',
  b: 'bar',
};

// Expected: "a" | "b"
// Actual: Cannot find name 'thing'
type thingKey = keyof thing;

type thingKey = keyof typeof thing;

//////////////////////////////////  USAGE /////////////////////////////////

var sequelize = new Sequelize();
var Users = sequelize.define("users", {
    firstName: STRING,
    lastName: CHAR(123),
    age: INTEGER,
    visits: { type: INTEGER, length: 4}
});

var u = Users.create({age: 22}); // only valid fields/types allowed 
u.firstName = "John"; // types are checked at compile time
u.lastName = "Doe"
u.visits = 123;


///////////////////////////////// DECLARATIONS /////////////////////////////


interface ABSTRACT_STATIC<T> {
    prototype: ABSTRACT<string, T>;
}
interface ABSTRACT_BASE<T> {
    stringify(value: T, options): string;
    validate(value: T);
}

interface ABSTRACT<Key, T> extends ABSTRACT_BASE<T> { 
    key: Key;
    dialectTypes: string;
    toSql: string;
    warn(link: string, text);
}

interface STRING_OPTIONS { length?: number, binary?: boolean }
interface STRING<Key> extends ABSTRACT<Key, string> {
    readonly BINARY: this
}
interface STRING_STATIC<Key, T extends STRING<Key>> extends ABSTRACT_STATIC<string> {
    new(length?: number, binary?: boolean): T;
    new(options: STRING_OPTIONS): T;
    (length?: number, binary?: boolean): T;
    (options: STRING_OPTIONS): T;
}
declare const STRING: STRING_STATIC<"STRING", STRING<"STRING">>;

interface CHAR extends STRING<"CHAR"> {}
interface CHAR_STATIC extends STRING_STATIC<"CHAR", CHAR> {}
declare const CHAR: CHAR_STATIC;

interface NUMBER_OPTIONS {
    length?: number,
    zerofill?: boolean,
    decimals?: number,
    precision?: number,
    scale?: number,
    unsigned?: boolean
}
interface NUMBER<Key> extends ABSTRACT<Key, number> {
    readonly UNSIGNED: this
    readonly ZEROFILL: this
}
interface NUMBER_STATIC<Key, T extends NUMBER<Key>> extends ABSTRACT_STATIC<number> {
    new(options: NUMBER_OPTIONS): T;
    (options: NUMBER_OPTIONS): T;
}
declare const NUMBER: NUMBER_STATIC<"NUMBER", NUMBER<"NUMBER">>;

interface INTEGER extends NUMBER<"INTEGER"> {}
interface INTEGER_STATIC extends NUMBER_STATIC<"INTEGER", INTEGER> {
    new(): INTEGER;
    (): INTEGER;
    new(length: number): INTEGER;
    (length: number): INTEGER;
}
declare const INTEGER: INTEGER_STATIC;
interface OPTIONS<T> { type: ABSTRACT_STATIC<T> }

interface STRING_OPTIONS_TYPE extends OPTIONS<string>, STRING_OPTIONS { }
interface NUMBER_OPTIONS_TYPE extends OPTIONS<number>, NUMBER_OPTIONS { }

type FIELD<T> = ABSTRACT_STATIC<T>
    | OPTIONS<T> & (
        STRING_OPTIONS_TYPE |
        NUMBER_OPTIONS_TYPE
        )
    | ABSTRACT_BASE<T> 

type INIT<T> = {[P in keyof T]?:T[P]}

declare class Factory<T> {
    create(initial?: INIT<T>): T
}

declare class Sequelize {
    define<T>(tableName: string, fields: {[P in keyof T]: FIELD<T[P]>}):Factory<T> 
}