declare module 'thatdevthing/ProjectType' {
	 enum ProjectType {
	    LIBRARY = 0,
	    CLIENT = 1,
	    SERVER = 2,
	    COMPLETE = 3,
	}
	export = ProjectType;

}
declare module 'thatdevthing/api/APIError' {
	 class APIError extends Error {
	    name: string;
	    message: string;
	    status: number;
	    statusCode: number;
	    constructor(name: string, message: string, status?: number);
	}
	export = APIError;

}
declare module 'thatdevthing/security/IPermission' {
	interface IPermission {
	    code: number;
	}
	export = IPermission;

}
declare module 'thatdevthing/security/IUser' {
	import IPermission = require('thatdevthing/security/IPermission');
	interface IUser {
	    /**
	     * // TODO Need to learn and understand OAUTH2
	     */
	    permissions: IPermission[];
	}
	export = IUser;

}
declare module 'thatdevthing/security/IContext' {
	import IUser = require('thatdevthing/security/IUser');
	interface IContext {
	    user?: IUser;
	}
	export = IContext;

}
declare module 'thatdevthing/api/IRequest' {
	import IContext = require('thatdevthing/security/IContext');
	interface IRequest {
	    context: IContext;
	    body: any;
	    params: any;
	    query: any;
	}
	export = IRequest;

}
declare module 'thatdevthing/api/IResponse' {
	interface IResponse {
	    status(status: number): IResponse;
	    sendStatus(status: number): any;
	    json(json: any): any;
	}
	export = IResponse;

}
declare module 'thatdevthing/jsonschema/IJsonSchema' {
	interface IJsonSchema {
	    name?: string;
	    title?: string;
	    description?: string;
	    type: string;
	    format?: string;
	    required?: boolean | string[];
	    minimum?: number;
	    maximum?: number;
	    maxLength?: number;
	    minLength?: number;
	    maxItems?: number;
	    minItems?: number;
	    maxProperties?: number;
	    minProperties?: number;
	    pattern?: string;
	    items?: IJsonSchema;
	    properties?: {
	        [propName: string]: IJsonSchema;
	    };
	}
	export = IJsonSchema;

}
declare module 'thatdevthing/api/IResponseDefinition' {
	import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema');
	interface IResponseDefinition {
	    code: number;
	    description: string;
	    schema?: IJsonSchema;
	}
	export = IResponseDefinition;

}
declare module 'thatdevthing/async/IAsync' {
	export interface Promise<T> {
	    then(resolve: (value: T) => any, reject?: (error: Error) => any, notify?: (status: string) => any): Promise<T>;
	    catch(callback: (error: Error) => any): Promise<T>;
	    progress(callback: (status: string) => any): Promise<T>;
	}
	export interface PromiseList<T> {
	    add(promise: Promise<T>): PromiseList<T>;
	    then(resolve: (value: T[]) => any, reject?: (error: Error) => any, notify?: (status: string) => any): PromiseList<T>;
	    catch(reject: (error: Error) => any): PromiseList<T>;
	    progress(notify: (status: string) => any): PromiseList<T>;
	}
	export interface Deferred<T> {
	    resolve(value?: T): void;
	    reject(error: Error): void;
	    progress(status: string): void;
	}

}
declare module 'thatdevthing/api/IService' {
	import IResponseDefinition = require('thatdevthing/api/IResponseDefinition');
	import IRequest = require('thatdevthing/api/IRequest');
	import IResponse = require('thatdevthing/api/IResponse');
	import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema');
	import IAsync = require('thatdevthing/async/IAsync');
	interface IService {
	    uri: string;
	    httpMethod: string;
	    operationId: string;
	    tags?: string[];
	    responses: IResponseDefinition[];
	    pathParameters?: IJsonSchema[];
	    queryParameters?: IJsonSchema[];
	    body?: IJsonSchema;
	    deprecated?: boolean;
	    process(req: IRequest, res: IResponse): IAsync.Promise<void>;
	}
	export = IService;

}
declare module 'thatdevthing/api' {
	export import APIError = require('thatdevthing/api/APIError');
	export import IRequest = require('thatdevthing/api/IRequest');
	export import IResponse = require('thatdevthing/api/IResponse');
	export import IResponseDefinition = require('thatdevthing/api/IResponseDefinition');
	export import IService = require('thatdevthing/api/IService');

}
declare module 'thatdevthing/log/ILog' {
	interface ILog {
	    delegate(log: ILog): any;
	    undelegate(): any;
	    info(title: string, detail?: string, code?: number): any;
	    warn(title: string, detail?: string, code?: number): any;
	    error(err: Error): any;
	}
	export = ILog;

}
declare module 'thatdevthing/log/log' {
	import ILog = require('thatdevthing/log/ILog'); var log: ILog;
	export = log;

}
declare module 'thatdevthing/async/QAsync' {
	import IAsync = require('thatdevthing/async/IAsync');
	import q = require('q');
	/**
	 * An implementation of our Promise Interface based on the Q library
	 */
	export class Promise<T> implements IAsync.Promise<T> {
	    private _deferred;
	    constructor(main: (deferred: IAsync.Deferred<T>, handler?: (error: Error) => any) => void);
	    then(resolve: (value: T) => any, reject?: (error: Error) => any, notify?: (status: string) => any): IAsync.Promise<T>;
	    catch(reject: (error: Error) => any): IAsync.Promise<T>;
	    progress(notify: (status: string) => any): IAsync.Promise<T>;
	}
	/**
	 * An implementation of our PromiseList Interface based on the Q library
	 */
	export class PromiseList<T> implements IAsync.PromiseList<T> {
	    private promises;
	    add(promise: IAsync.Promise<T>): IAsync.PromiseList<T>;
	    then(resolve: (value: T[]) => any, reject?: (error: Error) => any, notify?: (status: string) => any): IAsync.PromiseList<T>;
	    catch(reject: (error: Error) => any): IAsync.PromiseList<T>;
	    progress(notify: (status: string) => any): IAsync.PromiseList<T>;
	}
	/**
	 * An implementation of our PromiseList Interface based on the Q library
	 */
	export class Deferred<T> implements IAsync.Deferred<T> {
	    private _deferred;
	    constructor(deferred: q.Deferred<T>);
	    resolve(value?: T): void;
	    reject(error: Error): void;
	    progress(status: string): void;
	}

}
declare module 'thatdevthing/async' {
	export import IAsync = require('thatdevthing/async/IAsync');
	export import QAsync = require('thatdevthing/async/QAsync');

}
declare module 'thatdevthing/auto/IAutoOptions' {
	import ProjectType = require('thatdevthing/ProjectType');
	interface IAutoOptions {
	    rootDir: string;
	    srcDir: string;
	    releaseDir: string;
	    analysisDir: string;
	    testDir: string;
	    libDir: string;
	    nodeDir: string;
	    resourceDirs: string[];
	    projectType: ProjectType;
	    polymerPackages: string[];
	    services?: any;
	    publishTo?: string;
	}
	export = IAutoOptions;

}
declare module 'thatdevthing/fileio/IFileIO' {
	import IAsync = require('thatdevthing/Async/IAsync');
	interface IFileIO {
	    forEachFile(folderPaths: (string[] | string), fileType: string, recursive: boolean, callback: (fileName: string, filePath: string) => any): IFileIO;
	    forEachSubFolder(folderPaths: (string[] | string), recursive: boolean, callback: (subFolderName: string, subFolderPath) => any): IFileIO;
	    readFileAsString(filePath: string): IAsync.Promise<string>;
	    readFileAsJson(filePath: string): IAsync.Promise<any>;
	    writeStringAsFile(value: string, filePath: string): IAsync.Promise<void>;
	    writeJsonAsFile(value: any, filePath: string): IAsync.Promise<void>;
	    createFolderPath(folderPath: string): IAsync.Promise<void>;
	    deleteFile(filePath: string): IAsync.Promise<void>;
	    deleteFolder(filePath: string): IAsync.Promise<void>;
	    emptyFolder(folderPath: string): IAsync.Promise<void>;
	    existsFile(filePath: string): boolean;
	    existsFolder(filePath: string): boolean;
	    copyEachFile(srcPaths: (string[] | string), destPath: string, fileType: string, recursive: boolean): IAsync.Promise<void>;
	    copyFiles(filePaths: (string[] | string), destPath: string): IAsync.Promise<void>;
	    copyFile(source: string, target: string): IAsync.Promise<void>;
	}
	export = IFileIO;

}
declare module 'thatdevthing/fileio/NodeFileIO' {
	import QAsync = require('thatdevthing/Async/QAsync');
	import IFileIO = require('thatdevthing/fileio/IFileIO'); class NodeFileIO implements IFileIO {
	    forEachFile(folderPaths: (string | string[]), fileType: string, recursive: boolean, callback: (fileName: string, filePath: string) => any): IFileIO;
	    forEachSubFolder(folderPaths: (string | string[]), recursive: boolean, callback: (subFolderName: string, subFolderPath: string) => any): IFileIO;
	    readFileAsString(filePath: string): QAsync.Promise<string>;
	    readFileAsJson(filePath: string): QAsync.Promise<any>;
	    createFolderPath(folderPath: string): QAsync.Promise<void>;
	    writeStringAsFile(value: string, filePath: string): QAsync.Promise<void>;
	    writeJsonAsFile(value: any, filePath: string): QAsync.Promise<void>;
	    existsFile(filePath: string): boolean;
	    existsFolder(filePath: string): boolean;
	    copyEachFile(srcPaths: (string[] | string), destPath: string, fileType: string, recursive: boolean): QAsync.Promise<void>;
	    copyFiles(filePaths: (string[] | string), destPath: string): QAsync.Promise<void>;
	    copyFile(source: string, target: string): QAsync.Promise<void>;
	    emptyFolder(folderPath: string): QAsync.Promise<void>;
	    deleteFolder(folderPath: string): QAsync.Promise<void>;
	    deleteFile(filePath: string): QAsync.Promise<void>;
	}
	export = NodeFileIO;

}
declare module 'thatdevthing/auto/analyse/Reflection' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); class Reflection {
	    name: string;
	    packagePath: string;
	    sourcePath: string;
	    lineNumber: number;
	    type: string;
	    flags: any;
	    children: Reflection[];
	    static ReflectionTypes: {
	        PROJECT: string;
	        PACKAGE: string;
	        POLYMERPACKAGE: string;
	        POLYMERMODULE: string;
	        POLYMERCOMPONENT: string;
	        RESOURCEPACKAGE: string;
	        MODULE: string;
	        CLASS: string;
	        INTERFACE: string;
	        METHOD: string;
	        PROPERTY: string;
	        FUNCTION: string;
	        CONSTRUCTOR: string;
	        ENUMERATION: string;
	        ENUMERATION_MEMBER: string;
	        PARAMETER: string;
	        VARIABLE: string;
	        OBJECTLITERAL: string;
	        ACCESSOR: string;
	        UNKNOWN: string;
	    };
	    static generateProjectReflection(o: IAutoOptions): QAsync.Promise<Reflection>;
	}
	export = Reflection;

}
declare module 'thatdevthing/auto/analyse' {
	export import Reflection = require('thatdevthing/auto/analyse/Reflection');

}
declare module 'thatdevthing/auto/build/processJSRequires' {
	import QAsync = require('thatdevthing/async/QAsync'); function processJSRequires(folderPath: string, packageName: string): QAsync.Promise<void>;
	export = processJSRequires;

}
declare module 'thatdevthing/auto/build/compressClientApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function compressClientApp(o: IAutoOptions): QAsync.Promise<void>;
	export = compressClientApp;

}
declare module 'thatdevthing/auto/build/buildClientApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function buildClientApp(o: IAutoOptions): QAsync.Promise<void>;
	export = buildClientApp;

}
declare module 'thatdevthing/auto/build/buildCompleteApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function buildClientApp(o: IAutoOptions): QAsync.Promise<void>;
	export = buildClientApp;

}
declare module 'thatdevthing/auto/build/buildDTSFile' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function buildDTSFile(o: IAutoOptions): QAsync.Promise<void>;
	export = buildDTSFile;

}
declare module 'thatdevthing/auto/build/buildLibrary' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function buildLibrary(o: IAutoOptions): QAsync.Promise<void>;
	export = buildLibrary;

}
declare module 'thatdevthing/auto/build/buildServerApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function buildServerApp(o: IAutoOptions): QAsync.Promise<void>;
	export = buildServerApp;

}
declare module 'thatdevthing/auto/build/buildSwaggerJson' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function buildSwaggerJson(o: IAutoOptions): QAsync.Promise<void>;
	export = buildSwaggerJson;

}
declare module 'thatdevthing/auto/build/processAll' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function processAll(o: IAutoOptions): QAsync.Promise<void>;
	export = processAll;

}
declare module 'thatdevthing/auto/build' {
	export import buildClientApp = require('thatdevthing/auto/build/buildClientApp');
	export import buildCompleteApp = require('thatdevthing/auto/build/buildCompleteApp');
	export import buildDTSFile = require('thatdevthing/auto/build/buildDTSFile');
	export import buildLibrary = require('thatdevthing/auto/build/buildLibrary');
	export import buildServerApp = require('thatdevthing/auto/build/buildServerApp');
	export import buildSwaggerJson = require('thatdevthing/auto/build/buildSwaggerJson');
	export import compressClientApp = require('thatdevthing/auto/build/compressClientApp');
	export import processAll = require('thatdevthing/auto/build/processAll');
	export import processJSRequires = require('thatdevthing/auto/build/processJSRequires');

}
declare module 'thatdevthing/auto/code/removeAutoGeneratedFiles' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function removeAutoGeneratedFiles(o: IAutoOptions): QAsync.Promise<void>;
	export = removeAutoGeneratedFiles;

}
declare module 'thatdevthing/auto/code/createTSConfig' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function createTSConfig(o: IAutoOptions): QAsync.Promise<void>;
	export = createTSConfig;

}
declare module 'thatdevthing/auto/code/createPackageFiles' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function createPackageFiles(o: IAutoOptions): QAsync.Promise<void>;
	export = createPackageFiles;

}
declare module 'thatdevthing/auto/code/createTestFiles' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function createTestFiles(o: IAutoOptions): QAsync.Promise<void>;
	export = createTestFiles;

}
declare module 'thatdevthing/auto/code/codeClientApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function codeClientApp(o: IAutoOptions): QAsync.Promise<void>;
	export = codeClientApp;

}
declare module 'thatdevthing/auto/code/codeCompleteApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function codeCompleteApp(o: IAutoOptions): QAsync.Promise<void>;
	export = codeCompleteApp;

}
declare module 'thatdevthing/auto/code/codeLibrary' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function codeLibrary(o: IAutoOptions): QAsync.Promise<void>;
	export = codeLibrary;

}
declare module 'thatdevthing/auto/code/codeServerApp' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function codeServerApp(o: IAutoOptions): QAsync.Promise<void>;
	export = codeServerApp;

}
declare module 'thatdevthing/auto/code/processAll' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function processAll(o: IAutoOptions): QAsync.Promise<void>;
	export = processAll;

}
declare module 'thatdevthing/auto/code' {
	export import codeClientApp = require('thatdevthing/auto/code/codeClientApp');
	export import codeCompleteApp = require('thatdevthing/auto/code/codeCompleteApp');
	export import codeLibrary = require('thatdevthing/auto/code/codeLibrary');
	export import codeServerApp = require('thatdevthing/auto/code/codeServerApp');
	export import createPackageFiles = require('thatdevthing/auto/code/createPackageFiles');
	export import createTSConfig = require('thatdevthing/auto/code/createTSConfig');
	export import createTestFiles = require('thatdevthing/auto/code/createTestFiles');
	export import processAll = require('thatdevthing/auto/code/processAll');
	export import removeAutoGeneratedFiles = require('thatdevthing/auto/code/removeAutoGeneratedFiles');

}
declare module 'thatdevthing/auto/install/processAll' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function processAll(o: IAutoOptions): QAsync.Promise<void>;
	export = processAll;

}
declare module 'thatdevthing/auto/install' {
	export import processAll = require('thatdevthing/auto/install/processAll');

}
declare module 'thatdevthing/auto/publish/autoVersion' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function autoVersion(o: IAutoOptions): QAsync.Promise<void>;
	export = autoVersion;

}
declare module 'thatdevthing/auto/publish/publishNPM' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function publishNPM(o: IAutoOptions): QAsync.Promise<void>;
	export = publishNPM;

}
declare module 'thatdevthing/auto/publish/processAll' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function processAll(o: IAutoOptions): QAsync.Promise<void>;
	export = processAll;

}
declare module 'thatdevthing/auto/publish' {
	export import autoVersion = require('thatdevthing/auto/publish/autoVersion');
	export import processAll = require('thatdevthing/auto/publish/processAll');
	export import publishNPM = require('thatdevthing/auto/publish/publishNPM');

}
declare module 'thatdevthing/auto/test/runTests' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function runTests(o: IAutoOptions): QAsync.Promise<void>;
	export = runTests;

}
declare module 'thatdevthing/auto/test/runTestCoverage' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function runTestCoverage(o: IAutoOptions): QAsync.Promise<void>;
	export = runTestCoverage;

}
declare module 'thatdevthing/auto/test/processAll' {
	import QAsync = require('thatdevthing/async/QAsync');
	import IAutoOptions = require('thatdevthing/auto/IAutoOptions'); function processAll(o: IAutoOptions): QAsync.Promise<void>;
	export = processAll;

}
declare module 'thatdevthing/auto/test' {
	export import processAll = require('thatdevthing/auto/test/processAll');
	export import runTestCoverage = require('thatdevthing/auto/test/runTestCoverage');
	export import runTests = require('thatdevthing/auto/test/runTests');

}
declare module 'thatdevthing/auto' {
	export import IAutoOptions = require('thatdevthing/auto/IAutoOptions');
	export import analyse = require('thatdevthing/auto/analyse');
	export import build = require('thatdevthing/auto/build');
	export import code = require('thatdevthing/auto/code');
	export import install = require('thatdevthing/auto/install');
	export import publish = require('thatdevthing/auto/publish');
	export import test = require('thatdevthing/auto/test');

}
declare module 'thatdevthing/components/app-layout/app-layout-standard' {
	 var _default: any;
	export = _default;

}
declare module 'thatdevthing/components/app-menu-item/app-menu-item' {
	 var _default: any;
	export = _default;

}
declare module 'thatdevthing/fileio' {
	export import IFileIO = require('thatdevthing/fileio/IFileIO');
	export import NodeFileIO = require('thatdevthing/fileio/NodeFileIO');

}
declare module 'thatdevthing/jsonschema/Base' {
	import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema'); abstract class Base implements IJsonSchema {
	    name: string;
	    title: string;
	    description: string;
	    type: string;
	    format: string;
	    required: boolean | string[];
	    minimum: number;
	    maximum: number;
	    maxLength: number;
	    minLength: number;
	    maxItems: number;
	    minItems: number;
	    maxProperties: number;
	    minProperties: number;
	    pattern: string;
	    items: IJsonSchema;
	    properties: {
	        [propName: string]: IJsonSchema;
	    };
	    constructor(name?: string);
	}
	export = Base;

}
declare module 'thatdevthing/jsonschema/Array' {
	import Base = require('thatdevthing/jsonschema/Base'); class Array extends Base {
	    type: string;
	    $items(items: Base): Array;
	    $minItems(minItems: number): Array;
	    $maxItems(maxItems: number): Array;
	    $description(description: string): Array;
	    $required(): Array;
	}
	export = Array;

}
declare module 'thatdevthing/jsonschema/Boolean' {
	import Base = require('thatdevthing/jsonschema/Base'); class Boolean extends Base {
	    type: string;
	    $description(description: string): Boolean;
	    $required(): Boolean;
	}
	export = Boolean;

}
declare module 'thatdevthing/jsonschema/Date' {
	import Base = require('thatdevthing/jsonschema/Base'); class Date extends Base {
	    type: string;
	    format: string;
	    $description(description: string): Date;
	    $required(): Date;
	}
	export = Date;

}
declare module 'thatdevthing/jsonschema/Double' {
	import Base = require('thatdevthing/jsonschema/Base'); class Double extends Base {
	    type: string;
	    format: string;
	    $minimum(minimum: number): Double;
	    $maximum(maximum: number): Double;
	    $description(description: string): Double;
	    $required(): Double;
	}
	export = Double;

}
declare module 'thatdevthing/jsonschema/Email' {
	import Base = require('thatdevthing/jsonschema/Base'); class Email extends Base {
	    type: string;
	    format: string;
	    $minLength(minLength: number): Email;
	    $maxLength(maxLength: number): Email;
	    $description(description: string): Email;
	    $required(): Email;
	}
	export = Email;

}
declare module 'thatdevthing/jsonschema/Float' {
	import Base = require('thatdevthing/jsonschema/Base'); class Float extends Base {
	    type: string;
	    format: string;
	    $minimum(minimum: number): Float;
	    $maximum(maximum: number): Float;
	    $description(description: string): Float;
	    $required(): Float;
	}
	export = Float;

}
declare module 'thatdevthing/jsonschema/Integer' {
	import Base = require('thatdevthing/jsonschema/Base'); class Integer extends Base {
	    type: string;
	    format: string;
	    $minimum(minimum: number): Integer;
	    $maximum(maximum: number): Integer;
	    $description(description: string): Integer;
	    $required(): Integer;
	}
	export = Integer;

}
declare module 'thatdevthing/jsonschema/Long' {
	import Base = require('thatdevthing/jsonschema/Base'); class Long extends Base {
	    type: string;
	    format: string;
	    $minimum(minimum: number): Long;
	    $maximum(maximum: number): Long;
	    $description(description: string): Long;
	    $required(): Long;
	}
	export = Long;

}
declare module 'thatdevthing/model/IJsonable' {
	interface IJsonable {
	    fromJson(json: any): any;
	    toJson(): any;
	}
	export = IJsonable;

}
declare module 'thatdevthing/model/IModel' {
	import IJsonable = require('thatdevthing/model/IJsonable');
	interface IModel extends IJsonable {
	    key: string;
	}
	export = IModel;

}
declare module 'thatdevthing/model/metadata' {
	import 'reflect-metadata';
	import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema');
	export interface Metadata {
	    name?: string;
	    description?: string;
	    properties: {
	        [propName: string]: IJsonSchema;
	    };
	}
	export function get(target: any): Metadata;
	export function set(metadata: Metadata, target: any): void;

}
declare module 'thatdevthing/jsonschema/Model' {
	import 'reflect-metadata';
	import IModel = require('thatdevthing/model/IModel');
	import IModelConstructor = require('thatdevthing/model/IModelConstructor');
	import Base = require('thatdevthing/jsonschema/Base'); class Model extends Base {
	    type: string;
	    required: string[];
	    constructor(model: IModel | IModelConstructor);
	    $description(description: string): Model;
	}
	export = Model;

}
declare module 'thatdevthing/jsonschema/Object' {
	import Base = require('thatdevthing/jsonschema/Base');
	import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema'); class Object extends Base {
	    type: string;
	    $properties(properties: {
	        [propName: string]: IJsonSchema;
	    }): Object;
	    $required(): Object;
	}
	export = Object;

}
declare module 'thatdevthing/jsonschema/String' {
	import Base = require('thatdevthing/jsonschema/Base'); class String extends Base {
	    type: string;
	    $format(format: string): String;
	    $minLength(minLength: number): String;
	    $maxLength(maxLength: number): String;
	    $pattern(pattern: string): String;
	    $description(description: string): String;
	    $required(): String;
	}
	export = String;

}
declare module 'thatdevthing/jsonschema/builder' {
	import Array = require('thatdevthing/jsonschema/Array');
	import Boolean = require('thatdevthing/jsonschema/Boolean');
	import Date = require('thatdevthing/jsonschema/Date');
	import Email = require('thatdevthing/jsonschema/Email');
	import Float = require('thatdevthing/jsonschema/Float');
	import Double = require('thatdevthing/jsonschema/Double');
	import Integer = require('thatdevthing/jsonschema/Integer');
	import Long = require('thatdevthing/jsonschema/Long');
	import Object = require('thatdevthing/jsonschema/Object');
	import String = require('thatdevthing/jsonschema/String');
	import Model = require('thatdevthing/jsonschema/Model');
	import IModel = require('thatdevthing/model/IModel');
	import IModelConstructor = require('thatdevthing/model/IModelConstructor'); module builder {
	    function array(name?: string): Array;
	    function boolean(name?: string): Boolean;
	    function date(name?: string): Date;
	    function email(name?: string): Email;
	    function float(name?: string): Float;
	    function double(name?: string): Double;
	    function integer(name?: string): Integer;
	    function long(name?: string): Long;
	    function model(model: IModel | IModelConstructor): Model;
	    function object(name?: string): Object;
	    function string(name?: string): String;
	}
	export = builder;

}
declare module 'thatdevthing/jsonschema' {
	export import Array = require('thatdevthing/jsonschema/Array');
	export import Base = require('thatdevthing/jsonschema/Base');
	export import Boolean = require('thatdevthing/jsonschema/Boolean');
	export import Date = require('thatdevthing/jsonschema/Date');
	export import Double = require('thatdevthing/jsonschema/Double');
	export import Email = require('thatdevthing/jsonschema/Email');
	export import Float = require('thatdevthing/jsonschema/Float');
	export import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema');
	export import Integer = require('thatdevthing/jsonschema/Integer');
	export import Long = require('thatdevthing/jsonschema/Long');
	export import Model = require('thatdevthing/jsonschema/Model');
	export import Object = require('thatdevthing/jsonschema/Object');
	export import String = require('thatdevthing/jsonschema/String');
	export import builder = require('thatdevthing/jsonschema/builder');

}
declare module 'thatdevthing/log' {
	export import ILog = require('thatdevthing/log/ILog');
	export import log = require('thatdevthing/log/log');

}
declare module 'thatdevthing/model/Jsonable' {
	import metadata = require('thatdevthing/model/metadata');
	import IJsonable = require('thatdevthing/model/IJsonable'); abstract class Jsonable implements IJsonable {
	    /**
	     * meta
	     * @private
	     */
	    private _meta;
	    meta: metadata.Metadata;
	    /**
	     * fromJson
	     * @param json
	     * @returns {Model}
	     */
	    fromJson(json: any): any;
	    /**
	     * toJson
	     * @returns {any}
	     */
	    toJson(): any;
	}
	export = Jsonable;

}
declare module 'thatdevthing/model/annotations/model' {
	 function model(o: {
	    name?: string;
	    description?: string;
	}): (target: any) => void;
	export = model;

}
declare module 'thatdevthing/model/annotations/property' {
	import IJsonSchema = require('thatdevthing/jsonschema/IJsonSchema'); function property(o: IJsonSchema): (target: any, propertyKey: string) => void;
	export = property;

}
declare module 'thatdevthing/model/annotations/relationship' {
	 function relationship(o: any): (target: any, propertyKey: string) => void;
	export = relationship;

}
declare module 'thatdevthing/model/annotations' {
	export import model = require('thatdevthing/model/annotations/model');
	export import property = require('thatdevthing/model/annotations/property');
	export import relationship = require('thatdevthing/model/annotations/relationship');

}
declare module 'thatdevthing/model/Model' {
	import Jsonable = require('thatdevthing/model/Jsonable');
	import IModel = require('thatdevthing/model/IModel'); abstract class Model extends Jsonable implements IModel {
	    /**
	     * key
	     */
	    key: string;
	}
	export = Model;

}
declare module 'thatdevthing/model/store/IQuery' {
	interface IQuery {
	}
	export = IQuery;

}
declare module 'thatdevthing/model/store/IResultset' {
	import IModel = require('thatdevthing/model/IModel');
	import IAsync = require('thatdevthing/async/IAsync');
	interface IResultset {
	    count(): IAsync.Promise<number>;
	    range(start: number, length: number): IAsync.Promise<IModel[]>;
	}
	export = IResultset;

}
declare module 'thatdevthing/trans/ITransaction' {
	import IAsync = require('thatdevthing/async/IAsync');
	interface ITransaction {
	    catch(callback: (err: Error) => any): any;
	    abort(err: Error): IAsync.Promise<void>;
	    complete(): IAsync.Promise<void>;
	}
	export = ITransaction;

}
declare module 'thatdevthing/model/store/IStore' {
	import IResultset = require('thatdevthing/model/store/IResultset');
	import IQuery = require('thatdevthing/model/store/IQuery');
	import IModel = require('thatdevthing/model/IModel');
	import IModelConstructor = require('thatdevthing/model/IModelConstructor');
	import IAsync = require('thatdevthing/async/IAsync');
	import ITransaction = require('thatdevthing/trans/ITransaction');
	interface IStore {
	    count(transaction: ITransaction, query: IQuery): IAsync.Promise<number>;
	    find(transaction: ITransaction, query: IQuery): IAsync.Promise<IResultset>;
	    findByKey(transaction: ITransaction, model: IModelConstructor, key: string): IAsync.Promise<IModel>;
	    findAllByKey(transaction: ITransaction, model: IModelConstructor, keys: string[]): IAsync.Promise<IModel[]>;
	    put(transaction: ITransaction, item: IModel): IAsync.Promise<IModel>;
	    putAll(transaction: ITransaction, items: IModel[]): IAsync.Promise<IModel[]>;
	    remove(transaction: ITransaction, item: IModel): IAsync.Promise<void>;
	    removeAll(transaction: ITransaction, items: IModel[]): IAsync.Promise<void>;
	}
	export = IStore;

}
declare module 'thatdevthing/model/store/Query' {
	import IModelConstructor = require('thatdevthing/model/IModelConstructor');
	import IQuery = require('thatdevthing/model/store/IQuery'); class Query implements IQuery {
	    model: IModelConstructor;
	    constructor(model: IModelConstructor);
	}
	export = Query;

}
declare module 'thatdevthing/model/store/Resultset' {
	import IModelConstructor = require('thatdevthing/model/IModelConstructor');
	import IModel = require('thatdevthing/model/IModel');
	import QAsync = require('thatdevthing/async/QAsync');
	import IResultset = require('thatdevthing/model/store/IResultset'); class Resultset implements IResultset {
	    model: IModelConstructor;
	    constructor(model: IModelConstructor);
	    count(): QAsync.Promise<number>;
	    range(start: number, length: number): QAsync.Promise<IModel[]>;
	}
	export = Resultset;

}
declare module 'thatdevthing/model/store/errors' {
	export class NotFoundError extends Error {
	}

}
declare module 'thatdevthing/model/store' {
	export import IQuery = require('thatdevthing/model/store/IQuery');
	export import IResultset = require('thatdevthing/model/store/IResultset');
	export import IStore = require('thatdevthing/model/store/IStore');
	export import Query = require('thatdevthing/model/store/Query');
	export import Resultset = require('thatdevthing/model/store/Resultset');
	export import errors = require('thatdevthing/model/store/errors');

}
declare module 'thatdevthing/model/stores/JsonFileStore' {
	import ITransaction = require('thatdevthing/trans/ITransaction');
	import IStore = require('thatdevthing/model/store/IStore');
	import Resultset = require('thatdevthing/model/store/Resultset');
	import Query = require('thatdevthing/model/store/Query');
	import IModelConstructor = require('thatdevthing/model/IModelConstructor');
	import IModel = require('thatdevthing/model/IModel');
	import QAsync = require('thatdevthing/async/QAsync');
	import IFileIO = require('thatdevthing/fileio/IFileIO'); class JsonFileStore implements IStore {
	    private fileIO;
	    private filePath;
	    constructor(fileIO: IFileIO, filePath: string);
	    find(transaction: ITransaction, query: Query): QAsync.Promise<Resultset>;
	    count(transaction: ITransaction, query: Query): QAsync.Promise<number>;
	    findByKey(transaction: ITransaction, model: IModelConstructor, key: string): QAsync.Promise<IModel>;
	    findAllByKey(transaction: ITransaction, model: IModelConstructor, keys: string[]): QAsync.Promise<IModel[]>;
	    put(transaction: ITransaction, item: IModel): QAsync.Promise<IModel>;
	    putAll(transaction: ITransaction, items: IModel[]): QAsync.Promise<IModel[]>;
	    remove(transaction: ITransaction, item: IModel): QAsync.Promise<void>;
	    removeAll(transaction: ITransaction, items: IModel[]): QAsync.Promise<void>;
	}
	export = JsonFileStore;

}
declare module 'thatdevthing/model/stores' {
	export import JsonFileStore = require('thatdevthing/model/stores/JsonFileStore');

}
declare module 'thatdevthing/model' {
	export import IJsonable = require('thatdevthing/model/IJsonable');
	export import IModel = require('thatdevthing/model/IModel');
	export import Jsonable = require('thatdevthing/model/Jsonable');
	export import Model = require('thatdevthing/model/Model');
	export import annotations = require('thatdevthing/model/annotations');
	export import metadata = require('thatdevthing/model/metadata');
	export import store = require('thatdevthing/model/store');
	export import stores = require('thatdevthing/model/stores');

}
declare module 'thatdevthing/security' {
	export import IContext = require('thatdevthing/security/IContext');
	export import IPermission = require('thatdevthing/security/IPermission');
	export import IUser = require('thatdevthing/security/IUser');

}
declare module 'thatdevthing/server/IServer' {
	import api = require('thatdevthing/api');
	interface IServer {
	    rootDir: string;
	    name: string;
	    version: string;
	    port: number;
	    host: string;
	    hasStatic: boolean;
	    hasAPI: boolean;
	    services: {
	        [propName: string]: api.IService;
	    };
	    run(): any;
	}
	export = IServer;

}
declare module 'thatdevthing/server/handlers/contextHandler' {
	 function contextHandler(): (req: any, res: any, next: any) => void;
	export = contextHandler;

}
declare module 'thatdevthing/server/handlers/errorHandler' {
	 function errorHandler(): (err: any, req: any, res: any, next: any) => void;
	export = errorHandler;

}
declare module 'thatdevthing/server/handlers/serviceHandler' {
	import api = require('thatdevthing/api'); function serviceHandler(service: api.IService): (req: any, res: any, next: any) => any;
	export = serviceHandler;

}
declare module 'thatdevthing/server/handlers/swaggerHandler' {
	import IServer = require('thatdevthing/server/IServer'); function swaggerHandler(server: IServer): (req: any, res: any, next: any) => void;
	export = swaggerHandler;

}
declare module 'thatdevthing/server/handlers' {
	export import contextHandler = require('thatdevthing/server/handlers/contextHandler');
	export import errorHandler = require('thatdevthing/server/handlers/errorHandler');
	export import serviceHandler = require('thatdevthing/server/handlers/serviceHandler');
	export import swaggerHandler = require('thatdevthing/server/handlers/swaggerHandler');

}
declare module 'thatdevthing/server/Server' {
	import IServer = require('thatdevthing/server/IServer');
	import api = require('thatdevthing/api'); class Server implements IServer {
	    rootDir: string;
	    name: string;
	    version: string;
	    port: number;
	    host: string;
	    hasStatic: boolean;
	    hasAPI: boolean;
	    services: {
	        [propName: string]: api.IService;
	    };
	    constructor(o: any);
	    run(): void;
	}
	export = Server;

}
declare module 'thatdevthing/server' {
	export import IServer = require('thatdevthing/server/IServer');
	export import Server = require('thatdevthing/server/Server');
	export import handlers = require('thatdevthing/server/handlers');

}
declare module 'thatdevthing/trans/Transaction' {
	import ITransaction = require('thatdevthing/trans/ITransaction');
	import QAsync = require('thatdevthing/async/QAsync'); class Transaction implements ITransaction {
	    private _catches;
	    catch(callback: (err: Error) => any): Transaction;
	    abort(err?: Error): QAsync.Promise<void>;
	    complete(): QAsync.Promise<void>;
	}
	export = Transaction;

}
declare module 'thatdevthing/trans' {
	export import ITransaction = require('thatdevthing/trans/ITransaction');
	export import Transaction = require('thatdevthing/trans/Transaction');

}