sequelize.d.ts

example.ts

/// <reference path="./sequelize.d.ts" />

// ƪ(•̃͡ε•̃͡)∫ʃ”
import _ = require('sequelize');
var Sequelize = require('sequelize');

// connect to mysql
var sequelize = new Sequelize(
  'db_name',
  'username',
  'password',
  {
        host: '127.0.0.1',
        port: 3306,
        dialect: 'mysql',
        dialectOptions: {
            socketPath: '/tmp/mysql.sock'
        }
    }
);

var ModelName = sequelize.define(
  'ModelName',
  {
    title:Sequelize.STRING,
    desc:Sequelize.STRING
  }
);

ModelName.findOrCreate({
  title:'sushi',
  desc:'maguro salmon kappa!!!'
}).success(function(result){
  console.log(result);
}).error(function(error){
  console.log(error);
});

sequelize.d.ts

// Type definitions for sequelize.js 1.7.0
// Project: http://sequelizejs.com/
// Definitions by: Yoshihiro Misawa <https://github.com/PyYoshi/>
// URL: https://gist.github.com/PyYoshi/9970498

declare module 'sequelize' {}

interface SequelizeDatabaseOptions {
    host?:string;
    port?:number;
    protocol?:any;
    logging?:any;
    maxConcurrentQueries?:number;
    dialect?:string;
    storage?:string;
    omitNull?:boolean;
    native?:boolean;
    define?: {
        engine?:string;
        underscored?:boolean;
        freezeTableName?:boolean;
        syncOnAssociation?:boolean;
        charset?:string;
        collate?:string;
        classMethods?:any;
        instanceMethods?:any;
        timestamps?:boolean;
    };
    sync?: {
        force?:boolean;
    };
    syncOnAssociation?:boolean;
    pool?: {
        maxConnections?:number;
        maxIdleTime?:number;
    };
    language?:string;
    engine?:string;
}

interface SequelizeTableOptions {
    engine?:string;
    timestamps?:boolean;
    createdAt?:boolean;
    updatedAt?:boolean;
    paranoid?:boolean;
    deletedAt?:boolean;
    underscored?:boolean;
    freezeTableName?:boolean;
    tableName?:string;
}

// read sequelize/lib/emitters/custom-event-emitter.js
interface SequelizeEmitters {

    // success
    // cb(obj?:any)
    success(cb:Function):SequelizeEmitters;
    ok(cb:Function):SequelizeEmitters;

    // error
    // cb(err?:Error)
    error(cb:Function):SequelizeEmitters;
    failure(cb:Function):SequelizeEmitters;
    fail(cb:Function):SequelizeEmitters;

    // done
    // cb(err?:Error)
    done(cb:Function):SequelizeEmitters;
    complete(cb:Function):SequelizeEmitters;

}

interface SequelizeResult {
    save():SequelizeEmitters;
    update(...args:any[]):SequelizeEmitters;
    updateAttributes(data:any,opts?:any):SequelizeEmitters;
    destroy(...args:any[]):SequelizeEmitters;
    reload():SequelizeEmitters;
    decrement(obj:any):SequelizeEmitters;
}

interface SequelizeModel {
    build(obj:any):SequelizeResult;
    create(obj:any, opts?:any):SequelizeEmitters;
    bulkCreate(obj:any[]):SequelizeEmitters
    find(id:number):SequelizeEmitters;
    find(opts?:any, qopts?:any):SequelizeEmitters;
    findAll(opts?:any, qopts?:any):SequelizeEmitters;
    findOrCreate(where:any, defaults:any, opt?:any):SequelizeEmitters;
    findAndCountAll(opts:any):SequelizeEmitters;
    sync(options?:{force?:boolean}):SequelizeEmitters;
    drop():SequelizeEmitters;
    count():SequelizeEmitters;
    max(attr:string):SequelizeEmitters;
    min(attr:string):SequelizeEmitters;
    belongsTo(model:SequelizeModel);
    hasOne(model:SequelizeModel, opts?:any);
    hasMany(model:SequelizeModel, opts?:any);
    update(obj:any, where:any, opts?:any):SequelizeEmitters;
}

interface SequelizeDataTypes {
    STRING:any;
    TEXT:any;
    INTEGER:any;
    BIGINT:any;
    FLOAT:any;
    DECIMAL:any;
    DATE:any;
    BOOLEAN:any;
    BLOB:any;
    UUID:any;
}

interface SequelizeTransaction {
    commit():SequelizeEmitters;
    rollback():SequelizeEmitters;
}

interface SequelizeDao {
    dataValues:any;
    _previousDataValues:any;
    __options:any;
    options:any;
    hasPrimaryKeys:boolean;
    selectedValues:any;
    __eagerlyLoadedAssociations:any;
    isNewRecord:boolean;
}

declare class Sequelize{
    static STRING:any;
    static TEXT:any;
    static INTEGER:any;
    static BIGINT:any;
    static FLOAT:any;
    static DECIMAL:any;
    static DATE:any;
    static BOOLEAN:any;
    static BLOB:any;
    static UUID:any;

    constructor(database:string, username:string, password:string, options?: SequelizeDatabaseOptions);

    import(path:string, cb?:(sequelize:Sequelize, DataTypes:SequelizeDataTypes)=>void);
    define(model_name:string, model:any, opts?:SequelizeTableOptions):SequelizeModel;
    query(query:string, calee?:any, options?:any, replacements?:any):SequelizeEmitters;
    transaction(cb:(t:SequelizeTransaction)=>void);
}