@maka/maka-cli 5.3.0 → 5.3.2

package/bundle/typescript/src/templates/meteor/app/meteor.d.ts

@@ -0,0 +1,954 @@
+/**
+ * These are the common (for client and server) modules and interfaces that can't be automatically generated from the Meteor data.js file
+ */
+
+// Needed for testing.
+declare let require: Function;
+declare let beforeEach: Function;
+declare let afterEach: Function;
+declare let it: Function;
+declare let describe: Function;
+declare let assert: any;
+declare let equal: any;
+declare let Map: MapConstructor;
+declare let Meteor: any;
+
+// TODO: These should be worked out ...
+declare module 'meteor/react-meteor-data';
+declare module 'meteor/mdg:validated-method';
+declare module 'meteor/apollo';
+declare module 'meteor/server-render';
+declare module 'meteor/underscore';
+declare module 'meteor/ddp-rate-limiter';
+declare module 'meteor/check';
+declare module 'meteor/webapp';
+
+interface EJSONable {
+  [key: string]: number | string | boolean | object | number[] | string[] | object[] | Date | Uint8Array | EJSON.CustomType;
+}
+interface JSONable {
+  [key: string]: number | string | boolean | object | number[] | string[] | object[];
+}
+type EJSON = EJSONable
+
+declare module "meteor/match" {
+  export namespace Match {
+    export var Any: any;
+    export var String: any;
+    export var Integer: any;
+    export var Boolean: any;
+    export var undefined: any;
+    //function null();  // not allowed in TypeScript
+    export var Object: any;
+    export function Optional(pattern: any): boolean;
+    export function ObjectIncluding(dico: any): boolean;
+    export function OneOf(...patterns: any[]): any;
+    export function Where(condition: any): any;
+  }
+}
+
+
+declare module "meteor/meteor" {
+  export namespace Meteor {
+    export var isDevelopment: any;
+    export var isServer: any;
+    export var isClient: any;
+
+    interface UserEmail {
+      address: string;
+      verified: boolean;
+    }
+
+    interface User {
+      _id?: string;
+      username?: string;
+      emails?: Meteor.UserEmail[];
+      createdAt?: number;
+      profile?: any;
+      services?: any;
+    }
+
+    enum StatusEnum {
+      connected,
+      connecting,
+      failed,
+      waiting,
+      offline
+    }
+
+    interface LiveQueryHandle {
+      stop(): void;
+    }
+  }
+}
+
+declare module "meteor/ddp" {
+  import { Meteor } from "meteor/meteor";
+
+  export namespace 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;
+    }
+
+    interface DDPStatus {
+      connected: boolean;
+      status: Meteor.StatusEnum;
+      retryCount: number;
+      //To turn this into an interval until the next reconnection, use retryTime - (new Date()).getTime()
+      retryTime?: number;
+      reason?: string;
+    }
+  }
+}
+
+declare module "meteor/mongo" {
+  export namespace Mongo {
+    interface Selector {
+      [key: string]: any;
+    }
+    type Selector = object
+    interface Modifier { }
+    interface SortSpecifier { }
+    interface FieldSpecifier {
+      [id: string]: number;
+    }
+  }
+}
+
+declare module "meteor/http" {
+  export namespace 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;
+  }
+}
+
+declare module "meteor/random" {
+  export namespace Random {
+    function id(numberOfChars?: number): string;
+    function secret(numberOfChars?: number): string;
+    function fraction(): number;
+    function hexString(numberOfDigits: number): string; // @param numberOfDigits, @returns a random hex string of the given length
+    function choice(array: any[]): string; // @param array, @return a random element in array
+    function choice(str: string): string; // @param str, @return a random char in str
+  }
+}
+
+/**
+ * These are the client modules and interfaces that can't be automatically generated from the Meteor data.js file
+ */
+
+declare module "meteor/meteor" {
+  import { Blaze } from "meteor/blaze";
+
+  export namespace Meteor {
+    /** Start definitions for Template **/
+    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;
+    }
+    /** End definitions for Template **/
+
+    interface LoginWithExternalServiceOptions {
+      requestPermissions?: string[];
+      requestOfflineToken?: boolean;
+      forceApprovalPrompt?: boolean;
+      userEmail?: 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;
+
+    interface SubscriptionHandle {
+      stop(): void;
+      ready(): boolean;
+    }
+  }
+}
+
+declare module "meteor/blaze" {
+  export namespace Blaze {
+    interface View {
+      name: string;
+      parentView: Blaze.View;
+      isCreated: boolean;
+      isRendered: boolean;
+      isDestroyed: boolean;
+      renderCount: number;
+      autorun(runFunc: Function): void;
+      onViewCreated(func: Function): void;
+      onViewReady(func: Function): void;
+      onViewDestroyed(func: Function): void;
+      firstNode(): Node;
+      lastNode(): Node;
+      template: Blaze.Template;
+      templateInstance(): any;
+    }
+    interface Template {
+      viewName: string;
+      renderFunction: Function;
+      constructView(): Blaze.View;
+    }
+  }
+}
+
+declare module "meteor/browser-policy" {
+  export namespace BrowserPolicy {
+
+    interface framing {
+      disallow(): void;
+      restrictToOrigin(origin: string): void;
+      allowAll(): void;
+    }
+    interface content {
+      allowEval(): void;
+      allowInlineStyles(): void;
+      allowInlineScripts(): void;
+      allowSameOriginForAll(): void;
+      allowDataUrlForAll(): void;
+      allowOriginForAll(origin: string): void;
+      allowImageOrigin(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;
+      //TODO: add the basic content types
+      // allow<content type>Origin(origin)
+      // allow<content type>DataUrl()
+      // allow<content type>SameOrigin()
+      // disallow<content type>()
+    }
+  }
+}
+
+
+/**
+ * These are the server modules and interfaces that can't be automatically generated from the Meteor data.js file
+ */
+
+declare module "meteor/meteor" {
+  export namespace Meteor {
+    interface EmailFields {
+      subject?: Function;
+      text?: Function;
+    }
+
+    interface EmailTemplates {
+      from: string;
+      siteName: string;
+      resetPassword: Meteor.EmailFields;
+      enrollAccount: Meteor.EmailFields;
+      verifyEmail: Meteor.EmailFields;
+    }
+
+    interface Connection {
+      id: string;
+      close: Function;
+      onClose: Function;
+      clientAddress: string;
+      httpHeaders: object;
+    }
+  }
+}
+
+declare module "meteor/mongo" {
+  export namespace 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 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;
+}
+/**
+ * These are the modules and interfaces for packages that can't be automatically generated from the Meteor data.js file
+ */
+
+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;
+}
+
+declare module "meteor/tiny-test" {
+  export namespace Tinytest {
+    function add(description: string, func: (test: ITinytestAssertions) => void): void;
+    function addAsync(description: string, func: (test: ITinytestAssertions) => void): void;
+  }
+}
+
+
+// Kept in for backwards compatibility
+declare module "meteor/meteor" {
+  export namespace Meteor {
+    interface Tinytest {
+      add(description: string, func: (test: ITinytestAssertions) => void): void;
+      addAsync(description: string, func: (test: ITinytestAssertions) => void): void;
+    }
+  }
+}
+
+declare module "meteor/accounts-base" {
+  import { Meteor } from "meteor/meteor";
+
+  export namespace Accounts {
+    function addEmail(userId: string, newEmail: string, verified?: boolean): void;
+    function changePassword(oldPassword: string, newPassword: string, callback?: Function): void;
+    function createUser(options: {
+      username?: string;
+      email?: string;
+      password?: string;
+      profile?: object;
+    }, callback?: Function): string;
+    var emailTemplates: Meteor.EmailTemplates;
+    function findUserByEmail(email: string): object;
+    function findUserByUsername(username: string): object;
+    function forgotPassword(options: {
+      email?: string;
+    }, callback?: Function): void;
+    function onEmailVerificationLink(callback: Function): void;
+    function onEnrollmentLink(callback: Function): void;
+    function onResetPasswordLink(callback: Function): void;
+    function removeEmail(userId: string, email: string): void;
+    function resetPassword(token: string, newPassword: string, callback?: Function): void;
+    function sendEnrollmentEmail(userId: string, email?: string): void;
+    function sendResetPasswordEmail(userId: string, email?: string): void;
+    function sendVerificationEmail(userId: string, email?: string): void;
+    function setPassword(userId: string, newPassword: string, options?: {
+      logout?: object;
+    }): void;
+    function setUsername(userId: string, newUsername: string): void;
+    var ui: {
+      config(options: {
+        requestPermissions?: object;
+        requestOfflineToken?: object;
+        forceApprovalPrompt?: object;
+        passwordSignupFields?: string;
+      }): void;
+    };
+    function verifyEmail(token: string, callback?: Function): void;
+    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 user(): Meteor.User;
+    function userId(): string;
+    function loggingIn(): boolean;
+    function logout(callback?: Function): void;
+    function logoutOtherClients(callback?: Function): void;
+    function onCreateUser(func: Function): void;
+    function validateLoginAttempt(func: Function): { stop: () => void };
+    function validateNewUser(func: Function): boolean;
+  }
+}
+
+declare namespace App {
+  function accessRule(domainRule: string, options?: {
+    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 namespace Assets {
+  function getBinary(assetPath: string, asyncCallback?: Function): EJSON;
+  function getText(assetPath: string, asyncCallback?: Function): string;
+}
+
+declare module "meteor/blaze" {
+  import { Meteor } from "meteor/meteor";
+  export namespace Blaze {
+    function Each(argFunc: Function, contentFunc: Function, elseFunc?: Function): Blaze.View;
+    function If(conditionFunc: Function, contentFunc: Function, elseFunc?: Function): Blaze.View;
+    function Let(bindings: Function, contentFunc: Function): Blaze.View;
+    var Template: TemplateStatic;
+    interface TemplateStatic {
+      new (viewName?: string, renderFunction?: Function): Template;
+      // It should be [templateName: string]: TemplateInstance but this is not possible -- user will need to cast to TemplateInstance
+      [templateName: string]: any | Template; // added "any" to make it work
+      head: Template;
+      find(selector: string): Blaze.Template;
+      findAll(selector: string): Blaze.Template[];
+      $: any;
+    }
+    interface Template {
+    }
+
+    var TemplateInstance: TemplateInstanceStatic;
+    interface TemplateInstanceStatic {
+      new (view: Blaze.View): TemplateInstance;
+    }
+    interface TemplateInstance {
+      $(selector: string): any;
+      autorun(runFunc: Function): object;
+      data: object;
+      find(selector?: string): Blaze.TemplateInstance;
+      findAll(selector: string): Blaze.TemplateInstance[];
+      firstNode: object;
+      lastNode: object;
+      subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
+      subscriptionsReady(): boolean;
+      view: object;
+    }
+
+    function Unless(conditionFunc: Function, contentFunc: Function, elseFunc?: Function): Blaze.View;
+    var View: ViewStatic;
+    interface ViewStatic {
+      new (name?: string, renderFunction?: Function): View;
+    }
+    interface View {
+    }
+
+    function With(data: object | Function, contentFunc: Function): Blaze.View;
+    var currentView: Blaze.View;
+    function getData(elementOrView?: HTMLElement | Blaze.View): object;
+    function getView(element?: HTMLElement): Blaze.View;
+    function isTemplate(value: any): boolean;
+    function remove(renderedView: Blaze.View): void;
+    function render(templateOrView: Template | Blaze.View, parentNode: Node, nextNode?: Node, parentView?: Blaze.View): Blaze.View;
+    function renderWithData(templateOrView: Template | Blaze.View, data: object | Function, parentNode: Node, nextNode?: Node, parentView?: Blaze.View): Blaze.View;
+    function toHTML(templateOrView: Template | Blaze.View): string;
+    function toHTMLWithData(templateOrView: Template | Blaze.View, data: object | Function): string;
+  }
+}
+
+declare namespace Cordova {
+  function depends(dependencies: { [id: string]: string }): void;
+}
+
+declare module "meteor/ddp" {
+  export namespace DDP {
+    function connect(url: string): DDP.DDPStatic;
+  }
+}
+
+declare namespace DDPCommon {
+  function MethodInvocation(options: {
+  }): any;
+}
+
+declare namespace EJSON {
+  var CustomType: CustomTypeStatic;
+  interface CustomTypeStatic {
+    new (): CustomType;
+  }
+  interface CustomType {
+    clone(): EJSON.CustomType;
+    equals(other: object): boolean;
+    toJSONValue(): JSONable;
+    typeName(): string;
+  }
+
+  function addType(name: string, factory: (val: JSONable) => EJSON.CustomType): 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 namespace Match {
+  function test(value: any, pattern: any): boolean;
+}
+
+declare module "meteor/meteor" {
+  import { Mongo } from "meteor/mongo";
+
+  export namespace Meteor {
+    var Error: ErrorStatic;
+    interface ErrorStatic {
+      new (error: string | number, reason?: string, details?: string): Error;
+    }
+    interface Error {
+      error: string | number;
+      reason?: string;
+      details?: string;
+    }
+    function absoluteUrl(path?: string, options?: {
+      secure?: boolean;
+      replaceLocalhost?: boolean;
+      rootUrl?: string;
+    }): string;
+    function apply(name: string, args: EJSONable[], options?: {
+      wait?: boolean;
+      onResultReceived?: Function;
+    }, asyncCallback?: Function): any;
+    function call(name: string, ...args: any[]): any;
+    function clearInterval(id: number): void;
+    function clearTimeout(id: number): void;
+    function disconnect(): void;
+    var isClient: any;
+    var isCordova: boolean;
+    var isServer: any;
+    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 logout(callback?: Function): void;
+    function logoutOtherClients(callback?: Function): void;
+    function methods(methods: object): void;
+    function onConnection(callback: Function): void;
+    function publish(name: string, func: Function): void;
+    function reconnect(): void;
+    var release: string;
+    function setInterval(func: Function, delay: number): number;
+    function setTimeout(func: Function, delay: number): number;
+    var settings: { [id: string]: any };
+    function startup(func: Function): void;
+    function status(): Meteor.StatusEnum;
+    function subscribe(name: string, ...args: any[]): Meteor.SubscriptionHandle;
+    function user(): Meteor.User;
+    function userId(): string;
+    var users: Mongo.Collection<User>;
+    function wrapAsync(func: Function, context?: object): any;
+  }
+}
+
+declare module "meteor/mongo" {
+  import { Meteor } from "meteor/meteor";
+
+  export namespace Mongo {
+    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?: Mongo.Selector | Mongo.ObjectID | string, options?: {
+        sort?: Mongo.SortSpecifier;
+        skip?: number;
+        limit?: number;
+        fields?: Mongo.FieldSpecifier;
+        reactive?: boolean;
+        transform?: Function;
+      }): Mongo.Cursor<T>;
+      findOne(selector?: Mongo.Selector | Mongo.ObjectID | string, options?: {
+        sort?: Mongo.SortSpecifier;
+        skip?: number;
+        fields?: Mongo.FieldSpecifier;
+        reactive?: boolean;
+        transform?: Function;
+      }): T;
+      insert(doc: T, callback?: Function): string;
+      rawCollection(): any;
+      rawDatabase(): any;
+      remove(selector: Mongo.Selector | Mongo.ObjectID | string, callback?: Function): number;
+      update(selector: Mongo.Selector | Mongo.ObjectID | string, modifier: Mongo.Modifier, options?: {
+        multi?: boolean;
+        upsert?: boolean;
+      }, callback?: Function): number;
+      upsert(selector: Mongo.Selector | Mongo.ObjectID | string, modifier: Mongo.Modifier, options?: {
+        multi?: boolean;
+      }, callback?: Function): { numberAffected?: number; insertedId?: string; };
+      _ensureIndex(indexName: string, options?: { [key: string]: any }): void;
+    }
+
+    var Cursor: CursorStatic;
+    interface CursorStatic {
+      new <T>(): Cursor<T>;
+    }
+    interface Cursor<T> {
+      count(): number;
+      fetch(): Array<T>;
+      forEach(callback: <T>(doc: T, index: number, cursor: Mongo.Cursor<T>) => void, thisArg?: any): void;
+      map<U>(callback: (doc: T, index: number, cursor: Mongo.Cursor<T>) => U, thisArg?: any): Array<U>;
+      observe(callbacks: object): Meteor.LiveQueryHandle;
+      observeChanges(callbacks: object): Meteor.LiveQueryHandle;
+    }
+
+    var ObjectID: ObjectIDStatic;
+    interface ObjectIDStatic {
+      new (hexString?: string): ObjectID;
+    }
+    interface ObjectID {
+    }
+
+  }
+}
+
+declare namespace 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;
+  }): void;
+  function onTest(func: Function): void;
+  function onUse(func: Function): void;
+  function registerBuildPlugin(options?: {
+    name?: string;
+    use?: string | string[];
+    sources?: string[];
+    npmDependencies?: object;
+  }): void;
+}
+
+declare module "meteor/tracker" {
+  export namespace 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 Dependency: DependencyStatic;
+    interface DependencyStatic {
+      new (): Dependency;
+    }
+    interface Dependency {
+      changed(): void;
+      depend(fromComputation?: Tracker.Computation): boolean;
+      hasDependents(): boolean;
+    }
+
+    var active: boolean;
+    function afterFlush(callback: Function): void;
+    function autorun(runFunc: (computation: Tracker.Computation) => void, options?: {
+      onError?: Function;
+    }): Tracker.Computation;
+    var currentComputation: Tracker.Computation;
+    function flush(): void;
+    function nonreactive(func: Function): void;
+    function onInvalidate(callback: Function): void;
+  }
+}
+
+declare namespace Session {
+  function equals(key: string, value: string | number | boolean | any /** Null **/ | any /** Undefined **/): boolean;
+  function get(key: string): any;
+  function set(key: string, value: EJSONable | any /** Undefined **/): void;
+  function setDefault(key: string, value: EJSONable | any /** Undefined **/): void;
+}
+
+declare module "meteor/http" {
+  import { Meteor } from "meteor/meteor";
+  export namespace HTTP {
+
+    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;
+    function del(url: string, callOptions?: object, asyncCallback?: Function): HTTP.HTTPResponse;
+    function get(url: string, callOptions?: object, asyncCallback?: Function): HTTP.HTTPResponse;
+    function post(url: string, callOptions?: object, asyncCallback?: Function): HTTP.HTTPResponse;
+    function put(url: string, callOptions?: object, asyncCallback?: Function): HTTP.HTTPResponse;
+  }
+}
+
+declare module "meteor/email" {
+  export namespace 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;
+  }
+}
+
+declare var CompileStep: CompileStepStatic;
+interface CompileStepStatic {
+  new (): CompileStep;
+}
+interface CompileStep {
+  addAsset(options: {
+  }, path: string, data: any /** Buffer **/ | string): any;
+  addHtml(options: {
+    section?: string;
+    data?: string;
+  }): any;
+  addJavaScript(options: {
+    path?: string;
+    data?: string;
+    sourcePath?: string;
+  }): any;
+  addStylesheet(options: {
+  }, path: string, data: string, sourceMap: string): any;
+  arch: any;
+  declaredExports: any;
+  error(options: {
+  }, message: string, sourcePath?: string, line?: number, func?: string): any;
+  fileOptions: any;
+  fullInputPath: any;
+  inputPath: any;
+  inputSize: any;
+  packageName: any;
+  pathForSourceMap: any;
+  read(n?: number): any;
+  rootOutputPath: any;
+}
+
+declare var PackageAPI: PackageAPIStatic;
+interface PackageAPIStatic {
+  new (): PackageAPI;
+}
+interface 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 module "meteor/reactive-var" {
+  import { Meteor } from "meteor/meteor";
+
+  export var ReactiveVar: ReactiveVarStatic;
+  interface ReactiveVarStatic {
+    new <T>(initialValue: T, equalsFunc?: Function): ReactiveVar<T>;
+  }
+  interface ReactiveVar<T> {
+    get(): T;
+    set(newValue: T): void;
+  }
+
+  export var Subscription: SubscriptionStatic;
+  interface SubscriptionStatic {
+    new (): Subscription;
+  }
+  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/blaze" {
+  import { Meteor } from "meteor/meteor";
+
+  export var Template: TemplateStatic;
+  interface TemplateStatic {
+    new (): Template;
+    // It should be [templateName: string]: TemplateInstance but this is not possible -- user will need to cast to TemplateInstance
+    [templateName: string]: any | Template; // added "any" to make it work
+    head: Template;
+    find(selector: string): Blaze.Template;
+    findAll(selector: string): Blaze.Template[];
+    $: any;
+    body: Template;
+    currentData(): {};
+    instance(): Blaze.TemplateInstance;
+    parentData(numLevels?: number): {};
+    registerHelper(name: string, helperFunction: Function): void;
+  }
+  interface Template {
+    created: Function;
+    destroyed: Function;
+    events(eventMap: Meteor.EventMap): void;
+    helpers(helpers: { [id: string]: any }): void;
+    onCreated: Function;
+    onDestroyed: Function;
+    onRendered: Function;
+    rendered: Function;
+  }
+}
+
+declare function check(value: any, pattern: any): 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 function getExtension(): string;
+