From a0d7b386b975299312f876fdf875b7772a0b9ec8 Mon Sep 17 00:00:00 2001
From: Birk Skyum <birkskyum@gmail.com>
Date: Tue, 7 Mar 2017 13:12:50 +0100
Subject: [PATCH] Change indentation to 4 spaces

---
 meteor/index.d.ts      | 2990 ++++++++++++++++++++--------------------
 meteor/meteor-tests.ts |  568 ++++----
 2 files changed, 1781 insertions(+), 1777 deletions(-)

diff --git a/meteor/index.d.ts b/meteor/index.d.ts
index 3acd3e4fef..701f7999ec 100644
--- a/meteor/index.d.ts
+++ b/meteor/index.d.ts
@@ -8,54 +8,12 @@
 // Birk Skyum <https://github.com/birkskyum>
 
 interface URLS {
-  resetPassword: (token: string) => string;
-  verifyEmail: (token: string) => string;
-  enrollAccount: (token: string) => string;
-}
-
-declare module Accounts {
-  var urls: URLS;
-
-  function user(): Meteor.User;
-
-  function userId(): string;
-
-  function createUser(options: {
-    username?: string;
-    email?: string;
-    password?: string;
-    profile?: Object;
-  }, callback?: Function): string;
-
-  function config(options: {
-    sendVerificationEmail?: boolean;
-    forbidClientAccountCreation?: boolean;
-    restrictCreationByEmailDomain?: string | Function;
-    loginExpirationInDays?: number;
-    oauthSecretKey?: string;
-  }): void;
-
-  function onLogin(func: Function): {
-    stop: () => void
-  };
-
-  function onLoginFailure(func: Function): {
-    stop: () => void
-  };
-
-  function loginServicesConfigured(): boolean;
-
-  function onPageLoadLogin(func: Function): void;
-}
-
-declare module "meteor/accounts-base" {
-  interface URLS {
     resetPassword: (token: string) => string;
     verifyEmail: (token: string) => string;
     enrollAccount: (token: string) => string;
-  }
+}
 
-  module Accounts {
+declare module Accounts {
     var urls: URLS;
 
     function user(): Meteor.User;
@@ -63,73 +21,81 @@ declare module "meteor/accounts-base" {
     function userId(): string;
 
     function createUser(options: {
-      username?: string;
-      email?: string;
-      password?: string;
-      profile?: Object;
+        username?: string;
+        email?: string;
+        password?: string;
+        profile?: Object;
     }, callback?: Function): string;
 
     function config(options: {
-      sendVerificationEmail?: boolean;
-      forbidClientAccountCreation?: boolean;
-      restrictCreationByEmailDomain?: string | Function;
-      loginExpirationInDays?: number;
-      oauthSecretKey?: string;
+        sendVerificationEmail?: boolean;
+        forbidClientAccountCreation?: boolean;
+        restrictCreationByEmailDomain?: string | Function;
+        loginExpirationInDays?: number;
+        oauthSecretKey?: string;
     }): void;
 
     function onLogin(func: Function): {
-      stop: () => void
+        stop: () => void
     };
 
     function onLoginFailure(func: Function): {
-      stop: () => void
+        stop: () => void
     };
 
     function loginServicesConfigured(): boolean;
 
     function onPageLoadLogin(func: Function): void;
-  }
-}
-
-declare module Accounts {
-  function changePassword(oldPassword: string, newPassword: string, callback?: Function): void;
-
-  function forgotPassword(options: {
-    email?: string;
-  }, callback?: Function): void;
-
-  function resetPassword(token: string, newPassword: string, callback?: Function): void;
-
-  function verifyEmail(token: string, callback?: Function): void;
-
-  function onEmailVerificationLink(callback: Function): void;
-
-  function onEnrollmentLink(callback: Function): void;
-
-  function onResetPasswordLink(callback: Function): void;
-
-  function loggingIn(): boolean;
-
-  function logout(callback?: Function): void;
-
-  function logoutOtherClients(callback?: Function): void;
-
-  var ui: {
-    config(options: {
-      requestPermissions?: Object;
-      requestOfflineToken?: Object;
-      forceApprovalPrompt?: Object;
-      passwordSignupFields?: string;
-    }): void;
-  };
 }
 
 declare module "meteor/accounts-base" {
-  module Accounts {
+    interface URLS {
+        resetPassword: (token: string) => string;
+        verifyEmail: (token: string) => string;
+        enrollAccount: (token: string) => string;
+    }
+
+    module Accounts {
+        var urls: URLS;
+
+        function user(): Meteor.User;
+
+        function userId(): string;
+
+        function createUser(options: {
+            username?: string;
+            email?: string;
+            password?: string;
+            profile?: Object;
+        }, callback?: Function): string;
+
+        function config(options: {
+            sendVerificationEmail?: boolean;
+            forbidClientAccountCreation?: boolean;
+            restrictCreationByEmailDomain?: string | Function;
+            loginExpirationInDays?: number;
+            oauthSecretKey?: string;
+        }): void;
+
+        function onLogin(func: Function): {
+            stop: () => void
+        };
+
+        function onLoginFailure(func: Function): {
+            stop: () => void
+        };
+
+        function loginServicesConfigured(): boolean;
+
+        function onPageLoadLogin(func: Function): void;
+    }
+}
+
+declare module Accounts {
     function changePassword(oldPassword: string, newPassword: string, callback?: Function): void;
 
     function forgotPassword(options: {
-      email?: string;
+        email?: string;
     }, callback?: Function): void;
 
     function resetPassword(token: string, newPassword: string, callback?: Function): void;
@@ -149,100 +115,71 @@ declare module "meteor/accounts-base" {
     function logoutOtherClients(callback?: Function): void;
 
     var ui: {
-      config(options: {
-        requestPermissions?: Object;
-        requestOfflineToken?: Object;
-        forceApprovalPrompt?: Object;
-        passwordSignupFields?: string;
-      }): void;
+        config(options: {
+            requestPermissions?: Object;
+            requestOfflineToken?: Object;
+            forceApprovalPrompt?: Object;
+            passwordSignupFields?: string;
+        }): void;
     };
-  }
-}
-
-interface EmailFields {
-  from?: () => string;
-  subject?: (user: Meteor.User) => string;
-  text?: (user: Meteor.User, url: string) => string;
-  html?: (user: Meteor.User, url: string) => string;
-}
-
-interface Header {
-  [id: string]: string;
-}
-
-interface EmailTemplates {
-  from: string;
-  siteName: string;
-  headers?: Header;
-  resetPassword: EmailFields;
-  enrollAccount: EmailFields;
-  verifyEmail: EmailFields;
-}
-
-declare module Accounts {
-  var emailTemplates: EmailTemplates;
-
-  function addEmail(userId: string, newEmail: string, verified?: boolean): void;
-
-  function removeEmail(userId: string, email: string): void;
-
-  function onCreateUser(func: Function): void;
-
-  function findUserByEmail(email: string): Object;
-
-  function findUserByUsername(username: string): Object;
-
-  function sendEnrollmentEmail(userId: string, email?: string): void;
-
-  function sendResetPasswordEmail(userId: string, email?: string): void;
-
-  function sendVerificationEmail(userId: string, email?: string): void;
-
-  function setUsername(userId: string, newUsername: string): void;
-
-  function setPassword(userId: string, newPassword: string, options?: {
-    logout?: Object;
-  }): void;
-
-  function validateNewUser(func: Function): boolean;
-
-  function validateLoginAttempt(func: Function): {
-    stop: () => void
-  };
-
-  interface IValidateLoginAttemptCbOpts {
-    type: string;
-    allowed: boolean;
-    error: Meteor.Error;
-    user: Meteor.User;
-    connection: Meteor.Connection;
-    methodName: string;
-    methodArguments: any[];
-  }
 }
 
 declare module "meteor/accounts-base" {
-  interface EmailFields {
+    module Accounts {
+        function changePassword(oldPassword: string, newPassword: string, callback?: Function): void;
+
+        function forgotPassword(options: {
+            email?: string;
+        }, callback?: Function): void;
+
+        function resetPassword(token: string, newPassword: string, callback?: Function): void;
+
+        function verifyEmail(token: string, callback?: Function): void;
+
+        function onEmailVerificationLink(callback: Function): void;
+
+        function onEnrollmentLink(callback: Function): void;
+
+        function onResetPasswordLink(callback: Function): void;
+
+        function loggingIn(): boolean;
+
+        function logout(callback?: Function): void;
+
+        function logoutOtherClients(callback?: Function): void;
+
+        var ui: {
+            config(options: {
+                requestPermissions?: Object;
+                requestOfflineToken?: Object;
+                forceApprovalPrompt?: Object;
+                passwordSignupFields?: string;
+            }): void;
+        };
+    }
+}
+
+interface EmailFields {
     from?: () => string;
     subject?: (user: Meteor.User) => string;
     text?: (user: Meteor.User, url: string) => string;
     html?: (user: Meteor.User, url: string) => string;
-  }
+}
 
-  interface Header {
+interface Header {
     [id: string]: string;
-  }
+}
 
-  interface EmailTemplates {
+interface EmailTemplates {
     from: string;
     siteName: string;
     headers?: Header;
     resetPassword: EmailFields;
     enrollAccount: EmailFields;
     verifyEmail: EmailFields;
-  }
+}
 
-  module Accounts {
+declare module Accounts {
     var emailTemplates: EmailTemplates;
 
     function addEmail(userId: string, newEmail: string, verified?: boolean): void;
@@ -264,217 +201,171 @@ declare module "meteor/accounts-base" {
     function setUsername(userId: string, newUsername: string): void;
 
     function setPassword(userId: string, newPassword: string, options?: {
-      logout?: Object;
+        logout?: Object;
     }): void;
 
     function validateNewUser(func: Function): boolean;
 
     function validateLoginAttempt(func: Function): {
-      stop: () => void
+        stop: () => void
     };
 
     interface IValidateLoginAttemptCbOpts {
-      type: string;
-      allowed: boolean;
-      error: Meteor.Error;
-      user: Meteor.User;
-      connection: Meteor.Connection;
-      methodName: string;
-      methodArguments: any[];
+        type: string;
+        allowed: boolean;
+        error: Meteor.Error;
+        user: Meteor.User;
+        connection: Meteor.Connection;
+        methodName: string;
+        methodArguments: any[];
+    }
+}
+
+declare module "meteor/accounts-base" {
+    interface EmailFields {
+        from?: () => string;
+        subject?: (user: Meteor.User) => string;
+        text?: (user: Meteor.User, url: string) => string;
+        html?: (user: Meteor.User, url: string) => string;
+    }
+
+    interface Header {
+        [id: string]: string;
+    }
+
+    interface EmailTemplates {
+        from: string;
+        siteName: string;
+        headers?: Header;
+        resetPassword: EmailFields;
+        enrollAccount: EmailFields;
+        verifyEmail: EmailFields;
+    }
+
+    module Accounts {
+        var emailTemplates: EmailTemplates;
+
+        function addEmail(userId: string, newEmail: string, verified?: boolean): void;
+
+        function removeEmail(userId: string, email: string): void;
+
+        function onCreateUser(func: Function): void;
+
+        function findUserByEmail(email: string): Object;
+
+        function findUserByUsername(username: string): Object;
+
+        function sendEnrollmentEmail(userId: string, email?: string): void;
+
+        function sendResetPasswordEmail(userId: string, email?: string): void;
+
+        function sendVerificationEmail(userId: string, email?: string): void;
+
+        function setUsername(userId: string, newUsername: string): void;
+
+        function setPassword(userId: string, newPassword: string, options?: {
+            logout?: Object;
+        }): void;
+
+        function validateNewUser(func: Function): boolean;
+
+        function validateLoginAttempt(func: Function): {
+            stop: () => void
+        };
+
+        interface IValidateLoginAttemptCbOpts {
+            type: string;
+            allowed: boolean;
+            error: Meteor.Error;
+            user: Meteor.User;
+            connection: Meteor.Connection;
+            methodName: string;
+            methodArguments: any[];
+        }
     }
-  }
 }
 
 declare module Blaze {
-  var View: ViewStatic;
-
-  interface ViewStatic {
-    new(name?: string, renderFunction?: Function): View;
-  }
-
-  interface View {
-    name: string;
-    parentView: View;
-    isCreated: boolean;
-    isRendered: boolean;
-    isDestroyed: boolean;
-    renderCount: number;
-    autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
-    onViewCreated(func: Function): void;
-    onViewReady(func: Function): void;
-    onViewDestroyed(func: Function): void;
-    firstNode(): Node;
-    lastNode(): Node;
-    template: Template;
-    templateInstance(): TemplateInstance;
-  }
-  var currentView: View;
-
-  function isTemplate(value: any): boolean;
-
-  interface HelpersMap {
-    [key: string]: Function;
-  }
-
-  interface EventsMap {
-    [key: string]: Function;
-  }
-
-  var Template: TemplateStatic;
-
-  interface TemplateStatic {
-    new(viewName?: string, renderFunction?: Function): Template;
-
-    registerHelper(name: string, func: Function): void;
-    instance(): TemplateInstance;
-    currentData(): any;
-    parentData(numLevels: number): any;
-  }
-
-  interface Template {
-    viewName: string;
-    renderFunction: Function;
-    constructView(): View;
-    head: Template;
-    find(selector: string): HTMLElement;
-    findAll(selector: string): HTMLElement[];
-    $: any;
-    onCreated(cb: Function): void;
-    onRendered(cb: Function): void;
-    onDestroyed(cb: Function): void;
-    created: Function;
-    rendered: Function;
-    destroyed: Function;
-    helpers(helpersMap: HelpersMap): void;
-    events(eventsMap: EventsMap): void;
-  }
-
-  var TemplateInstance: TemplateInstanceStatic;
-
-  interface TemplateInstanceStatic {
-    new(view: View): TemplateInstance;
-  }
-
-  interface TemplateInstance {
-    $(selector: string): any;
-    autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
-    data: Object;
-    find(selector: string): HTMLElement;
-    findAll(selector: string): HTMLElement[];
-    firstNode: Object;
-    lastNode: Object;
-    subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
-    subscriptionsReady(): boolean;
-    view: Object;
-  }
-
-  function Each(argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
-
-  function Unless(conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
-
-  function If(conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
-
-  function Let(bindings: Function, contentFunc: Function): View;
-
-  function With(data: Object | Function, contentFunc: Function): View;
-
-  function getData(elementOrView?: HTMLElement | View): Object;
-
-  function getView(element?: HTMLElement): View;
-
-  function remove(renderedView: View): void;
-
-  function render(templateOrView: Template | View, parentNode: Node, nextNode?: Node, parentView?: View): View;
-
-  function renderWithData(templateOrView: Template | View, data: Object | Function, parentNode: Node, nextNode?: Node, parentView?: View): View;
-
-  function toHTML(templateOrView: Template | View): string;
-
-  function toHTMLWithData(templateOrView: Template | View, data: Object | Function): string;
-}
-
-declare module "meteor/blaze" {
-  module Blaze {
     var View: ViewStatic;
 
     interface ViewStatic {
-      new(name?: string, renderFunction?: Function): View;
+        new (name?: string, renderFunction?: Function): View;
     }
 
     interface View {
-      name: string;
-      parentView: View;
-      isCreated: boolean;
-      isRendered: boolean;
-      isDestroyed: boolean;
-      renderCount: number;
-      autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
-      onViewCreated(func: Function): void;
-      onViewReady(func: Function): void;
-      onViewDestroyed(func: Function): void;
-      firstNode(): Node;
-      lastNode(): Node;
-      template: Template;
-      templateInstance(): TemplateInstance;
+        name: string;
+        parentView: View;
+        isCreated: boolean;
+        isRendered: boolean;
+        isDestroyed: boolean;
+        renderCount: number;
+        autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
+        onViewCreated(func: Function): void;
+        onViewReady(func: Function): void;
+        onViewDestroyed(func: Function): void;
+        firstNode(): Node;
+        lastNode(): Node;
+        template: Template;
+        templateInstance(): TemplateInstance;
     }
     var currentView: View;
 
     function isTemplate(value: any): boolean;
 
     interface HelpersMap {
-      [key: string]: Function;
+        [key: string]: Function;
     }
 
     interface EventsMap {
-      [key: string]: Function;
+        [key: string]: Function;
     }
 
     var Template: TemplateStatic;
 
     interface TemplateStatic {
-      new(viewName?: string, renderFunction?: Function): Template;
+        new (viewName?: string, renderFunction?: Function): Template;
 
-      registerHelper(name: string, func: Function): void;
-      instance(): TemplateInstance;
-      currentData(): any;
-      parentData(numLevels: number): any;
+        registerHelper(name: string, func: Function): void;
+        instance(): TemplateInstance;
+        currentData(): any;
+        parentData(numLevels: number): any;
     }
 
     interface Template {
-      viewName: string;
-      renderFunction: Function;
-      constructView(): View;
-      head: Template;
-      find(selector: string): HTMLElement;
-      findAll(selector: string): HTMLElement[];
-      $: any;
-      onCreated(cb: Function): void;
-      onRendered(cb: Function): void;
-      onDestroyed(cb: Function): void;
-      created: Function;
-      rendered: Function;
-      destroyed: Function;
-      helpers(helpersMap: HelpersMap): void;
-      events(eventsMap: EventsMap): void;
+        viewName: string;
+        renderFunction: Function;
+        constructView(): View;
+        head: Template;
+        find(selector: string): HTMLElement;
+        findAll(selector: string): HTMLElement[];
+        $: any;
+        onCreated(cb: Function): void;
+        onRendered(cb: Function): void;
+        onDestroyed(cb: Function): void;
+        created: Function;
+        rendered: Function;
+        destroyed: Function;
+        helpers(helpersMap: HelpersMap): void;
+        events(eventsMap: EventsMap): void;
     }
 
     var TemplateInstance: TemplateInstanceStatic;
 
     interface TemplateInstanceStatic {
-      new(view: View): TemplateInstance;
+        new (view: View): TemplateInstance;
     }
 
     interface TemplateInstance {
-      $(selector: string): any;
-      autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
-      data: Object;
-      find(selector: string): HTMLElement;
-      findAll(selector: string): HTMLElement[];
-      firstNode: Object;
-      lastNode: Object;
-      subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
-      subscriptionsReady(): boolean;
-      view: Object;
+        $(selector: string): any;
+        autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
+        data: Object;
+        find(selector: string): HTMLElement;
+        findAll(selector: string): HTMLElement[];
+        firstNode: Object;
+        lastNode: Object;
+        subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
+        subscriptionsReady(): boolean;
+        view: Object;
     }
 
     function Each(argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
@@ -500,104 +391,191 @@ declare module "meteor/blaze" {
     function toHTML(templateOrView: Template | View): string;
 
     function toHTMLWithData(templateOrView: Template | View, data: Object | Function): string;
-  }
+}
+
+declare module "meteor/blaze" {
+    module Blaze {
+        var View: ViewStatic;
+
+        interface ViewStatic {
+            new (name?: string, renderFunction?: Function): View;
+        }
+
+        interface View {
+            name: string;
+            parentView: View;
+            isCreated: boolean;
+            isRendered: boolean;
+            isDestroyed: boolean;
+            renderCount: number;
+            autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
+            onViewCreated(func: Function): void;
+            onViewReady(func: Function): void;
+            onViewDestroyed(func: Function): void;
+            firstNode(): Node;
+            lastNode(): Node;
+            template: Template;
+            templateInstance(): TemplateInstance;
+        }
+        var currentView: View;
+
+        function isTemplate(value: any): boolean;
+
+        interface HelpersMap {
+            [key: string]: Function;
+        }
+
+        interface EventsMap {
+            [key: string]: Function;
+        }
+
+        var Template: TemplateStatic;
+
+        interface TemplateStatic {
+            new (viewName?: string, renderFunction?: Function): Template;
+
+            registerHelper(name: string, func: Function): void;
+            instance(): TemplateInstance;
+            currentData(): any;
+            parentData(numLevels: number): any;
+        }
+
+        interface Template {
+            viewName: string;
+            renderFunction: Function;
+            constructView(): View;
+            head: Template;
+            find(selector: string): HTMLElement;
+            findAll(selector: string): HTMLElement[];
+            $: any;
+            onCreated(cb: Function): void;
+            onRendered(cb: Function): void;
+            onDestroyed(cb: Function): void;
+            created: Function;
+            rendered: Function;
+            destroyed: Function;
+            helpers(helpersMap: HelpersMap): void;
+            events(eventsMap: EventsMap): void;
+        }
+
+        var TemplateInstance: TemplateInstanceStatic;
+
+        interface TemplateInstanceStatic {
+            new (view: View): TemplateInstance;
+        }
+
+        interface TemplateInstance {
+            $(selector: string): any;
+            autorun(runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
+            data: Object;
+            find(selector: string): HTMLElement;
+            findAll(selector: string): HTMLElement[];
+            firstNode: Object;
+            lastNode: Object;
+            subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
+            subscriptionsReady(): boolean;
+            view: Object;
+        }
+
+        function Each(argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
+
+        function Unless(conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
+
+        function If(conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
+
+        function Let(bindings: Function, contentFunc: Function): View;
+
+        function With(data: Object | Function, contentFunc: Function): View;
+
+        function getData(elementOrView?: HTMLElement | View): Object;
+
+        function getView(element?: HTMLElement): View;
+
+        function remove(renderedView: View): void;
+
+        function render(templateOrView: Template | View, parentNode: Node, nextNode?: Node, parentView?: View): View;
+
+        function renderWithData(templateOrView: Template | View, data: Object | Function, parentNode: Node, nextNode?: Node, parentView?: View): View;
+
+        function toHTML(templateOrView: Template | View): string;
+
+        function toHTMLWithData(templateOrView: Template | View, data: Object | Function): string;
+    }
 }
 
 declare module BrowserPolicy {
-  var framing: {
-    disallow(): void;
-    restrictToOrigin(origin: string): void;
-    allowAll(): void;
-  };
-
-  var content: {
-    allowEval(): void;
-    allowInlineStyles(): void;
-    allowInlineScripts(): void;
-    allowSameOriginForAll(): void;
-    allowDataUrlForAll(): void;
-    allowOriginForAll(origin: string): void;
-    allowImageOrigin(origin: string): void;
-    allowMediaOrigin(origin: string): void;
-    allowFontOrigin(origin: string): void;
-    allowStyleOrigin(origin: string): void;
-    allowScriptOrigin(origin: string): void;
-    allowFrameOrigin(origin: string): void;
-    allowContentTypeSniffing(): void;
-    allowAllContentOrigin(): void;
-    allowAllContentDataUrl(): void;
-    allowAllContentSameOrigin(): void;
-
-    disallowAll(): void;
-    disallowInlineStyles(): void;
-    disallowEval(): void;
-    disallowInlineScripts(): void;
-    disallowFont(): void;
-    disallowObject(): void;
-    disallowAllContent(): void;
-  };
-}
-
-declare module "meteor/browser-policy-common" {
-  module BrowserPolicy {
     var framing: {
-      disallow(): void;
-      restrictToOrigin(origin: string): void;
-      allowAll(): void;
+        disallow(): void;
+        restrictToOrigin(origin: string): void;
+        allowAll(): void;
     };
 
     var content: {
-      allowEval(): void;
-      allowInlineStyles(): void;
-      allowInlineScripts(): void;
-      allowSameOriginForAll(): void;
-      allowDataUrlForAll(): void;
-      allowOriginForAll(origin: string): void;
-      allowImageOrigin(origin: string): void;
-      allowMediaOrigin(origin: string): void;
-      allowFontOrigin(origin: string): void;
-      allowStyleOrigin(origin: string): void;
-      allowScriptOrigin(origin: string): void;
-      allowFrameOrigin(origin: string): void;
-      allowContentTypeSniffing(): void;
-      allowAllContentOrigin(): void;
-      allowAllContentDataUrl(): void;
-      allowAllContentSameOrigin(): void;
+        allowEval(): void;
+        allowInlineStyles(): void;
+        allowInlineScripts(): void;
+        allowSameOriginForAll(): void;
+        allowDataUrlForAll(): void;
+        allowOriginForAll(origin: string): void;
+        allowImageOrigin(origin: string): void;
+        allowMediaOrigin(origin: string): void;
+        allowFontOrigin(origin: string): void;
+        allowStyleOrigin(origin: string): void;
+        allowScriptOrigin(origin: string): void;
+        allowFrameOrigin(origin: string): void;
+        allowContentTypeSniffing(): void;
+        allowAllContentOrigin(): void;
+        allowAllContentDataUrl(): void;
+        allowAllContentSameOrigin(): void;
 
-      disallowAll(): void;
-      disallowInlineStyles(): void;
-      disallowEval(): void;
-      disallowInlineScripts(): void;
-      disallowFont(): void;
-      disallowObject(): void;
-      disallowAllContent(): void;
+        disallowAll(): void;
+        disallowInlineStyles(): void;
+        disallowEval(): void;
+        disallowInlineScripts(): void;
+        disallowFont(): void;
+        disallowObject(): void;
+        disallowAllContent(): void;
     };
-  }
+}
+
+declare module "meteor/browser-policy-common" {
+    module BrowserPolicy {
+        var framing: {
+            disallow(): void;
+            restrictToOrigin(origin: string): void;
+            allowAll(): void;
+        };
+
+        var content: {
+            allowEval(): void;
+            allowInlineStyles(): void;
+            allowInlineScripts(): void;
+            allowSameOriginForAll(): void;
+            allowDataUrlForAll(): void;
+            allowOriginForAll(origin: string): void;
+            allowImageOrigin(origin: string): void;
+            allowMediaOrigin(origin: string): void;
+            allowFontOrigin(origin: string): void;
+            allowStyleOrigin(origin: string): void;
+            allowScriptOrigin(origin: string): void;
+            allowFrameOrigin(origin: string): void;
+            allowContentTypeSniffing(): void;
+            allowAllContentOrigin(): void;
+            allowAllContentDataUrl(): void;
+            allowAllContentSameOrigin(): void;
+
+            disallowAll(): void;
+            disallowInlineStyles(): void;
+            disallowEval(): void;
+            disallowInlineScripts(): void;
+            disallowFont(): void;
+            disallowObject(): void;
+            disallowAllContent(): void;
+        };
+    }
 }
 
 declare module Match {
-  var Any: any;
-  var String: any;
-  var Integer: any;
-  var Boolean: any;
-  var undefined: any;
-  var Object: any;
-
-  function Optional(pattern: any): boolean;
-
-  function ObjectIncluding(dico: any): boolean;
-
-  function OneOf(...patterns: any[]): any;
-
-  function Where(condition: any): any;
-
-  function test(value: any, pattern: any): boolean;
-}
-
-declare function check(value: any, pattern: any): void;
-
-declare module "meteor/check" {
-  module Match {
     var Any: any;
     var String: any;
     var Integer: any;
@@ -614,89 +592,73 @@ declare module "meteor/check" {
     function Where(condition: any): any;
 
     function test(value: any, pattern: any): boolean;
-  }
+}
 
-  function check(value: any, pattern: any): void;
+declare function check(value: any, pattern: any): void;
+
+declare module "meteor/check" {
+    module Match {
+        var Any: any;
+        var String: any;
+        var Integer: any;
+        var Boolean: any;
+        var undefined: any;
+        var Object: any;
+
+        function Optional(pattern: any): boolean;
+
+        function ObjectIncluding(dico: any): boolean;
+
+        function OneOf(...patterns: any[]): any;
+
+        function Where(condition: any): any;
+
+        function test(value: any, pattern: any): boolean;
+    }
+
+    function check(value: any, pattern: any): void;
 }
 
 declare module DDPRateLimiter {
-  interface Matcher {
-    type?: string | ((type: string) => boolean);
-    name?: string | ((name: string) => boolean);
-    userId?: string | ((userId: string) => boolean);
-    connectionId?: string | ((connectionId: string) => boolean);
-    clientAddress?: string | ((clientAddress: string) => boolean);
-  }
-
-  function addRule(matcher: Matcher, numRequests: number, timeInterval: number): string;
-
-  function removeRule(ruleId: string): boolean;
-}
-
-declare module "meteor/ddp-rate-limiter" {
-  module DDPRateLimiter {
     interface Matcher {
-      type?: string | ((type: string) => boolean);
-      name?: string | ((name: string) => boolean);
-      userId?: string | ((userId: string) => boolean);
-      connectionId?: string | ((connectionId: string) => boolean);
-      clientAddress?: string | ((clientAddress: string) => boolean);
+        type?: string | ((type: string) => boolean);
+        name?: string | ((name: string) => boolean);
+        userId?: string | ((userId: string) => boolean);
+        connectionId?: string | ((connectionId: string) => boolean);
+        clientAddress?: string | ((clientAddress: string) => boolean);
     }
 
     function addRule(matcher: Matcher, numRequests: number, timeInterval: number): string;
 
     function removeRule(ruleId: string): boolean;
-  }
+}
+
+declare module "meteor/ddp-rate-limiter" {
+    module DDPRateLimiter {
+        interface Matcher {
+            type?: string | ((type: string) => boolean);
+            name?: string | ((name: string) => boolean);
+            userId?: string | ((userId: string) => boolean);
+            connectionId?: string | ((connectionId: string) => boolean);
+            clientAddress?: string | ((clientAddress: string) => boolean);
+        }
+
+        function addRule(matcher: Matcher, numRequests: number, timeInterval: number): string;
+
+        function removeRule(ruleId: string): boolean;
+    }
 }
 
 declare module DDP {
-  interface DDPStatic {
-    subscribe(name: string, ...rest: any[]): Meteor.SubscriptionHandle;
-    call(method: string, ...parameters: any[]): void;
-    apply(method: string, ...parameters: any[]): void;
-    methods(IMeteorMethodsDictionary: any): any;
-    status(): DDPStatus;
-    reconnect(): void;
-    disconnect(): void;
-    onReconnect(): void;
-  }
-
-  function _allSubscriptionsReady(): boolean;
-
-  type Status = 'connected' | 'connecting' | 'failed' | 'waiting' | 'offline';
-
-  interface DDPStatus {
-    connected: boolean;
-    status: Status;
-    retryCount: number;
-    retryTime?: number;
-    reason?: string;
-  }
-
-  function connect(url: string): DDPStatic;
-}
-
-declare module DDPCommon {
-  interface MethodInvocation {
-    new(options: {}): MethodInvocation;
-
-    unblock(): void;
-
-    setUserId(userId: number): void;
-  }
-}
-
-declare module "meteor/ddp" {
-  module DDP {
     interface DDPStatic {
-      subscribe(name: string, ...rest: any[]): Meteor.SubscriptionHandle;
-      call(method: string, ...parameters: any[]): void;
-      apply(method: string, ...parameters: any[]): void;
-      methods(IMeteorMethodsDictionary: any): any;
-      status(): DDPStatus;
-      reconnect(): void;
-      disconnect(): void;
-      onReconnect(): void;
+        subscribe(name: string, ...rest: any[]): Meteor.SubscriptionHandle;
+        call(method: string, ...parameters: any[]): void;
+        apply(method: string, ...parameters: any[]): void;
+        methods(IMeteorMethodsDictionary: any): any;
+        status(): DDPStatus;
+        reconnect(): void;
+        disconnect(): void;
+        onReconnect(): void;
     }
 
     function _allSubscriptionsReady(): boolean;
@@ -704,87 +666,86 @@ declare module "meteor/ddp" {
     type Status = 'connected' | 'connecting' | 'failed' | 'waiting' | 'offline';
 
     interface DDPStatus {
-      connected: boolean;
-      status: Status;
-      retryCount: number;
-      retryTime?: number;
-      reason?: string;
+        connected: boolean;
+        status: Status;
+        retryCount: number;
+        retryTime?: number;
+        reason?: string;
     }
 
     function connect(url: string): DDPStatic;
-  }
+}
 
-  module DDPCommon {
+declare module DDPCommon {
     interface MethodInvocation {
-      new(options: {}): MethodInvocation;
+        new (options: {}): MethodInvocation;
 
-      unblock(): void;
+        unblock(): void;
 
-      setUserId(userId: number): void;
+        setUserId(userId: number): void;
+    }
+}
+
+declare module "meteor/ddp" {
+    module DDP {
+        interface DDPStatic {
+            subscribe(name: string, ...rest: any[]): Meteor.SubscriptionHandle;
+            call(method: string, ...parameters: any[]): void;
+            apply(method: string, ...parameters: any[]): void;
+            methods(IMeteorMethodsDictionary: any): any;
+            status(): DDPStatus;
+            reconnect(): void;
+            disconnect(): void;
+            onReconnect(): void;
+        }
+
+        function _allSubscriptionsReady(): boolean;
+
+        type Status = 'connected' | 'connecting' | 'failed' | 'waiting' | 'offline';
+
+        interface DDPStatus {
+            connected: boolean;
+            status: Status;
+            retryCount: number;
+            retryTime?: number;
+            reason?: string;
+        }
+
+        function connect(url: string): DDPStatic;
+    }
+
+    module DDPCommon {
+        interface MethodInvocation {
+            new (options: {}): MethodInvocation;
+
+            unblock(): void;
+
+            setUserId(userId: number): void;
+        }
     }
-  }
 }
 
 interface EJSONableCustomType {
-  clone(): EJSONableCustomType;
-  equals(other: Object): boolean;
-  toJSONValue(): JSONable;
-  typeName(): string;
-}
-interface EJSONable {
-  [key: string]: number | string | boolean | Object | number[] | string[] | Object[] | Date | Uint8Array | EJSONableCustomType;
-}
-interface JSONable {
-  [key: string]: number | string | boolean | Object | number[] | string[] | Object[];
-}
-interface EJSON extends EJSONable {}
-
-declare module EJSON {
-  function addType(name: string, factory: (val: JSONable) => EJSONableCustomType): void;
-
-  function clone < T > (val: T): T;
-
-  function equals(a: EJSON, b: EJSON, options?: {
-    keyOrderSensitive?: boolean;
-  }): boolean;
-
-  function fromJSONValue(val: JSONable): any;
-
-  function isBinary(x: Object): boolean;
-  var newBinary: any;
-
-  function parse(str: string): EJSON;
-
-  function stringify(val: EJSON, options?: {
-    indent?: boolean | number | string;
-    canonical?: boolean;
-  }): string;
-
-  function toJSONValue(val: EJSON): JSONable;
-}
-
-declare module "meteor/ejson" {
-  interface EJSONableCustomType {
     clone(): EJSONableCustomType;
     equals(other: Object): boolean;
     toJSONValue(): JSONable;
     typeName(): string;
-  }
-  interface EJSONable {
+}
+interface EJSONable {
     [key: string]: number | string | boolean | Object | number[] | string[] | Object[] | Date | Uint8Array | EJSONableCustomType;
-  }
-  interface JSONable {
+}
+interface JSONable {
     [key: string]: number | string | boolean | Object | number[] | string[] | Object[];
-  }
-  interface EJSON extends EJSONable {}
+}
+interface EJSON extends EJSONable { }
 
-  module EJSON {
+declare module EJSON {
     function addType(name: string, factory: (val: JSONable) => EJSONableCustomType): void;
 
-    function clone < T > (val: T): T;
+    function clone<T>(val: T): T;
 
     function equals(a: EJSON, b: EJSON, options?: {
-      keyOrderSensitive?: boolean;
+        keyOrderSensitive?: boolean;
     }): boolean;
 
     function fromJSONValue(val: JSONable): any;
@@ -795,159 +756,148 @@ declare module "meteor/ejson" {
     function parse(str: string): EJSON;
 
     function stringify(val: EJSON, options?: {
-      indent?: boolean | number | string;
-      canonical?: boolean;
+        indent?: boolean | number | string;
+        canonical?: boolean;
     }): string;
 
     function toJSONValue(val: EJSON): JSONable;
-  }
+}
+
+declare module "meteor/ejson" {
+    interface EJSONableCustomType {
+        clone(): EJSONableCustomType;
+        equals(other: Object): boolean;
+        toJSONValue(): JSONable;
+        typeName(): string;
+    }
+    interface EJSONable {
+        [key: string]: number | string | boolean | Object | number[] | string[] | Object[] | Date | Uint8Array | EJSONableCustomType;
+    }
+    interface JSONable {
+        [key: string]: number | string | boolean | Object | number[] | string[] | Object[];
+    }
+    interface EJSON extends EJSONable { }
+
+    module EJSON {
+        function addType(name: string, factory: (val: JSONable) => EJSONableCustomType): void;
+
+        function clone<T>(val: T): T;
+
+        function equals(a: EJSON, b: EJSON, options?: {
+            keyOrderSensitive?: boolean;
+        }): boolean;
+
+        function fromJSONValue(val: JSONable): any;
+
+        function isBinary(x: Object): boolean;
+        var newBinary: any;
+
+        function parse(str: string): EJSON;
+
+        function stringify(val: EJSON, options?: {
+            indent?: boolean | number | string;
+            canonical?: boolean;
+        }): string;
+
+        function toJSONValue(val: EJSON): JSONable;
+    }
 }
 
 declare module Email {
-  function send(options: {
-    from?: string;
-    to?: string | string[];
-    cc?: string | string[];
-    bcc?: string | string[];
-    replyTo?: string | string[];
-    subject?: string;
-    text?: string;
-    html?: string;
-    headers?: Object;
-    attachments?: Object[];
-    mailComposer?: MailComposer;
-  }): void;
+    function send(options: {
+        from?: string;
+        to?: string | string[];
+        cc?: string | string[];
+        bcc?: string | string[];
+        replyTo?: string | string[];
+        subject?: string;
+        text?: string;
+        html?: string;
+        headers?: Object;
+        attachments?: Object[];
+        mailComposer?: MailComposer;
+    }): void;
 }
 
 interface MailComposerOptions {
-  escapeSMTP: boolean;
-  encoding: string;
-  charset: string;
-  keepBcc: boolean;
-  forceEmbeddedImages: boolean;
-}
-
-declare var MailComposer: MailComposerStatic;
-interface MailComposerStatic {
-  new(options: MailComposerOptions): MailComposer;
-}
-interface MailComposer {
-  addHeader(name: string, value: string): void;
-  setMessageOption(from: string, to: string, body: string, html: string): void;
-  streamMessage(): void;
-  pipe(stream: any /** fs.WriteStream **/ ): void;
-}
-
-declare module "meteor/email" {
-  module Email {
-    function send(options: {
-      from?: string;
-      to?: string | string[];
-      cc?: string | string[];
-      bcc?: string | string[];
-      replyTo?: string | string[];
-      subject?: string;
-      text?: string;
-      html?: string;
-      headers?: Object;
-      attachments?: Object[];
-      mailComposer?: MailComposer;
-    }): void;
-  }
-
-  interface MailComposerOptions {
     escapeSMTP: boolean;
     encoding: string;
     charset: string;
     keepBcc: boolean;
     forceEmbeddedImages: boolean;
-  }
+}
 
-  var MailComposer: MailComposerStatic;
-  interface MailComposerStatic {
-    new(options: MailComposerOptions): MailComposer;
-  }
-  interface MailComposer {
+declare var MailComposer: MailComposerStatic;
+interface MailComposerStatic {
+    new (options: MailComposerOptions): MailComposer;
+}
+interface MailComposer {
     addHeader(name: string, value: string): void;
     setMessageOption(from: string, to: string, body: string, html: string): void;
     streamMessage(): void;
-    pipe(stream: any /** fs.WriteStream **/ ): void;
-  }
+    pipe(stream: any /** fs.WriteStream **/): void;
+}
+
+declare module "meteor/email" {
+    module Email {
+        function send(options: {
+            from?: string;
+            to?: string | string[];
+            cc?: string | string[];
+            bcc?: string | string[];
+            replyTo?: string | string[];
+            subject?: string;
+            text?: string;
+            html?: string;
+            headers?: Object;
+            attachments?: Object[];
+            mailComposer?: MailComposer;
+        }): void;
+    }
+
+    interface MailComposerOptions {
+        escapeSMTP: boolean;
+        encoding: string;
+        charset: string;
+        keepBcc: boolean;
+        forceEmbeddedImages: boolean;
+    }
+
+    var MailComposer: MailComposerStatic;
+    interface MailComposerStatic {
+        new (options: MailComposerOptions): MailComposer;
+    }
+    interface MailComposer {
+        addHeader(name: string, value: string): void;
+        setMessageOption(from: string, to: string, body: string, html: string): void;
+        streamMessage(): void;
+        pipe(stream: any /** fs.WriteStream **/): void;
+    }
 }
 
 declare module HTTP {
-  interface HTTPRequest {
-    content?: string;
-    data?: any;
-    query?: string;
-    params?: {
-      [id: string]: string
-    };
-    auth?: string;
-    headers?: {
-      [id: string]: string
-    };
-    timeout?: number;
-    followRedirects?: boolean;
-  }
-
-  interface HTTPResponse {
-    statusCode?: number;
-    headers?: {
-      [id: string]: string
-    };
-    content?: string;
-    data?: any;
-  }
-
-  function call(method: string, url: string, options?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
-
-  function del(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
-
-  function get(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
-
-  function post(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
-
-  function put(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
-
-  function call(method: string, url: string, options?: {
-    content?: string;
-    data?: Object;
-    query?: string;
-    params?: Object;
-    auth?: string;
-    headers?: Object;
-    timeout?: number;
-    followRedirects?: boolean;
-    npmRequestOptions?: Object;
-    beforeSend?: Function;
-  }, asyncCallback?: Function): HTTP.HTTPResponse;
-}
-
-declare module "meteor/http" {
-  module HTTP {
     interface HTTPRequest {
-      content?: string;
-      data?: any;
-      query?: string;
-      params?: {
-        [id: string]: string
-      };
-      auth?: string;
-      headers?: {
-        [id: string]: string
-      };
-      timeout?: number;
-      followRedirects?: boolean;
+        content?: string;
+        data?: any;
+        query?: string;
+        params?: {
+            [id: string]: string
+        };
+        auth?: string;
+        headers?: {
+            [id: string]: string
+        };
+        timeout?: number;
+        followRedirects?: boolean;
     }
 
     interface HTTPResponse {
-      statusCode?: number;
-      headers?: {
-        [id: string]: string
-      };
-      content?: string;
-      data?: any;
+        statusCode?: number;
+        headers?: {
+            [id: string]: string
+        };
+        content?: string;
+        data?: any;
     }
 
     function call(method: string, url: string, options?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
@@ -961,122 +911,71 @@ declare module "meteor/http" {
     function put(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
 
     function call(method: string, url: string, options?: {
-      content?: string;
-      data?: Object;
-      query?: string;
-      params?: Object;
-      auth?: string;
-      headers?: Object;
-      timeout?: number;
-      followRedirects?: boolean;
-      npmRequestOptions?: Object;
-      beforeSend?: Function;
+        content?: string;
+        data?: Object;
+        query?: string;
+        params?: Object;
+        auth?: string;
+        headers?: Object;
+        timeout?: number;
+        followRedirects?: boolean;
+        npmRequestOptions?: Object;
+        beforeSend?: Function;
     }, asyncCallback?: Function): HTTP.HTTPResponse;
-  }
+}
+
+declare module "meteor/http" {
+    module HTTP {
+        interface HTTPRequest {
+            content?: string;
+            data?: any;
+            query?: string;
+            params?: {
+                [id: string]: string
+            };
+            auth?: string;
+            headers?: {
+                [id: string]: string
+            };
+            timeout?: number;
+            followRedirects?: boolean;
+        }
+
+        interface HTTPResponse {
+            statusCode?: number;
+            headers?: {
+                [id: string]: string
+            };
+            content?: string;
+            data?: any;
+        }
+
+        function call(method: string, url: string, options?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
+
+        function del(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
+
+        function get(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
+
+        function post(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
+
+        function put(url: string, callOptions?: HTTP.HTTPRequest, asyncCallback?: Function): HTTP.HTTPResponse;
+
+        function call(method: string, url: string, options?: {
+            content?: string;
+            data?: Object;
+            query?: string;
+            params?: Object;
+            auth?: string;
+            headers?: Object;
+            timeout?: number;
+            followRedirects?: boolean;
+            npmRequestOptions?: Object;
+            beforeSend?: Function;
+        }, asyncCallback?: Function): HTTP.HTTPResponse;
+    }
 }
 
 declare module Meteor {
-  /** Global props **/
-  var isClient: boolean;
-  var isCordova: boolean;
-  var isServer: boolean;
-  var isProduction: boolean;
-  var release: string;
-  /** Global props **/
-
-  /** Settings **/
-  interface Settings {
-    public: {
-      [id: string]: any
-    }, [id: string]: any
-  }
-  var settings: Settings;
-  /** Settings **/
-
-  /** User **/
-  interface UserEmail {
-    address: string;
-    verified: boolean;
-  }
-  interface User {
-    _id?: string;
-    username?: string;
-    emails?: UserEmail[];
-    createdAt?: number;
-    profile?: any;
-    services?: any;
-  }
-
-  function user(): User;
-
-  function userId(): string;
-  var users: Mongo.Collection < User > ;
-  /** User **/
-
-  /** Error **/
-  var Error: ErrorStatic;
-  interface ErrorStatic {
-    new(error: string | number, reason?: string, details?: string): Error;
-  }
-  interface Error {
-    error: string | number;
-    reason?: string;
-    details?: string;
-  }
-  /** Error **/
-
-  /** Method **/
-  function methods(methods: Object): void;
-
-  function call(name: string, ...args: any[]): any;
-
-  function apply(name: string, args: EJSONable[], options?: {
-    wait?: boolean;
-    onResultReceived?: Function;
-  }, asyncCallback?: Function): any;
-  /** Method **/
-
-  /** Url **/
-  function absoluteUrl(path?: string, options?: {
-    secure?: boolean;
-    replaceLocalhost?: boolean;
-    rootUrl?: string;
-  }): string;
-  /** Url **/
-
-  /** Timeout **/
-  function setInterval(func: Function, delay: number): number;
-
-  function setTimeout(func: Function, delay: number): number;
-
-  function clearInterval(id: number): void;
-
-  function clearTimeout(id: number): void;
-
-  function defer(func: Function): void;
-  /** Timeout **/
-
-  /** utils **/
-  function startup(func: Function): void;
-
-  function wrapAsync(func: Function, context?: Object): any;
-
-  function bindEnvironment(func: Function): any;
-  /** utils **/
-
-  /** Pub/Sub **/
-  interface SubscriptionHandle {
-    stop(): void;
-    ready(): boolean;
-  }
-  interface LiveQueryHandle {
-    stop(): void;
-  }
-  /** Pub/Sub **/
-}
-
-declare module "meteor/meteor" {
-  module Meteor {
     /** Global props **/
     var isClient: boolean;
     var isCordova: boolean;
@@ -1087,42 +986,42 @@ declare module "meteor/meteor" {
 
     /** Settings **/
     interface Settings {
-      public: {
-        [id: string]: any
-      }, [id: string]: any
+        public: {
+            [id: string]: any
+        }, [id: string]: any
     }
     var settings: Settings;
     /** Settings **/
 
     /** User **/
     interface UserEmail {
-      address: string;
-      verified: boolean;
+        address: string;
+        verified: boolean;
     }
     interface User {
-      _id?: string;
-      username?: string;
-      emails?: UserEmail[];
-      createdAt?: number;
-      profile?: any;
-      services?: any;
+        _id?: string;
+        username?: string;
+        emails?: UserEmail[];
+        createdAt?: number;
+        profile?: any;
+        services?: any;
     }
 
     function user(): User;
 
     function userId(): string;
-    var users: Mongo.Collection < User > ;
+    var users: Mongo.Collection<User>;
     /** User **/
 
     /** Error **/
     var Error: ErrorStatic;
     interface ErrorStatic {
-      new(error: string | number, reason?: string, details?: string): Error;
+        new (error: string | number, reason?: string, details?: string): Error;
     }
     interface Error {
-      error: string | number;
-      reason?: string;
-      details?: string;
+        error: string | number;
+        reason?: string;
+        details?: string;
     }
     /** Error **/
 
@@ -1132,16 +1031,16 @@ declare module "meteor/meteor" {
     function call(name: string, ...args: any[]): any;
 
     function apply(name: string, args: EJSONable[], options?: {
-      wait?: boolean;
-      onResultReceived?: Function;
+        wait?: boolean;
+        onResultReceived?: Function;
     }, asyncCallback?: Function): any;
     /** Method **/
 
     /** Url **/
     function absoluteUrl(path?: string, options?: {
-      secure?: boolean;
-      replaceLocalhost?: boolean;
-      rootUrl?: string;
+        secure?: boolean;
+        replaceLocalhost?: boolean;
+        rootUrl?: string;
     }): string;
     /** Url **/
 
@@ -1167,109 +1066,127 @@ declare module "meteor/meteor" {
 
     /** Pub/Sub **/
     interface SubscriptionHandle {
-      stop(): void;
-      ready(): boolean;
+        stop(): void;
+        ready(): boolean;
     }
     interface LiveQueryHandle {
-      stop(): void;
+        stop(): void;
     }
     /** Pub/Sub **/
-  }
-}
-
-declare module Meteor {
-  /** Login **/
-  interface LoginWithExternalServiceOptions {
-    requestPermissions?: string[];
-    requestOfflineToken?: Boolean;
-    forceApprovalPrompt?: Boolean;
-    loginUrlParameters?: Object;
-    redirectUrl?: string;
-    loginHint?: string;
-    loginStyle?: string;
-  }
-
-  function loginWithMeteorDeveloperAccount(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loginWithFacebook(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loginWithGithub(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loginWithGoogle(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loginWithMeetup(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loginWithTwitter(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loginWithWeibo(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
-
-  function loggingIn(): boolean;
-
-  function loginWith < ExternalService > (options?: {
-    requestPermissions?: string[];
-    requestOfflineToken?: boolean;
-    loginUrlParameters?: Object;
-    userEmail?: string;
-    loginStyle?: string;
-    redirectUrl?: string;
-  }, callback?: Function): void;
-
-  function loginWithPassword(user: Object | string, password: string, callback?: Function): void;
-
-  function loginWithToken(token: string, callback?: Function): void;
-
-  function logout(callback?: Function): void;
-
-  function logoutOtherClients(callback?: Function): void;
-  /** Login **/
-
-  /** Event **/
-  interface Event {
-    type: string;
-    target: HTMLElement;
-    currentTarget: HTMLElement;
-    which: number;
-    stopPropagation(): void;
-    stopImmediatePropagation(): void;
-    preventDefault(): void;
-    isPropagationStopped(): boolean;
-    isImmediatePropagationStopped(): boolean;
-    isDefaultPrevented(): boolean;
-  }
-  interface EventHandlerFunction extends Function {
-    (event?: Meteor.Event, templateInstance?: Blaze.TemplateInstance): void;
-  }
-  interface EventMap {
-    [id: string]: Meteor.EventHandlerFunction;
-  }
-  /** Event **/
-
-  /** Connection **/
-  function reconnect(): void;
-
-  function disconnect(): void;
-  /** Connection **/
-
-  /** Status **/
-  function status(): DDP.DDPStatus;
-  /** Status **/
-
-  /** Pub/Sub **/
-  function subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
-  /** Pub/Sub **/
 }
 
 declare module "meteor/meteor" {
-  module Meteor {
+    module Meteor {
+        /** Global props **/
+        var isClient: boolean;
+        var isCordova: boolean;
+        var isServer: boolean;
+        var isProduction: boolean;
+        var release: string;
+        /** Global props **/
+
+        /** Settings **/
+        interface Settings {
+            public: {
+                [id: string]: any
+            }, [id: string]: any
+        }
+        var settings: Settings;
+        /** Settings **/
+
+        /** User **/
+        interface UserEmail {
+            address: string;
+            verified: boolean;
+        }
+        interface User {
+            _id?: string;
+            username?: string;
+            emails?: UserEmail[];
+            createdAt?: number;
+            profile?: any;
+            services?: any;
+        }
+
+        function user(): User;
+
+        function userId(): string;
+        var users: Mongo.Collection<User>;
+        /** User **/
+
+        /** Error **/
+        var Error: ErrorStatic;
+        interface ErrorStatic {
+            new (error: string | number, reason?: string, details?: string): Error;
+        }
+        interface Error {
+            error: string | number;
+            reason?: string;
+            details?: string;
+        }
+        /** Error **/
+
+        /** Method **/
+        function methods(methods: Object): void;
+
+        function call(name: string, ...args: any[]): any;
+
+        function apply(name: string, args: EJSONable[], options?: {
+            wait?: boolean;
+            onResultReceived?: Function;
+        }, asyncCallback?: Function): any;
+        /** Method **/
+
+        /** Url **/
+        function absoluteUrl(path?: string, options?: {
+            secure?: boolean;
+            replaceLocalhost?: boolean;
+            rootUrl?: string;
+        }): string;
+        /** Url **/
+
+        /** Timeout **/
+        function setInterval(func: Function, delay: number): number;
+
+        function setTimeout(func: Function, delay: number): number;
+
+        function clearInterval(id: number): void;
+
+        function clearTimeout(id: number): void;
+
+        function defer(func: Function): void;
+        /** Timeout **/
+
+        /** utils **/
+        function startup(func: Function): void;
+
+        function wrapAsync(func: Function, context?: Object): any;
+
+        function bindEnvironment(func: Function): any;
+        /** utils **/
+
+        /** Pub/Sub **/
+        interface SubscriptionHandle {
+            stop(): void;
+            ready(): boolean;
+        }
+        interface LiveQueryHandle {
+            stop(): void;
+        }
+        /** Pub/Sub **/
+    }
+}
+
+declare module Meteor {
     /** Login **/
     interface LoginWithExternalServiceOptions {
-      requestPermissions?: string[];
-      requestOfflineToken?: Boolean;
-      forceApprovalPrompt?: Boolean;
-      loginUrlParameters?: Object;
-      redirectUrl?: string;
-      loginHint?: string;
-      loginStyle?: string;
+        requestPermissions?: string[];
+        requestOfflineToken?: Boolean;
+        forceApprovalPrompt?: Boolean;
+        loginUrlParameters?: Object;
+        redirectUrl?: string;
+        loginHint?: string;
+        loginStyle?: string;
     }
 
     function loginWithMeteorDeveloperAccount(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
@@ -1288,13 +1205,13 @@ declare module "meteor/meteor" {
 
     function loggingIn(): boolean;
 
-    function loginWith < ExternalService > (options?: {
-      requestPermissions?: string[];
-      requestOfflineToken?: boolean;
-      loginUrlParameters?: Object;
-      userEmail?: string;
-      loginStyle?: string;
-      redirectUrl?: string;
+    function loginWith<ExternalService>(options?: {
+        requestPermissions?: string[];
+        requestOfflineToken?: boolean;
+        loginUrlParameters?: Object;
+        userEmail?: string;
+        loginStyle?: string;
+        redirectUrl?: string;
     }, callback?: Function): void;
 
     function loginWithPassword(user: Object | string, password: string, callback?: Function): void;
@@ -1308,22 +1225,22 @@ declare module "meteor/meteor" {
 
     /** Event **/
     interface Event {
-      type: string;
-      target: HTMLElement;
-      currentTarget: HTMLElement;
-      which: number;
-      stopPropagation(): void;
-      stopImmediatePropagation(): void;
-      preventDefault(): void;
-      isPropagationStopped(): boolean;
-      isImmediatePropagationStopped(): boolean;
-      isDefaultPrevented(): boolean;
+        type: string;
+        target: HTMLElement;
+        currentTarget: HTMLElement;
+        which: number;
+        stopPropagation(): void;
+        stopImmediatePropagation(): void;
+        preventDefault(): void;
+        isPropagationStopped(): boolean;
+        isImmediatePropagationStopped(): boolean;
+        isDefaultPrevented(): boolean;
     }
     interface EventHandlerFunction extends Function {
-      (event?: Meteor.Event, templateInstance?: Blaze.TemplateInstance): void;
+        (event?: Meteor.Event, templateInstance?: Blaze.TemplateInstance): void;
     }
     interface EventMap {
-      [id: string]: Meteor.EventHandlerFunction;
+        [id: string]: Meteor.EventHandlerFunction;
     }
     /** Event **/
 
@@ -1340,48 +1257,100 @@ declare module "meteor/meteor" {
     /** Pub/Sub **/
     function subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
     /** Pub/Sub **/
-  }
-}
-
-declare module Meteor {
-  /** Connection **/
-  interface Connection {
-    id: string;
-    close: Function;
-    onClose: Function;
-    clientAddress: string;
-    httpHeaders: Object;
-  }
-
-  function onConnection(callback: Function): void;
-  /** Connection **/
-
-  function publish(name: string, func: Function): void;
-
-  function _debug(...args: any[]): void;
-}
-
-interface Subscription {
-  added(collection: string, id: string, fields: Object): void;
-  changed(collection: string, id: string, fields: Object): void;
-  connection: Meteor.Connection;
-  error(error: Error): void;
-  onStop(func: Function): void;
-  ready(): void;
-  removed(collection: string, id: string): void;
-  stop(): void;
-  userId: string;
 }
 
 declare module "meteor/meteor" {
-  module Meteor {
+    module Meteor {
+        /** Login **/
+        interface LoginWithExternalServiceOptions {
+            requestPermissions?: string[];
+            requestOfflineToken?: Boolean;
+            forceApprovalPrompt?: Boolean;
+            loginUrlParameters?: Object;
+            redirectUrl?: string;
+            loginHint?: string;
+            loginStyle?: string;
+        }
+
+        function loginWithMeteorDeveloperAccount(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loginWithFacebook(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loginWithGithub(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loginWithGoogle(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loginWithMeetup(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loginWithTwitter(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loginWithWeibo(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+        function loggingIn(): boolean;
+
+        function loginWith<ExternalService>(options?: {
+            requestPermissions?: string[];
+            requestOfflineToken?: boolean;
+            loginUrlParameters?: Object;
+            userEmail?: string;
+            loginStyle?: string;
+            redirectUrl?: string;
+        }, callback?: Function): void;
+
+        function loginWithPassword(user: Object | string, password: string, callback?: Function): void;
+
+        function loginWithToken(token: string, callback?: Function): void;
+
+        function logout(callback?: Function): void;
+
+        function logoutOtherClients(callback?: Function): void;
+        /** Login **/
+
+        /** Event **/
+        interface Event {
+            type: string;
+            target: HTMLElement;
+            currentTarget: HTMLElement;
+            which: number;
+            stopPropagation(): void;
+            stopImmediatePropagation(): void;
+            preventDefault(): void;
+            isPropagationStopped(): boolean;
+            isImmediatePropagationStopped(): boolean;
+            isDefaultPrevented(): boolean;
+        }
+        interface EventHandlerFunction extends Function {
+            (event?: Meteor.Event, templateInstance?: Blaze.TemplateInstance): void;
+        }
+        interface EventMap {
+            [id: string]: Meteor.EventHandlerFunction;
+        }
+        /** Event **/
+
+        /** Connection **/
+        function reconnect(): void;
+
+        function disconnect(): void;
+        /** Connection **/
+
+        /** Status **/
+        function status(): DDP.DDPStatus;
+        /** Status **/
+
+        /** Pub/Sub **/
+        function subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
+        /** Pub/Sub **/
+    }
+}
+
+declare module Meteor {
     /** Connection **/
     interface Connection {
-      id: string;
-      close: Function;
-      onClose: Function;
-      clientAddress: string;
-      httpHeaders: Object;
+        id: string;
+        close: Function;
+        onClose: Function;
+        clientAddress: string;
+        httpHeaders: Object;
     }
 
     function onConnection(callback: Function): void;
@@ -1390,9 +1359,9 @@ declare module "meteor/meteor" {
     function publish(name: string, func: Function): void;
 
     function _debug(...args: any[]): void;
-  }
+}
 
-  interface Subscription {
+interface Subscription {
     added(collection: string, id: string, fields: Object): void;
     changed(collection: string, id: string, fields: Object): void;
     connection: Meteor.Connection;
@@ -1402,265 +1371,281 @@ declare module "meteor/meteor" {
     removed(collection: string, id: string): void;
     stop(): void;
     userId: string;
-  }
+}
+
+declare module "meteor/meteor" {
+    module Meteor {
+        /** Connection **/
+        interface Connection {
+            id: string;
+            close: Function;
+            onClose: Function;
+            clientAddress: string;
+            httpHeaders: Object;
+        }
+
+        function onConnection(callback: Function): void;
+        /** Connection **/
+
+        function publish(name: string, func: Function): void;
+
+        function _debug(...args: any[]): void;
+    }
+
+    interface Subscription {
+        added(collection: string, id: string, fields: Object): void;
+        changed(collection: string, id: string, fields: Object): void;
+        connection: Meteor.Connection;
+        error(error: Error): void;
+        onStop(func: Function): void;
+        ready(): void;
+        removed(collection: string, id: string): void;
+        stop(): void;
+        userId: string;
+    }
 }
 
 declare module Mongo {
-  interface Selector {
-    [key: string]: any;
-  }
-  interface Selector extends Object {}
-  interface Modifier {}
-  interface SortSpecifier {}
-  interface FieldSpecifier {
-    [id: string]: Number;
-  }
-
-  var Collection: CollectionStatic;
-  interface CollectionStatic {
-    new < T > (name: string, options?: {
-      connection?: Object;
-      idGeneration?: string;
-      transform?: Function;
-    }): Collection < T > ;
-  }
-  interface Collection < T > {
-    allow(options: {
-      insert?: (userId: string, doc: T) => boolean;
-      update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
-      remove?: (userId: string, doc: T) => boolean;
-      fetch?: string[];
-      transform?: Function;
-    }): boolean;
-    deny(options: {
-      insert?: (userId: string, doc: T) => boolean;
-      update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
-      remove?: (userId: string, doc: T) => boolean;
-      fetch?: string[];
-      transform?: Function;
-    }): boolean;
-    find(selector?: Selector | ObjectID | string, options?: {
-      sort?: SortSpecifier;
-      skip?: number;
-      limit?: number;
-      fields?: FieldSpecifier;
-      reactive?: boolean;
-      transform?: Function;
-    }): Cursor < T > ;
-    findOne(selector?: Selector | ObjectID | string, options?: {
-      sort?: SortSpecifier;
-      skip?: number;
-      fields?: FieldSpecifier;
-      reactive?: boolean;
-      transform?: Function;
-    }): T;
-    insert(doc: T, callback?: Function): string;
-    rawCollection(): any;
-    rawDatabase(): any;
-    remove(selector: Selector | ObjectID | string, callback?: Function): number;
-    update(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
-      multi?: boolean;
-      upsert?: boolean;
-    }, callback?: Function): number;
-    upsert(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
-      multi?: boolean;
-    }, callback?: Function): {
-      numberAffected?: number;insertedId?: string;
-    };
-    _ensureIndex(keys: {
-      [key: string]: number | string
-    } | string, options?: {
-      [key: string]: any
-    }): void;
-    _dropIndex(keys: {
-      [key: string]: number | string
-    } | string): void;
-  }
-
-  var Cursor: CursorStatic;
-  interface CursorStatic {
-    new < T > (): Cursor < T > ;
-  }
-  interface ObserveCallbacks {
-    added?(document: Object) : void;
-    addedAt?(document: Object, atIndex: number, before: Object) : void;
-    changed?(newDocument: Object, oldDocument: Object) : void;
-    changedAt?(newDocument: Object, oldDocument: Object, indexAt: number) : void;
-    removed?(oldDocument: Object) : void;
-    removedAt?(oldDocument: Object, atIndex: number) : void;
-    movedTo?(document: Object, fromIndex: number, toIndex: number, before: Object) : void;
-  }
-  interface ObserveChangesCallbacks {
-    added?(id: string, fields: Object) : void;
-    addedBefore?(id: string, fields: Object, before: Object) : void;
-    changed?(id: string, fields: Object) : void;
-    movedBefore?(id: string, before: Object) : void;
-    removed?(id: string) : void;
-  }
-  interface Cursor < T > {
-    count(applySkipLimit?: boolean): number;
-    fetch(): Array < T > ;
-    forEach(callback: < T > (doc: T, index: number, cursor: Cursor < T > ) => void, thisArg?: any): void;
-    map < U > (callback: (doc: T, index: number, cursor: Cursor < T > ) => U, thisArg?: any): Array < U > ;
-    observe(callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
-    observeChanges(callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
-  }
-
-  var ObjectID: ObjectIDStatic;
-  interface ObjectIDStatic {
-    new(hexString?: string): ObjectID;
-  }
-  interface ObjectID {}
-}
-
-declare module "meteor/mongo" {
-  module Mongo {
     interface Selector {
-      [key: string]: any;
+        [key: string]: any;
     }
-    interface Selector extends Object {}
-    interface Modifier {}
-    interface SortSpecifier {}
+    interface Selector extends Object { }
+    interface Modifier { }
+    interface SortSpecifier { }
     interface FieldSpecifier {
-      [id: string]: Number;
+        [id: string]: Number;
     }
 
     var Collection: CollectionStatic;
     interface CollectionStatic {
-      new < T > (name: string, options?: {
-        connection?: Object;
-        idGeneration?: string;
-        transform?: Function;
-      }): Collection < T > ;
+        new <T>(name: string, options?: {
+            connection?: Object;
+            idGeneration?: string;
+            transform?: Function;
+        }): Collection<T>;
     }
-    interface Collection < T > {
-      allow(options: {
-        insert?: (userId: string, doc: T) => boolean;
-        update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
-        remove?: (userId: string, doc: T) => boolean;
-        fetch?: string[];
-        transform?: Function;
-      }): boolean;
-      deny(options: {
-        insert?: (userId: string, doc: T) => boolean;
-        update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
-        remove?: (userId: string, doc: T) => boolean;
-        fetch?: string[];
-        transform?: Function;
-      }): boolean;
-      find(selector?: Selector | ObjectID | string, options?: {
-        sort?: SortSpecifier;
-        skip?: number;
-        limit?: number;
-        fields?: FieldSpecifier;
-        reactive?: boolean;
-        transform?: Function;
-      }): Cursor < T > ;
-      findOne(selector?: Selector | ObjectID | string, options?: {
-        sort?: SortSpecifier;
-        skip?: number;
-        fields?: FieldSpecifier;
-        reactive?: boolean;
-        transform?: Function;
-      }): T;
-      insert(doc: T, callback?: Function): string;
-      rawCollection(): any;
-      rawDatabase(): any;
-      remove(selector: Selector | ObjectID | string, callback?: Function): number;
-      update(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
-        multi?: boolean;
-        upsert?: boolean;
-      }, callback?: Function): number;
-      upsert(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
-        multi?: boolean;
-      }, callback?: Function): {
-        numberAffected?: number;insertedId?: string;
-      };
-      _ensureIndex(keys: {
-        [key: string]: number | string
-      } | string, options?: {
-        [key: string]: any
-      }): void;
-      _dropIndex(keys: {
-        [key: string]: number | string
-      } | string): void;
+    interface Collection<T> {
+        allow(options: {
+            insert?: (userId: string, doc: T) => boolean;
+            update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
+            remove?: (userId: string, doc: T) => boolean;
+            fetch?: string[];
+            transform?: Function;
+        }): boolean;
+        deny(options: {
+            insert?: (userId: string, doc: T) => boolean;
+            update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
+            remove?: (userId: string, doc: T) => boolean;
+            fetch?: string[];
+            transform?: Function;
+        }): boolean;
+        find(selector?: Selector | ObjectID | string, options?: {
+            sort?: SortSpecifier;
+            skip?: number;
+            limit?: number;
+            fields?: FieldSpecifier;
+            reactive?: boolean;
+            transform?: Function;
+        }): Cursor<T>;
+        findOne(selector?: Selector | ObjectID | string, options?: {
+            sort?: SortSpecifier;
+            skip?: number;
+            fields?: FieldSpecifier;
+            reactive?: boolean;
+            transform?: Function;
+        }): T;
+        insert(doc: T, callback?: Function): string;
+        rawCollection(): any;
+        rawDatabase(): any;
+        remove(selector: Selector | ObjectID | string, callback?: Function): number;
+        update(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
+            multi?: boolean;
+            upsert?: boolean;
+        }, callback?: Function): number;
+        upsert(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
+            multi?: boolean;
+        }, callback?: Function): {
+                numberAffected?: number; insertedId?: string;
+            };
+        _ensureIndex(keys: {
+            [key: string]: number | string
+        } | string, options?: {
+            [key: string]: any
+        }): void;
+        _dropIndex(keys: {
+            [key: string]: number | string
+        } | string): void;
     }
 
     var Cursor: CursorStatic;
     interface CursorStatic {
-      new < T > (): Cursor < T > ;
+        new <T>(): Cursor<T>;
     }
     interface ObserveCallbacks {
-      added?(document: Object) : void;
-      addedAt?(document: Object, atIndex: number, before: Object) : void;
-      changed?(newDocument: Object, oldDocument: Object) : void;
-      changedAt?(newDocument: Object, oldDocument: Object, indexAt: number) : void;
-      removed?(oldDocument: Object) : void;
-      removedAt?(oldDocument: Object, atIndex: number) : void;
-      movedTo?(document: Object, fromIndex: number, toIndex: number, before: Object) : void;
+        added?(document: Object): void;
+        addedAt?(document: Object, atIndex: number, before: Object): void;
+        changed?(newDocument: Object, oldDocument: Object): void;
+        changedAt?(newDocument: Object, oldDocument: Object, indexAt: number): void;
+        removed?(oldDocument: Object): void;
+        removedAt?(oldDocument: Object, atIndex: number): void;
+        movedTo?(document: Object, fromIndex: number, toIndex: number, before: Object): void;
     }
     interface ObserveChangesCallbacks {
-      added?(id: string, fields: Object) : void;
-      addedBefore?(id: string, fields: Object, before: Object) : void;
-      changed?(id: string, fields: Object) : void;
-      movedBefore?(id: string, before: Object) : void;
-      removed?(id: string) : void;
+        added?(id: string, fields: Object): void;
+        addedBefore?(id: string, fields: Object, before: Object): void;
+        changed?(id: string, fields: Object): void;
+        movedBefore?(id: string, before: Object): void;
+        removed?(id: string): void;
     }
-    interface Cursor < T > {
-      count(applySkipLimit?: boolean): number;
-      fetch(): Array < T > ;
-      forEach(callback: < T > (doc: T, index: number, cursor: Cursor < T > ) => void, thisArg?: any): void;
-      map < U > (callback: (doc: T, index: number, cursor: Cursor < T > ) => U, thisArg?: any): Array < U > ;
-      observe(callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
-      observeChanges(callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
+    interface Cursor<T> {
+        count(applySkipLimit?: boolean): number;
+        fetch(): Array<T>;
+        forEach(callback: < T > (doc: T, index: number, cursor: Cursor<T>) => void, thisArg?: any): void;
+        map<U>(callback: (doc: T, index: number, cursor: Cursor<T>) => U, thisArg?: any): Array<U>;
+        observe(callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
+        observeChanges(callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
     }
 
     var ObjectID: ObjectIDStatic;
     interface ObjectIDStatic {
-      new(hexString?: string): ObjectID;
+        new (hexString?: string): ObjectID;
     }
-    interface ObjectID {}
-  }
-}
-
-declare module Mongo {
-  interface AllowDenyOptions {
-    insert?: (userId: string, doc: any) => boolean;
-    update?: (userId: string, doc: any, fieldNames: string[], modifier: any) => boolean;
-    remove?: (userId: string, doc: any) => boolean;
-    fetch?: string[];
-    transform?: Function;
-  }
+    interface ObjectID { }
 }
 
 declare module "meteor/mongo" {
-  module Mongo {
-    interface AllowDenyOptions {
-      insert?: (userId: string, doc: any) => boolean;
-      update?: (userId: string, doc: any, fieldNames: string[], modifier: any) => boolean;
-      remove?: (userId: string, doc: any) => boolean;
-      fetch?: string[];
-      transform?: Function;
+    module Mongo {
+        interface Selector {
+            [key: string]: any;
+        }
+        interface Selector extends Object { }
+        interface Modifier { }
+        interface SortSpecifier { }
+        interface FieldSpecifier {
+            [id: string]: Number;
+        }
+
+        var Collection: CollectionStatic;
+        interface CollectionStatic {
+            new <T>(name: string, options?: {
+                connection?: Object;
+                idGeneration?: string;
+                transform?: Function;
+            }): Collection<T>;
+        }
+        interface Collection<T> {
+            allow(options: {
+                insert?: (userId: string, doc: T) => boolean;
+                update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
+                remove?: (userId: string, doc: T) => boolean;
+                fetch?: string[];
+                transform?: Function;
+            }): boolean;
+            deny(options: {
+                insert?: (userId: string, doc: T) => boolean;
+                update?: (userId: string, doc: T, fieldNames: string[], modifier: any) => boolean;
+                remove?: (userId: string, doc: T) => boolean;
+                fetch?: string[];
+                transform?: Function;
+            }): boolean;
+            find(selector?: Selector | ObjectID | string, options?: {
+                sort?: SortSpecifier;
+                skip?: number;
+                limit?: number;
+                fields?: FieldSpecifier;
+                reactive?: boolean;
+                transform?: Function;
+            }): Cursor<T>;
+            findOne(selector?: Selector | ObjectID | string, options?: {
+                sort?: SortSpecifier;
+                skip?: number;
+                fields?: FieldSpecifier;
+                reactive?: boolean;
+                transform?: Function;
+            }): T;
+            insert(doc: T, callback?: Function): string;
+            rawCollection(): any;
+            rawDatabase(): any;
+            remove(selector: Selector | ObjectID | string, callback?: Function): number;
+            update(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
+                multi?: boolean;
+                upsert?: boolean;
+            }, callback?: Function): number;
+            upsert(selector: Selector | ObjectID | string, modifier: Modifier, options?: {
+                multi?: boolean;
+            }, callback?: Function): {
+                    numberAffected?: number; insertedId?: string;
+                };
+            _ensureIndex(keys: {
+                [key: string]: number | string
+            } | string, options?: {
+                [key: string]: any
+            }): void;
+            _dropIndex(keys: {
+                [key: string]: number | string
+            } | string): void;
+        }
+
+        var Cursor: CursorStatic;
+        interface CursorStatic {
+            new <T>(): Cursor<T>;
+        }
+        interface ObserveCallbacks {
+            added?(document: Object): void;
+            addedAt?(document: Object, atIndex: number, before: Object): void;
+            changed?(newDocument: Object, oldDocument: Object): void;
+            changedAt?(newDocument: Object, oldDocument: Object, indexAt: number): void;
+            removed?(oldDocument: Object): void;
+            removedAt?(oldDocument: Object, atIndex: number): void;
+            movedTo?(document: Object, fromIndex: number, toIndex: number, before: Object): void;
+        }
+        interface ObserveChangesCallbacks {
+            added?(id: string, fields: Object): void;
+            addedBefore?(id: string, fields: Object, before: Object): void;
+            changed?(id: string, fields: Object): void;
+            movedBefore?(id: string, before: Object): void;
+            removed?(id: string): void;
+        }
+        interface Cursor<T> {
+            count(applySkipLimit?: boolean): number;
+            fetch(): Array<T>;
+            forEach(callback: < T > (doc: T, index: number, cursor: Cursor<T>) => void, thisArg?: any): void;
+            map<U>(callback: (doc: T, index: number, cursor: Cursor<T>) => U, thisArg?: any): Array<U>;
+            observe(callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
+            observeChanges(callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
+        }
+
+        var ObjectID: ObjectIDStatic;
+        interface ObjectIDStatic {
+            new (hexString?: string): ObjectID;
+        }
+        interface ObjectID { }
+    }
+}
+
+declare module Mongo {
+    interface AllowDenyOptions {
+        insert?: (userId: string, doc: any) => boolean;
+        update?: (userId: string, doc: any, fieldNames: string[], modifier: any) => boolean;
+        remove?: (userId: string, doc: any) => boolean;
+        fetch?: string[];
+        transform?: Function;
+    }
+}
+
+declare module "meteor/mongo" {
+    module Mongo {
+        interface AllowDenyOptions {
+            insert?: (userId: string, doc: any) => boolean;
+            update?: (userId: string, doc: any, fieldNames: string[], modifier: any) => boolean;
+            remove?: (userId: string, doc: any) => boolean;
+            fetch?: string[];
+            transform?: Function;
+        }
     }
-  }
 }
 
 declare module Random {
-  function id(numberOfChars?: number): string;
-
-  function secret(numberOfChars?: number): string;
-
-  function fraction(): number;
-  // @param numberOfDigits, @returns a random hex string of the given length
-  function hexString(numberOfDigits: number): string;
-  // @param array, @return a random element in array
-  function choice(array: any[]): string;
-  // @param str, @return a random char in str
-  function choice(str: string): string;
-}
-
-declare module "meteor/random" {
-  module Random {
     function id(numberOfChars?: number): string;
 
     function secret(numberOfChars?: number): string;
@@ -1672,41 +1657,45 @@ declare module "meteor/random" {
     function choice(array: any[]): string;
     // @param str, @return a random char in str
     function choice(str: string): string;
-  }
+}
+
+declare module "meteor/random" {
+    module Random {
+        function id(numberOfChars?: number): string;
+
+        function secret(numberOfChars?: number): string;
+
+        function fraction(): number;
+        // @param numberOfDigits, @returns a random hex string of the given length
+        function hexString(numberOfDigits: number): string;
+        // @param array, @return a random element in array
+        function choice(array: any[]): string;
+        // @param str, @return a random char in str
+        function choice(str: string): string;
+    }
 }
 
 declare var ReactiveVar: ReactiveVarStatic;
 interface ReactiveVarStatic {
-  new < T > (initialValue: T, equalsFunc?: Function): ReactiveVar < T > ;
+    new <T>(initialValue: T, equalsFunc?: Function): ReactiveVar<T>;
 }
-interface ReactiveVar < T > {
-  get(): T;
-  set(newValue: T): void;
+interface ReactiveVar<T> {
+    get(): T;
+    set(newValue: T): void;
 }
 
 declare module "meteor/reactive-var" {
-  var ReactiveVar: ReactiveVarStatic;
-  interface ReactiveVarStatic {
-    new < T > (initialValue: T, equalsFunc?: Function): ReactiveVar < T > ;
-  }
-  interface ReactiveVar < T > {
-    get(): T;
-    set(newValue: T): void;
-  }
+    var ReactiveVar: ReactiveVarStatic;
+    interface ReactiveVarStatic {
+        new <T>(initialValue: T, equalsFunc?: Function): ReactiveVar<T>;
+    }
+    interface ReactiveVar<T> {
+        get(): T;
+        set(newValue: T): void;
+    }
 }
 
 declare module Session {
-  function equals(key: string, value: string | number | boolean | any): boolean;
-
-  function get(key: string): any;
-
-  function set(key: string, value: EJSONable | any): void;
-
-  function setDefault(key: string, value: EJSONable | any): void;
-}
-
-declare module "meteor/session" {
-  module Session {
     function equals(key: string, value: string | number | boolean | any): boolean;
 
     function get(key: string): any;
@@ -1714,74 +1703,47 @@ declare module "meteor/session" {
     function set(key: string, value: EJSONable | any): void;
 
     function setDefault(key: string, value: EJSONable | any): void;
-  }
+}
+
+declare module "meteor/session" {
+    module Session {
+        function equals(key: string, value: string | number | boolean | any): boolean;
+
+        function get(key: string): any;
+
+        function set(key: string, value: EJSONable | any): void;
+
+        function setDefault(key: string, value: EJSONable | any): void;
+    }
 }
 
 declare var Template: TemplateStatic;
 interface TemplateStatic extends Blaze.TemplateStatic {
-  new(viewName?: string, renderFunction?: Function): Blaze.Template;
-  body: Blaze.Template;
-  [index: string]: any | Blaze.Template;
+    new (viewName?: string, renderFunction?: Function): Blaze.Template;
+    body: Blaze.Template;
+    [index: string]: any | Blaze.Template;
 }
 
 declare module "meteor/templating" {
-  var Template: TemplateStatic;
-  interface TemplateStatic extends Blaze.TemplateStatic {
-    new(viewName?: string, renderFunction?: Function): Blaze.Template;
-    body: Blaze.Template;
-    [index: string]: any | Blaze.Template;
-  }
+    var Template: TemplateStatic;
+    interface TemplateStatic extends Blaze.TemplateStatic {
+        new (viewName?: string, renderFunction?: Function): Blaze.Template;
+        body: Blaze.Template;
+        [index: string]: any | Blaze.Template;
+    }
 }
 
 interface ILengthAble {
-  length: number;
+    length: number;
 }
 
 interface ITinytestAssertions {
-  ok(doc: Object): void;
-  expect_fail(): void;
-  fail(doc: Object): void;
-  runId(): string;
-  equal < T > (actual: T, expected: T, message?: string, not?: boolean): void;
-  notEqual < T > (actual: T, expected: T, message?: string): void;
-  instanceOf(obj: Object, klass: Function, message?: string): void;
-  notInstanceOf(obj: Object, klass: Function, message?: string): void;
-  matches(actual: any, regexp: RegExp, message?: string): void;
-  notMatches(actual: any, regexp: RegExp, message?: string): void;
-  throws(f: Function, expected?: string | RegExp): void;
-  isTrue(v: boolean, msg?: string): void;
-  isFalse(v: boolean, msg?: string): void;
-  isNull(v: any, msg?: string): void;
-  isNotNull(v: any, msg?: string): void;
-  isUndefined(v: any, msg?: string): void;
-  isNotUndefined(v: any, msg?: string): void;
-  isNan(v: any, msg?: string): void;
-  isNotNan(v: any, msg?: string): void;
-  include < T > (s: Array < T > | Object | string, value: any, msg?: string, not?: boolean): void;
-
-  notInclude < T > (s: Array < T > | Object | string, value: any, msg?: string, not?: boolean): void;
-  length(obj: ILengthAble, expected_length: number, msg?: string): void;
-  _stringEqual(actual: string, expected: string, msg?: string): void;
-}
-
-declare module Tinytest {
-  function add(description: string, func: (test: ITinytestAssertions) => void): void;
-
-  function addAsync(description: string, func: (test: ITinytestAssertions) => void): void;
-}
-
-declare module "meteor/tiny-test" {
-  interface ILengthAble {
-    length: number;
-  }
-
-  interface ITinytestAssertions {
     ok(doc: Object): void;
     expect_fail(): void;
     fail(doc: Object): void;
     runId(): string;
-    equal < T > (actual: T, expected: T, message?: string, not?: boolean): void;
-    notEqual < T > (actual: T, expected: T, message?: string): void;
+    equal<T>(actual: T, expected: T, message?: string, not?: boolean): void;
+    notEqual<T>(actual: T, expected: T, message?: string): void;
     instanceOf(obj: Object, klass: Function, message?: string): void;
     notInstanceOf(obj: Object, klass: Function, message?: string): void;
     matches(actual: any, regexp: RegExp, message?: string): void;
@@ -1795,128 +1757,62 @@ declare module "meteor/tiny-test" {
     isNotUndefined(v: any, msg?: string): void;
     isNan(v: any, msg?: string): void;
     isNotNan(v: any, msg?: string): void;
-    include < T > (s: Array < T > | Object | string, value: any, msg?: string, not?: boolean): void;
+    include<T>(s: Array<T> | Object | string, value: any, msg?: string, not?: boolean): void;
 
-    notInclude < T > (s: Array < T > | Object | string, value: any, msg?: string, not?: boolean): void;
+    notInclude<T>(s: Array<T> | Object | string, value: any, msg?: string, not?: boolean): void;
     length(obj: ILengthAble, expected_length: number, msg?: string): void;
     _stringEqual(actual: string, expected: string, msg?: string): void;
-  }
+}
 
-  module Tinytest {
+declare module Tinytest {
     function add(description: string, func: (test: ITinytestAssertions) => void): void;
 
     function addAsync(description: string, func: (test: ITinytestAssertions) => void): void;
-  }
+}
+
+declare module "meteor/tiny-test" {
+    interface ILengthAble {
+        length: number;
+    }
+
+    interface ITinytestAssertions {
+        ok(doc: Object): void;
+        expect_fail(): void;
+        fail(doc: Object): void;
+        runId(): string;
+        equal<T>(actual: T, expected: T, message?: string, not?: boolean): void;
+        notEqual<T>(actual: T, expected: T, message?: string): void;
+        instanceOf(obj: Object, klass: Function, message?: string): void;
+        notInstanceOf(obj: Object, klass: Function, message?: string): void;
+        matches(actual: any, regexp: RegExp, message?: string): void;
+        notMatches(actual: any, regexp: RegExp, message?: string): void;
+        throws(f: Function, expected?: string | RegExp): void;
+        isTrue(v: boolean, msg?: string): void;
+        isFalse(v: boolean, msg?: string): void;
+        isNull(v: any, msg?: string): void;
+        isNotNull(v: any, msg?: string): void;
+        isUndefined(v: any, msg?: string): void;
+        isNotUndefined(v: any, msg?: string): void;
+        isNan(v: any, msg?: string): void;
+        isNotNan(v: any, msg?: string): void;
+        include<T>(s: Array<T> | Object | string, value: any, msg?: string, not?: boolean): void;
+
+        notInclude<T>(s: Array<T> | Object | string, value: any, msg?: string, not?: boolean): void;
+        length(obj: ILengthAble, expected_length: number, msg?: string): void;
+        _stringEqual(actual: string, expected: string, msg?: string): void;
+    }
+
+    module Tinytest {
+        function add(description: string, func: (test: ITinytestAssertions) => void): void;
+
+        function addAsync(description: string, func: (test: ITinytestAssertions) => void): void;
+    }
 }
 
 declare module App {
-  function accessRule(pattern: string, options?: {
-    type?: string;
-    launchExternal?: boolean;
-  }): void;
-
-  function configurePlugin(id: string, config: Object): void;
-
-  function icons(icons: Object): void;
-
-  function info(options: {
-    id?: string;
-    version?: string;
-    name?: string;
-    description?: string;
-    author?: string;
-    email?: string;
-    website?: string;
-  }): void;
-
-  function launchScreens(launchScreens: Object): void;
-
-  function setPreference(name: string, value: string, platform?: string): void;
-}
-
-declare function execFileAsync(command: string, args?: any[], options?: {
-  cwd?: Object;
-  env?: Object;
-  stdio?: any[] | string;
-  destination?: any;
-  waitForClose?: string;
-}): any;
-declare function execFileSync(command: string, args?: any[], options?: {
-  cwd?: Object;
-  env?: Object;
-  stdio?: any[] | string;
-  destination?: any;
-  waitForClose?: string;
-}): String;
-
-declare module Assets {
-  function getBinary(assetPath: string, asyncCallback?: Function): EJSON;
-
-  function getText(assetPath: string, asyncCallback?: Function): string;
-
-  function absoluteFilePath(assetPath: string): string;
-}
-
-declare module Cordova {
-  function depends(dependencies: {
-    [id: string]: string
-  }): void;
-}
-
-declare module Npm {
-  function depends(dependencies: {
-    [id: string]: string
-  }): void;
-
-  function require(name: string): any;
-}
-
-declare namespace Package {
-  function describe(options: {
-    summary?: string;
-    version?: string;
-    name?: string;
-    git?: string;
-    documentation?: string;
-    debugOnly?: boolean;
-    prodOnly?: boolean;
-    testOnly?: boolean;
-  }): void;
-
-  function onTest(func: (api: PackageAPI) => void): void;
-
-  function onUse(func: (api: PackageAPI) => void): void;
-
-  function registerBuildPlugin(options?: {
-    name?: string;
-    use?: string | string[];
-    sources?: string[];
-    npmDependencies?: Object;
-  }): void;
-}
-
-interface PackageAPI {
-  new(): PackageAPI;
-  addAssets(filenames: string | string[], architecture: string | string[]): void;
-  addFiles(filenames: string | string[], architecture?: string | string[], options?: {
-    bare?: boolean;
-  }): void;
-  export (exportedObjects: string | string[], architecture?: string | string[], exportOptions?: Object, testOnly?: boolean): void;
-  imply(packageNames: string | string[], architecture?: string | string[]): void;
-  use(packageNames: string | string[], architecture?: string | string[], options?: {
-    weak?: boolean;
-    unordered?: boolean;
-  }): void;
-  versionsFrom(meteorRelease: string | string[]): void;
-}
-
-declare var console: Console;
-
-declare module "meteor/tools" {
-  module App {
     function accessRule(pattern: string, options?: {
-      type?: string;
-      launchExternal?: boolean;
+        type?: string;
+        launchExternal?: boolean;
     }): void;
 
     function configurePlugin(id: string, config: Object): void;
@@ -1924,68 +1820,67 @@ declare module "meteor/tools" {
     function icons(icons: Object): void;
 
     function info(options: {
-      id?: string;
-      version?: string;
-      name?: string;
-      description?: string;
-      author?: string;
-      email?: string;
-      website?: string;
+        id?: string;
+        version?: string;
+        name?: string;
+        description?: string;
+        author?: string;
+        email?: string;
+        website?: string;
     }): void;
 
     function launchScreens(launchScreens: Object): void;
 
     function setPreference(name: string, value: string, platform?: string): void;
-  }
+}
 
-  function execFileAsync(command: string, args?: any[], options?: {
+declare function execFileAsync(command: string, args?: any[], options?: {
     cwd?: Object;
     env?: Object;
     stdio?: any[] | string;
     destination?: any;
     waitForClose?: string;
-  }): any;
-
-  function execFileSync(command: string, args?: any[], options?: {
+}): any;
+declare function execFileSync(command: string, args?: any[], options?: {
     cwd?: Object;
     env?: Object;
     stdio?: any[] | string;
     destination?: any;
     waitForClose?: string;
-  }): String;
+}): String;
 
-  module Assets {
+declare module Assets {
     function getBinary(assetPath: string, asyncCallback?: Function): EJSON;
 
     function getText(assetPath: string, asyncCallback?: Function): string;
 
     function absoluteFilePath(assetPath: string): string;
-  }
+}
 
-  module Cordova {
+declare module Cordova {
     function depends(dependencies: {
-      [id: string]: string
+        [id: string]: string
     }): void;
-  }
+}
 
-  module Npm {
+declare module Npm {
     function depends(dependencies: {
-      [id: string]: string
+        [id: string]: string
     }): void;
 
     function require(name: string): any;
-  }
+}
 
-  namespace Package {
+declare namespace Package {
     function describe(options: {
-      summary?: string;
-      version?: string;
-      name?: string;
-      git?: string;
-      documentation?: string;
-      debugOnly?: boolean;
-      prodOnly?: boolean;
-      testOnly?: boolean;
+        summary?: string;
+        version?: string;
+        name?: string;
+        git?: string;
+        documentation?: string;
+        debugOnly?: boolean;
+        prodOnly?: boolean;
+        testOnly?: boolean;
     }): void;
 
     function onTest(func: (api: PackageAPI) => void): void;
@@ -1993,91 +1888,157 @@ declare module "meteor/tools" {
     function onUse(func: (api: PackageAPI) => void): void;
 
     function registerBuildPlugin(options?: {
-      name?: string;
-      use?: string | string[];
-      sources?: string[];
-      npmDependencies?: Object;
+        name?: string;
+        use?: string | string[];
+        sources?: string[];
+        npmDependencies?: Object;
     }): void;
-  }
+}
 
-  interface PackageAPI {
-    new(): PackageAPI;
+interface PackageAPI {
+    new (): PackageAPI;
     addAssets(filenames: string | string[], architecture: string | string[]): void;
     addFiles(filenames: string | string[], architecture?: string | string[], options?: {
-      bare?: boolean;
+        bare?: boolean;
     }): void;
-    export (exportedObjects: string | string[], architecture?: string | string[], exportOptions?: Object, testOnly?: boolean): void;
+    export(exportedObjects: string | string[], architecture?: string | string[], exportOptions?: Object, testOnly?: boolean): void;
     imply(packageNames: string | string[], architecture?: string | string[]): void;
     use(packageNames: string | string[], architecture?: string | string[], options?: {
-      weak?: boolean;
-      unordered?: boolean;
+        weak?: boolean;
+        unordered?: boolean;
     }): void;
     versionsFrom(meteorRelease: string | string[]): void;
-  }
+}
 
-  var console: Console;
+declare var console: Console;
+
+declare module "meteor/tools" {
+    module App {
+        function accessRule(pattern: string, options?: {
+            type?: string;
+            launchExternal?: boolean;
+        }): void;
+
+        function configurePlugin(id: string, config: Object): void;
+
+        function icons(icons: Object): void;
+
+        function info(options: {
+            id?: string;
+            version?: string;
+            name?: string;
+            description?: string;
+            author?: string;
+            email?: string;
+            website?: string;
+        }): void;
+
+        function launchScreens(launchScreens: Object): void;
+
+        function setPreference(name: string, value: string, platform?: string): void;
+    }
+
+    function execFileAsync(command: string, args?: any[], options?: {
+        cwd?: Object;
+        env?: Object;
+        stdio?: any[] | string;
+        destination?: any;
+        waitForClose?: string;
+    }): any;
+
+    function execFileSync(command: string, args?: any[], options?: {
+        cwd?: Object;
+        env?: Object;
+        stdio?: any[] | string;
+        destination?: any;
+        waitForClose?: string;
+    }): String;
+
+    module Assets {
+        function getBinary(assetPath: string, asyncCallback?: Function): EJSON;
+
+        function getText(assetPath: string, asyncCallback?: Function): string;
+
+        function absoluteFilePath(assetPath: string): string;
+    }
+
+    module Cordova {
+        function depends(dependencies: {
+            [id: string]: string
+        }): void;
+    }
+
+    module Npm {
+        function depends(dependencies: {
+            [id: string]: string
+        }): void;
+
+        function require(name: string): any;
+    }
+
+    namespace Package {
+        function describe(options: {
+            summary?: string;
+            version?: string;
+            name?: string;
+            git?: string;
+            documentation?: string;
+            debugOnly?: boolean;
+            prodOnly?: boolean;
+            testOnly?: boolean;
+        }): void;
+
+        function onTest(func: (api: PackageAPI) => void): void;
+
+        function onUse(func: (api: PackageAPI) => void): void;
+
+        function registerBuildPlugin(options?: {
+            name?: string;
+            use?: string | string[];
+            sources?: string[];
+            npmDependencies?: Object;
+        }): void;
+    }
+
+    interface PackageAPI {
+        new (): PackageAPI;
+        addAssets(filenames: string | string[], architecture: string | string[]): void;
+        addFiles(filenames: string | string[], architecture?: string | string[], options?: {
+            bare?: boolean;
+        }): void;
+        export(exportedObjects: string | string[], architecture?: string | string[], exportOptions?: Object, testOnly?: boolean): void;
+        imply(packageNames: string | string[], architecture?: string | string[]): void;
+        use(packageNames: string | string[], architecture?: string | string[], options?: {
+            weak?: boolean;
+            unordered?: boolean;
+        }): void;
+        versionsFrom(meteorRelease: string | string[]): void;
+    }
+
+    var console: Console;
 }
 
 declare module Tracker {
-  function Computation(): void;
-  interface Computation {
-    firstRun: boolean;
-    invalidate(): void;
-    invalidated: boolean;
-    onInvalidate(callback: Function): void;
-    onStop(callback: Function): void;
-    stop(): void;
-    stopped: boolean;
-  }
-  var currentComputation: Computation;
-
-  var Dependency: DependencyStatic;
-  interface DependencyStatic {
-    new(): Dependency;
-  }
-  interface Dependency {
-    changed(): void;
-    depend(fromComputation?: Computation): boolean;
-    hasDependents(): boolean;
-  }
-
-  var active: boolean;
-
-  function afterFlush(callback: Function): void;
-
-  function autorun(runFunc: (computation: Computation) => void, options?: {
-    onError?: Function;
-  }): Computation;
-
-  function flush(): void;
-
-  function nonreactive(func: Function): void;
-
-  function onInvalidate(callback: Function): void;
-}
-
-declare module "meteor/tracker" {
-  module Tracker {
     function Computation(): void;
     interface Computation {
-      firstRun: boolean;
-      invalidate(): void;
-      invalidated: boolean;
-      onInvalidate(callback: Function): void;
-      onStop(callback: Function): void;
-      stop(): void;
-      stopped: boolean;
+        firstRun: boolean;
+        invalidate(): void;
+        invalidated: boolean;
+        onInvalidate(callback: Function): void;
+        onStop(callback: Function): void;
+        stop(): void;
+        stopped: boolean;
     }
     var currentComputation: Computation;
 
     var Dependency: DependencyStatic;
     interface DependencyStatic {
-      new(): Dependency;
+        new (): Dependency;
     }
     interface Dependency {
-      changed(): void;
-      depend(fromComputation?: Computation): boolean;
-      hasDependents(): boolean;
+        changed(): void;
+        depend(fromComputation?: Computation): boolean;
+        hasDependents(): boolean;
     }
 
     var active: boolean;
@@ -2085,7 +2046,7 @@ declare module "meteor/tracker" {
     function afterFlush(callback: Function): void;
 
     function autorun(runFunc: (computation: Computation) => void, options?: {
-      onError?: Function;
+        onError?: Function;
     }): Computation;
 
     function flush(): void;
@@ -2093,51 +2054,90 @@ declare module "meteor/tracker" {
     function nonreactive(func: Function): void;
 
     function onInvalidate(callback: Function): void;
-  }
+}
+
+declare module "meteor/tracker" {
+    module Tracker {
+        function Computation(): void;
+        interface Computation {
+            firstRun: boolean;
+            invalidate(): void;
+            invalidated: boolean;
+            onInvalidate(callback: Function): void;
+            onStop(callback: Function): void;
+            stop(): void;
+            stopped: boolean;
+        }
+        var currentComputation: Computation;
+
+        var Dependency: DependencyStatic;
+        interface DependencyStatic {
+            new (): Dependency;
+        }
+        interface Dependency {
+            changed(): void;
+            depend(fromComputation?: Computation): boolean;
+            hasDependents(): boolean;
+        }
+
+        var active: boolean;
+
+        function afterFlush(callback: Function): void;
+
+        function autorun(runFunc: (computation: Computation) => void, options?: {
+            onError?: Function;
+        }): Computation;
+
+        function flush(): void;
+
+        function nonreactive(func: Function): void;
+
+        function onInvalidate(callback: Function): void;
+    }
 }
 
 declare module Match {
-  function Maybe(pattern: any): boolean;
+    function Maybe(pattern: any): boolean;
 }
 
 declare module "meteor/check" {
-  module Match {
-    function Maybe(pattern: any): boolean;
-  }
+    module Match {
+        function Maybe(pattern: any): boolean;
+    }
 }
 
 declare module Meteor {
-  /** Global props **/
-  var isDevelopment: boolean;
-  var isTest: boolean;
-  /** Global props **/
-}
-
-declare module "meteor/meteor" {
-  module Meteor {
     /** Global props **/
     var isDevelopment: boolean;
     var isTest: boolean;
     /** Global props **/
-  }
+}
+
+declare module "meteor/meteor" {
+    module Meteor {
+        /** Global props **/
+        var isDevelopment: boolean;
+        var isTest: boolean;
+        /** Global props **/
+    }
 }
 
 declare module Accounts {
-  function onLogout(func: Function): void;
-}
-
-declare module "meteor/accounts-base" {
-  module Accounts {
     function onLogout(func: Function): void;
-  }
-}
-
-declare module Accounts {
-  function onLogout(func: (user: Meteor.User, connection: Meteor.Connection) => void): void;
 }
 
 declare module "meteor/accounts-base" {
-  module Accounts {
-    function onLogout(func: (user: Meteor.User, connection: Meteor.Connection) => void): void;
-  }
+    module Accounts {
+        function onLogout(func: Function): void;
+    }
+}
+
+declare module Accounts {
+    function onLogout(func: (user: Meteor.User, connection: Meteor.Connection) => void): void;
+}
+
+declare module "meteor/accounts-base" {
+    module Accounts {
+        function onLogout(func: (user: Meteor.User, connection: Meteor.Connection) => void): void;
+    }
 }
diff --git a/meteor/meteor-tests.ts b/meteor/meteor-tests.ts
index 4b59d9cc7a..c269105eb3 100644
--- a/meteor/meteor-tests.ts
+++ b/meteor/meteor-tests.ts
@@ -6,24 +6,24 @@
 
 
 /*********************************** Begin setup for tests ******************************/
-import {Mongo} from "meteor/mongo";
-import {Meteor} from "meteor/meteor";
-import {check, Match} from "meteor/check";
-import {Tracker} from "meteor/tracker";
-import {Template} from "meteor/templating";
-import {Blaze} from "meteor/blaze";
-import {Session} from "meteor/session";
-import {HTTP} from "meteor/http";
-import {ReactiveVar} from "meteor/reactive-var";
-import {Accounts} from "meteor/accounts-base";
-import {BrowserPolicy} from "meteor/browser-policy-common";
-import {DDPRateLimiter} from "meteor/ddp-rate-limiter";
+import { Mongo } from "meteor/mongo";
+import { Meteor } from "meteor/meteor";
+import { check, Match } from "meteor/check";
+import { Tracker } from "meteor/tracker";
+import { Template } from "meteor/templating";
+import { Blaze } from "meteor/blaze";
+import { Session } from "meteor/session";
+import { HTTP } from "meteor/http";
+import { ReactiveVar } from "meteor/reactive-var";
+import { Accounts } from "meteor/accounts-base";
+import { BrowserPolicy } from "meteor/browser-policy-common";
+import { DDPRateLimiter } from "meteor/ddp-rate-limiter";
 
 var Rooms = new Mongo.Collection('rooms');
 var Messages = new Mongo.Collection('messages');
 interface MonkeyDAO {
-  _id: string;
-  name: string;
+    _id: string;
+    name: string;
 }
 var Monkeys = new Mongo.Collection<MonkeyDAO>('monkeys');
 //var x = new Mongo.Collection<xDAO>('x');
@@ -36,68 +36,68 @@ var Monkeys = new Mongo.Collection<MonkeyDAO>('monkeys');
  * Tests Meteor.isServer, Meteor.startup, Collection.insert(), Collection.find()
  */
 if (Meteor.isServer) {
-  Meteor.startup(function () {
-    if (Rooms.find().count() === 0) {
-      Rooms.insert({name: "Initial room"});
-    }
-  });
+    Meteor.startup(function () {
+        if (Rooms.find().count() === 0) {
+            Rooms.insert({ name: "Initial room" });
+        }
+    });
 }
 
 /**
  * From Publish and Subscribe, Meteor.publish section
  **/
 Meteor.publish("rooms", function () {
-  return Rooms.find({}, {fields: {secretInfo: 0}});
+    return Rooms.find({}, { fields: { secretInfo: 0 } });
 });
 
 Meteor.publish("adminSecretInfo", function () {
-  return Rooms.find({admin: this.userId}, {fields: {secretInfo: 1}});
+    return Rooms.find({ admin: this.userId }, { fields: { secretInfo: 1 } });
 });
 
 Meteor.publish("roomAndMessages", function (roomId: string) {
-  check(roomId, String);
-  return [
-    Rooms.find({_id: roomId}, {fields: {secretInfo: 0}}),
-    Messages.find({roomId: roomId})
-  ];
+    check(roomId, String);
+    return [
+        Rooms.find({ _id: roomId }, { fields: { secretInfo: 0 } }),
+        Messages.find({ roomId: roomId })
+    ];
 });
 
 /**
  * Also from Publish and Subscribe, Meteor.publish section
  */
 Meteor.publish("counts-by-room", function (roomId: string) {
-  var self = this;
-  check(roomId, String);
-  var count = 0;
-  var initializing = true;
-  var handle = Messages.find({roomId: roomId}).observeChanges({
-    added: function (id: any) {
-      count++;
-      // if (!initializing)
-      //   this.changed("counts", roomId, {count: count});
-    },
-    removed: function (id: any) {
-      count--;
-// Todo: Not sure how to define in typescript
-//      self.changed("counts", roomId, {count: count});
-    }
-  });
+    var self = this;
+    check(roomId, String);
+    var count = 0;
+    var initializing = true;
+    var handle = Messages.find({ roomId: roomId }).observeChanges({
+        added: function (id: any) {
+            count++;
+            // if (!initializing)
+            //   this.changed("counts", roomId, {count: count});
+        },
+        removed: function (id: any) {
+            count--;
+            // Todo: Not sure how to define in typescript
+            //      self.changed("counts", roomId, {count: count});
+        }
+    });
 
-  initializing = false;
+    initializing = false;
 
-// Todo: Not sure how to define in typescript
-//  self.added("counts", roomId, {count: count});
-  self.ready();
+    // Todo: Not sure how to define in typescript
+    //  self.added("counts", roomId, {count: count});
+    self.ready();
 
-  self.onStop(function () {
-    handle.stop();
-  });
+    self.onStop(function () {
+        handle.stop();
+    });
 });
 
 var Counts = new Mongo.Collection("counts");
 
 Tracker.autorun(function () {
-  Meteor.subscribe("counts-by-room", Session.get("roomId"));
+    Meteor.subscribe("counts-by-room", Session.get("roomId"));
 });
 
 // Checking status
@@ -116,47 +116,47 @@ Meteor.subscribe("allplayers");
  * Also from Meteor.subscribe section
  */
 Tracker.autorun(function () {
-  Meteor.subscribe("chat", {room: Session.get("current-room")});
-  Meteor.subscribe("privateMessages");
+    Meteor.subscribe("chat", { room: Session.get("current-room") });
+    Meteor.subscribe("privateMessages");
 });
 
 /**
  * From Methods, Meteor.methods section
  */
 Meteor.methods({
-  foo: function (arg1: string, arg2: number[]) {
-    check(arg1, String);
-    check(arg2, [Number]);
+    foo: function (arg1: string, arg2: number[]) {
+        check(arg1, String);
+        check(arg2, [Number]);
 
-    var you_want_to_throw_an_error = true;
-    if (you_want_to_throw_an_error)
-      throw new Meteor.Error("404", "Can't find my pants");
-    return "some return value";
-  },
+        var you_want_to_throw_an_error = true;
+        if (you_want_to_throw_an_error)
+            throw new Meteor.Error("404", "Can't find my pants");
+        return "some return value";
+    },
 
-  bar: function () {
-    // .. do other stuff ..
-    return "baz";
-  }
+    bar: function () {
+        // .. do other stuff ..
+        return "baz";
+    }
 });
 
 /**
  * From Methods, Meteor.Error section
  */
 function meteorErrorTestFunction1() {
-  throw new Meteor.Error("logged-out",
-      "The user must be logged in to post a comment.");
+    throw new Meteor.Error("logged-out",
+        "The user must be logged in to post a comment.");
 }
 
 function meteorErrorTestFunction2() {
-  throw new Meteor.Error(403,
-      "The user must be logged in to post a comment.");
+    throw new Meteor.Error(403,
+        "The user must be logged in to post a comment.");
 }
 
 Meteor.call("methodName", function (error: Meteor.Error) {
-  if (error.error === "logged-out") {
-    Session.set("errorMessage", "Please log in to post a comment.");
-  }
+    if (error.error === "logged-out") {
+        Session.set("errorMessage", "Please log in to post a comment.");
+    }
 });
 var error = new Meteor.Error("logged-out", "The user must be logged in to post a comment.");
 console.log(error.error === "logged-out");
@@ -166,7 +166,7 @@ console.log(error.details !== "");
 /**
  * From Methods, Meteor.call section
  */
-Meteor.call('foo', 1, 2, function (error:any, result:any) {} );
+Meteor.call('foo', 1, 2, function (error: any, result: any) { });
 var result = Meteor.call('foo', 1, 2);
 
 /**
@@ -175,22 +175,22 @@ var result = Meteor.call('foo', 1, 2);
 // DA: I added the "var" keyword in there
 
 interface ChatroomsDAO {
-  _id?: string;
+    _id?: string;
 }
 interface MessagesDAO {
-  _id?: string;
+    _id?: string;
 }
 var Chatrooms = new Mongo.Collection<ChatroomsDAO>("chatrooms");
 Messages = new Mongo.Collection<MessagesDAO>("messages");
 
-var myMessages:any[] = Messages.find({userId: Session.get('myUserId')}).fetch();
+var myMessages: any[] = Messages.find({ userId: Session.get('myUserId') }).fetch();
 
-Messages.insert({text: "Hello, world!"});
+Messages.insert({ text: "Hello, world!" });
 
-Messages.update(myMessages[0]._id, {$set: {important: true}});
+Messages.update(myMessages[0]._id, { $set: { important: true } });
 
 var Posts = new Mongo.Collection("posts");
-Posts.insert({title: "Hello world", body: "First post"});
+Posts.insert({ title: "Hello world", body: "First post" });
 
 // Couldn't find assert() in the meteor docs
 //assert(Posts.find().count() === 1);
@@ -206,30 +206,30 @@ Posts.insert({title: "Hello world", body: "First post"});
  **/
 
 class Animal {
-    private sound:string;
-    constructor(doc:any) {
+    private sound: string;
+    constructor(doc: any) {
 
     }
     makeNoise() {
-      console.log(this.sound)
+        console.log(this.sound)
     }
 }
 
 interface AnimalDAO {
-  _id?: string;
-  name: string;
-  sound: string;
-  makeNoise?: () => void;
+    _id?: string;
+    name: string;
+    sound: string;
+    makeNoise?: () => void;
 }
 
 // Define a Collection that uses Animal as its document
 var Animals = new Mongo.Collection<AnimalDAO>("Animals", {
-  transform: function (doc:any): Animal { return new Animal(doc); }
+    transform: function (doc: any): Animal { return new Animal(doc); }
 });
 
 // Create an Animal and call its makeNoise method
-Animals.insert({name: "raptor", sound: "roar"});
-Animals.findOne({name: "raptor"}).makeNoise(); // prints "roar"
+Animals.insert({ name: "raptor", sound: "roar" });
+Animals.findOne({ name: "raptor" }).makeNoise(); // prints "roar"
 
 /**
  * From Collections, Collection.insert section
@@ -238,9 +238,9 @@ Animals.findOne({name: "raptor"}).makeNoise(); // prints "roar"
 var Lists = new Mongo.Collection('Lists');
 var Items = new Mongo.Collection('Lists');
 
-var groceriesId = Lists.insert({name: "Groceries"});
-Items.insert({list: groceriesId, name: "Watercress"});
-Items.insert({list: groceriesId, name: "Persimmons"});
+var groceriesId = Lists.insert({ name: "Groceries" });
+Items.insert({ list: groceriesId, name: "Watercress" });
+Items.insert({ list: groceriesId, name: "Persimmons" });
 
 /**
  * From Collections, collection.update section
@@ -248,39 +248,39 @@ Items.insert({list: groceriesId, name: "Persimmons"});
 var Players = new Mongo.Collection('Players');
 
 Template['adminDashboard'].events({
-  'click .givePoints': function () {
-    Players.update(Session.get("currentPlayer"), {$inc: {score: 5}});
-  }
+    'click .givePoints': function () {
+        Players.update(Session.get("currentPlayer"), { $inc: { score: 5 } });
+    }
 });
 
 /**
  * Also from Collections, collection.update section
  */
 Meteor.methods({
-  declareWinners: function () {
-    Players.update({score: {$gt: 10}},
-        {$addToSet: {badges: "Winner"}},
-        {multi: true});
-  }
+    declareWinners: function () {
+        Players.update({ score: { $gt: 10 } },
+            { $addToSet: { badges: "Winner" } },
+            { multi: true });
+    }
 });
 
 /**
  * From Collections, collection.remove section
  */
 Template['chat'].events({
-  'click .remove': function () {
-    Messages.remove(this._id);
-  }
+    'click .remove': function () {
+        Messages.remove(this._id);
+    }
 });
 
 // DA: I added this next line
 var Logs = new Mongo.Collection('logs');
 
 Meteor.startup(function () {
-  if (Meteor.isServer) {
-    Logs.remove({});
-    Players.remove({karma: {$lt: -2}});
-  }
+    if (Meteor.isServer) {
+        Logs.remove({});
+        Players.remove({ karma: { $lt: -2 } });
+    }
 });
 
 /***
@@ -288,50 +288,50 @@ Meteor.startup(function () {
  */
 
 interface iPost {
-  _id: string;
-  owner: string;
-  userId: string;
-  locked: boolean;
+    _id: string;
+    owner: string;
+    userId: string;
+    locked: boolean;
 }
 
 Posts = new Mongo.Collection<iPost>("posts");
 
 Posts.allow({
-  insert: function (userId:string, doc: iPost) {
-    // the user must be logged in, and the document must be owned by the user
-    return (userId && doc.owner === userId);
-  },
-  update: function (userId:string, doc: iPost, fields:string[], modifier:any) {
-    // can only change your own documents
-    return doc.owner === userId;
-  },
-  remove: function (userId:string, doc: iPost) {
-    // can only remove your own documents
-    return doc.owner === userId;
-  },
-  fetch: ['owner']
+    insert: function (userId: string, doc: iPost) {
+        // the user must be logged in, and the document must be owned by the user
+        return (userId && doc.owner === userId);
+    },
+    update: function (userId: string, doc: iPost, fields: string[], modifier: any) {
+        // can only change your own documents
+        return doc.owner === userId;
+    },
+    remove: function (userId: string, doc: iPost) {
+        // can only remove your own documents
+        return doc.owner === userId;
+    },
+    fetch: ['owner']
 });
 
 Posts.deny({
-  update: function (userId:string, doc: iPost, fields:string[], modifier:any) {
-    // can't change owners
-    return doc.userId !== userId;
-  },
-  remove: function (userId:string, doc: iPost) {
-    // can't remove locked documents
-    return doc.locked;
-  },
-  fetch: ['locked'] // no need to fetch 'owner'
+    update: function (userId: string, doc: iPost, fields: string[], modifier: any) {
+        // can't change owners
+        return doc.userId !== userId;
+    },
+    remove: function (userId: string, doc: iPost) {
+        // can't remove locked documents
+        return doc.locked;
+    },
+    fetch: ['locked'] // no need to fetch 'owner'
 });
 
 /**
  * From Collections, cursor.forEach section
  */
-var topPosts = Posts.find({}, {sort: {score: -1}, limit: 5});
+var topPosts = Posts.find({}, { sort: { score: -1 }, limit: 5 });
 var count = 0;
-topPosts.forEach(function (post:{title:string}) {
-  console.log("Title of post " + count + ": " + post.title);
-  count += 1;
+topPosts.forEach(function (post: { title: string }) {
+    console.log("Title of post " + count + ": " + post.title);
+    count += 1;
 });
 
 /**
@@ -341,28 +341,28 @@ topPosts.forEach(function (post:{title:string}) {
 var Users = new Mongo.Collection('users');
 
 var count1 = 0;
-var query = Users.find({admin: true, onlineNow: true});
+var query = Users.find({ admin: true, onlineNow: true });
 var handle = query.observeChanges({
-  added: function (id:string, user:{name:string}) {
-    count1++;
-    console.log(user.name + " brings the total to " + count1 + " admins.");
-  },
-  removed: function () {
-    count1--;
-    console.log("Lost one. We're now down to " + count1 + " admins.");
-  }
+    added: function (id: string, user: { name: string }) {
+        count1++;
+        console.log(user.name + " brings the total to " + count1 + " admins.");
+    },
+    removed: function () {
+        count1--;
+        console.log("Lost one. We're now down to " + count1 + " admins.");
+    }
 });
 
 let cursor: Mongo.Cursor<Object>;
 
 // After five seconds, stop keeping the count.
-setTimeout(function () {handle.stop();}, 5000);
+setTimeout(function () { handle.stop(); }, 5000);
 
 /**
  * From Sessions, Session.set section
  */
 Tracker.autorun(function () {
-  Meteor.subscribe("chat-history", {room: Session.get("currentRoomId")});
+    Meteor.subscribe("chat-history", { room: Session.get("currentRoomId") });
 });
 
 // Causes the function passed to Tracker.autorun to be re-run, so
@@ -391,59 +391,59 @@ Session.equals("key", value);
  * From Accounts, Meteor.users section
  */
 Meteor.publish("userData", function () {
-  return Meteor.users.find({_id: this.userId},
-      {fields: {'other': 1, 'things': 1}});
+    return Meteor.users.find({ _id: this.userId },
+        { fields: { 'other': 1, 'things': 1 } });
 });
 
-Meteor.users.deny({update: function () { return true; }});
+Meteor.users.deny({ update: function () { return true; } });
 
 /**
  * From Accounts, Meteor.loginWithExternalService section
  */
 Meteor.loginWithGithub({
-  requestPermissions: ['user', 'public_repo']
+    requestPermissions: ['user', 'public_repo']
 }, function (err: Meteor.Error) {
-  if (err)
-    Session.set('errorMessage', err.reason || 'Unknown error');
+    if (err)
+        Session.set('errorMessage', err.reason || 'Unknown error');
 });
 
 /**
  * From Accounts, Accounts.ui.config section
  */
 Accounts.ui.config({
-  requestPermissions: {
-    facebook: ['user_likes'],
-    github: ['user', 'repo']
-  },
-  requestOfflineToken: {
-    google: true
-  },
-  passwordSignupFields: 'USERNAME_AND_OPTIONAL_EMAIL'
+    requestPermissions: {
+        facebook: ['user_likes'],
+        github: ['user', 'repo']
+    },
+    requestOfflineToken: {
+        google: true
+    },
+    passwordSignupFields: 'USERNAME_AND_OPTIONAL_EMAIL'
 });
 
 /**
  * From Accounts, Accounts.validateNewUser section
  */
-Accounts.validateNewUser(function (user:{username:string}) {
-  if (user.username && user.username.length >= 3)
-    return true;
-  throw new Meteor.Error("403", "Username must have at least 3 characters");
+Accounts.validateNewUser(function (user: { username: string }) {
+    if (user.username && user.username.length >= 3)
+        return true;
+    throw new Meteor.Error("403", "Username must have at least 3 characters");
 });
 // Validate username, without a specific error message.
-Accounts.validateNewUser(function (user:{username:string}) {
-  return user.username !== "root";
+Accounts.validateNewUser(function (user: { username: string }) {
+    return user.username !== "root";
 });
 
 /**
  * From Accounts, Accounts.onCreateUser section
  */
-Accounts.onCreateUser(function(options:{profile:any}, user:{profile:any, dexterity:number}) {
-  var d6 = function () { return Math.floor(Math.random() * 6) + 1; };
-  user.dexterity = d6() + d6() + d6();
-  // We still want the default hook's 'profile' behavior.
-  if (options.profile)
-    user.profile = options.profile;
-  return user;
+Accounts.onCreateUser(function (options: { profile: any }, user: { profile: any, dexterity: number }) {
+    var d6 = function () { return Math.floor(Math.random() * 6) + 1; };
+    user.dexterity = d6() + d6() + d6();
+    // We still want the default hook's 'profile' behavior.
+    if (options.profile)
+        user.profile = options.profile;
+    return user;
 });
 
 /**
@@ -451,48 +451,48 @@ Accounts.onCreateUser(function(options:{profile:any}, user:{profile:any, dexteri
  */
 Accounts.emailTemplates.siteName = "AwesomeSite";
 Accounts.emailTemplates.from = "AwesomeSite Admin <accounts@example.com>";
-Accounts.emailTemplates.enrollAccount.subject = function (user:{ profile:{name: string} }) {
-  return "Welcome to Awesome Town, " + user.profile.name;
+Accounts.emailTemplates.enrollAccount.subject = function (user: { profile: { name: string } }) {
+    return "Welcome to Awesome Town, " + user.profile.name;
 };
-Accounts.emailTemplates.enrollAccount.text = function (user:any, url:string) {
-  return "You have been selected to participate in building a better future!"
-      + " To activate your account, simply click the link below:\n\n"
-      + url;
+Accounts.emailTemplates.enrollAccount.text = function (user: any, url: string) {
+    return "You have been selected to participate in building a better future!"
+        + " To activate your account, simply click the link below:\n\n"
+        + url;
 };
 
 /**
  * From Templates, Template.myTemplate.helpers section
  */
 Template['adminDashboard'].helpers({
-  foo: function () {
-    return Session.get("foo");
-  }
+    foo: function () {
+        return Session.get("foo");
+    }
 });
 
 Template['newTemplate'].helpers({
-  helperName: function () {
-  }
+    helperName: function () {
+    }
 });
 
-Template['newTemplate'].created = function() {
+Template['newTemplate'].created = function () {
 
 };
 
-Template['newTemplate'].rendered = function() {
+Template['newTemplate'].rendered = function () {
 
 };
 
-Template['newTemplate'].destroyed = function() {
+Template['newTemplate'].destroyed = function () {
 
 };
 
 Template['newTemplate'].events({
-  'click .something': function (event: Meteor.Event, template: Blaze.TemplateInstance) {
-  }
+    'click .something': function (event: Meteor.Event, template: Blaze.TemplateInstance) {
+    }
 });
 
-Template.registerHelper('testHelper', function() {
-  return 'tester';
+Template.registerHelper('testHelper', function () {
+    return 'tester';
 });
 
 var instance = Template.instance();
@@ -505,23 +505,25 @@ var body = Template.body;
  */
 var Chats = new Mongo.Collection('chats');
 
-Meteor.publish("chats-in-room", function (roomId:string) {
-  // Make sure roomId is a string, not an arbitrary mongo selector object.
-  check(roomId, String);
-  return Chats.find({room: roomId});
+Meteor.publish("chats-in-room", function (roomId: string) {
+    // Make sure roomId is a string, not an arbitrary mongo selector object.
+    check(roomId, String);
+    return Chats.find({ room: roomId });
 });
 
-Meteor.methods({addChat: function (roomId:string, message:{text:string, timestamp:Date, tags:string}) {
-  check(roomId, String);
-  check(message, {
-    text: String,
-    timestamp: Date,
-    // Optional, but if present must be an array of strings.
-    tags: Match.Optional('Test String')
-  });
+Meteor.methods({
+    addChat: function (roomId: string, message: { text: string, timestamp: Date, tags: string }) {
+        check(roomId, String);
+        check(message, {
+            text: String,
+            timestamp: Date,
+            // Optional, but if present must be an array of strings.
+            tags: Match.Optional('Test String')
+        });
 
-  // ... do something with the message ...
-}});
+        // ... do something with the message ...
+    }
+});
 
 /**
  * From Match patterns section
@@ -538,27 +540,27 @@ check(undefined, Match.Optional('test')); // OK
  * From Deps, Tracker.autorun section
  */
 Tracker.autorun(function () {
-  var oldest = Monkeys.findOne('age = 20');
+    var oldest = Monkeys.findOne('age = 20');
 
-  if (oldest)
-    Session.set("oldest", oldest.name);
+    if (oldest)
+        Session.set("oldest", oldest.name);
 });
 
 Tracker.autorun(function (c) {
-  if (! Session.equals("shouldAlert", true))
-    return;
+    if (!Session.equals("shouldAlert", true))
+        return;
 
-  c.stop();
-  alert("Oh no!");
+    c.stop();
+    alert("Oh no!");
 });
 
 /**
  * From Deps, Deps.Computation
  */
 if (Tracker.active) {
-  Tracker.onInvalidate(function () {
-    console.log('invalidated');
-  });
+    Tracker.onInvalidate(function () {
+        console.log('invalidated');
+    });
 }
 
 /**
@@ -568,50 +570,52 @@ var weather = "sunny";
 var weatherDep = new Tracker.Dependency;
 
 var getWeather = function () {
-  weatherDep.depend();
-  return weather;
+    weatherDep.depend();
+    return weather;
 };
 
-var setWeather = function (w:string) {
-  weather = w;
-  // (could add logic here to only call changed()
-  // if the new value is different from the old)
-  weatherDep.changed();
+var setWeather = function (w: string) {
+    weather = w;
+    // (could add logic here to only call changed()
+    // if the new value is different from the old)
+    weatherDep.changed();
 };
 
 /**
  * From HTTP, HTTP.call section
  */
-Meteor.methods({checkTwitter: function (userId:string) {
-  check(userId, String);
-  this.unblock();
-  var result = HTTP.call("GET", "http://api.twitter.com/xyz",
-      {params: {user: userId}});
-  if (result.statusCode === 200)
-    return true
-  return false;
-}});
+Meteor.methods({
+    checkTwitter: function (userId: string) {
+        check(userId, String);
+        this.unblock();
+        var result = HTTP.call("GET", "http://api.twitter.com/xyz",
+            { params: { user: userId } });
+        if (result.statusCode === 200)
+            return true
+        return false;
+    }
+});
 
 
 HTTP.call("POST", "http://api.twitter.com/xyz",
-    {data: {some: "json", stuff: 1}},
-    function (error: Meteor.Error, result:any) {
-      if (result.statusCode === 200) {
-        Session.set("twizzled", true);
-      }
+    { data: { some: "json", stuff: 1 } },
+    function (error: Meteor.Error, result: any) {
+        if (result.statusCode === 200) {
+            Session.set("twizzled", true);
+        }
     });
 
 /**
  * From Email, Email.send section
  */
 Meteor.methods({
-  sendEmail: function (to:string, from:string, subject:string, text:string) {
-    check([to, from, subject, text], [String]);
+    sendEmail: function (to: string, from: string, subject: string, text: string) {
+        check([to, from, subject, text], [String]);
 
-    // Let other method calls from the same client start running,
-    // without waiting for the email sending to complete.
-    this.unblock();
-  }
+        // Let other method calls from the same client start running,
+        // without waiting for the email sending to complete.
+        this.unblock();
+    }
 });
 
 // In your client code: asynchronously send an email
@@ -626,69 +630,69 @@ Blaze.Template.instance();
 
 declare var el: HTMLElement;
 Blaze.render(testTemplate, el);
-Blaze.renderWithData(testTemplate, {testData: 123}, el);
+Blaze.renderWithData(testTemplate, { testData: 123 }, el);
 Blaze.remove(testView);
 Blaze.getData(el);
 Blaze.getData(testView);
 Blaze.toHTML(testTemplate);
 Blaze.toHTML(testView);
-Blaze.toHTMLWithData(testTemplate, {test: 1});
-Blaze.toHTMLWithData(testTemplate, function() {});
-Blaze.toHTMLWithData(testView, {test: 1});
-Blaze.toHTMLWithData(testView, function() {});
+Blaze.toHTMLWithData(testTemplate, { test: 1 });
+Blaze.toHTMLWithData(testTemplate, function () { });
+Blaze.toHTMLWithData(testView, { test: 1 });
+Blaze.toHTMLWithData(testView, function () { });
 
 var reactiveVar1 = new ReactiveVar<string>('test value');
-var reactiveVar2 = new ReactiveVar<string>('test value', function(oldVal:any) { return true; });
+var reactiveVar2 = new ReactiveVar<string>('test value', function (oldVal: any) { return true; });
 
 var varValue: string = reactiveVar1.get();
 reactiveVar1.set('new value');
 
 // Covers this PR:  https://github.com/DefinitelyTyped/DefinitelyTyped/pull/8233
 var isConfigured: boolean = Accounts.loginServicesConfigured();
-Accounts.onPageLoadLogin(function() {
-  // do something
+Accounts.onPageLoadLogin(function () {
+    // do something
 });
 
 // Covers this PR:  https://github.com/DefinitelyTyped/DefinitelyTyped/pull/8065
-var loginOpts = <Meteor.LoginWithExternalServiceOptions> {
-  requestPermissions: ["a", "b"],
-  requestOfflineToken: true,
-  loginUrlParameters: {asdf: 1, qwer: "1234"},
-  loginHint: "Help me",
-  loginStyle: "Bold and powerful",
-  redirectUrl: "popup",
-  profile: "asdfasdf"
+var loginOpts = <Meteor.LoginWithExternalServiceOptions>{
+    requestPermissions: ["a", "b"],
+    requestOfflineToken: true,
+    loginUrlParameters: { asdf: 1, qwer: "1234" },
+    loginHint: "Help me",
+    loginStyle: "Bold and powerful",
+    redirectUrl: "popup",
+    profile: "asdfasdf"
 };
-Meteor.loginWithMeteorDeveloperAccount(loginOpts, function(error: Meteor.Error) {});
+Meteor.loginWithMeteorDeveloperAccount(loginOpts, function (error: Meteor.Error) { });
 
 Accounts.emailTemplates.siteName = "AwesomeSite";
 Accounts.emailTemplates.from = "AwesomeSite Admin <accounts@example.com>";
 Accounts.emailTemplates.headers = { asdf: 'asdf', qwer: 'qwer' };
 
-Accounts.emailTemplates.enrollAccount.subject = function(user: Meteor.User) {
-  return "Welcome to Awesome Town, " + user.profile.name;
+Accounts.emailTemplates.enrollAccount.subject = function (user: Meteor.User) {
+    return "Welcome to Awesome Town, " + user.profile.name;
 };
-Accounts.emailTemplates.enrollAccount.html = function(user: Meteor.User, url: string) {
-  return "<h1>Some html here</h1>";
+Accounts.emailTemplates.enrollAccount.html = function (user: Meteor.User, url: string) {
+    return "<h1>Some html here</h1>";
 };
-Accounts.emailTemplates.enrollAccount.from = function() {
-  return "asdf@asdf.com";
+Accounts.emailTemplates.enrollAccount.from = function () {
+    return "asdf@asdf.com";
 };
-Accounts.emailTemplates.enrollAccount.text = function(user: Meteor.User, url: string) {
-  return "You have been selected to participate in building a better future!"
+Accounts.emailTemplates.enrollAccount.text = function (user: Meteor.User, url: string) {
+    return "You have been selected to participate in building a better future!"
         + " To activate your account, simply click the link below:\n\n"
         + url;
 };
 
-var handle = Accounts.validateLoginAttempt(function(attemptInfoObject: Accounts.IValidateLoginAttemptCbOpts) {
-  var type: string = attemptInfoObject.type;
-  var allowed: boolean = attemptInfoObject.allowed;
-  var error: Meteor.Error = attemptInfoObject.error;
-  var user: Meteor.User = attemptInfoObject.user;
-  var connection: Meteor.Connection = attemptInfoObject.connection;
-  var methodName: string = attemptInfoObject.methodName;
-  var methodArguments: any[] = attemptInfoObject.methodArguments;
-  return true;
+var handle = Accounts.validateLoginAttempt(function (attemptInfoObject: Accounts.IValidateLoginAttemptCbOpts) {
+    var type: string = attemptInfoObject.type;
+    var allowed: boolean = attemptInfoObject.allowed;
+    var error: Meteor.Error = attemptInfoObject.error;
+    var user: Meteor.User = attemptInfoObject.user;
+    var connection: Meteor.Connection = attemptInfoObject.connection;
+    var methodName: string = attemptInfoObject.methodName;
+    var methodArguments: any[] = attemptInfoObject.methodArguments;
+    return true;
 });
 handle.stop();
 
@@ -701,7 +705,7 @@ const deeperPrivateSetting = Meteor.settings['somePrivateSettings']['deeperSetti
 
 
 // Covers https://github.com/meteor-typings/meteor/issues/9
-const username = (<HTMLInputElement> Template.instance().find('#username')).value;
+const username = (<HTMLInputElement>Template.instance().find('#username')).value;
 
 
 // Covers https://github.com/meteor-typings/meteor/issues/3
@@ -711,7 +715,7 @@ BrowserPolicy.content.allowEval();
 
 // Covers https://github.com/meteor-typings/meteor/issues/18
 if (Meteor.isDevelopment) {
-  Rooms._dropIndex({field: 1});
+    Rooms._dropIndex({ field: 1 });
 }
 
 
@@ -721,11 +725,11 @@ Rooms.find().count(true);
 
 // Covers https://github.com/meteor-typings/meteor/issues/21
 if (Meteor.isTest) {
-  // do something
+    // do something
 }
 
 DDPRateLimiter.addRule({ userId: 'foo' }, 5, 1000);
 
-DDPRateLimiter.addRule((userId: string) => userId =='foo', 5, 1000);
+DDPRateLimiter.addRule((userId: string) => userId == 'foo', 5, 1000);
 
-Template.instance().autorun(() => {}).stop();
+Template.instance().autorun(() => { }).stop();