meteor-typings

meteor-typings

Version 1.4.1
Published 8 years ago
No dependencies
MIT license

Install

npm i meteor-typings

yarn add meteor-typings

pnpm add meteor-typings

Overview

Type definitions for Meteor

Index

Variables

variable console

var console: Console;

variable MailComposer

var MailComposer: MailComposerStatic;

variable ReactiveVar

var ReactiveVar: ReactiveVarStatic;

variable Template

var Template: TemplateStatic;

Functions

function check

check: {
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
};

function execFileAsync

execFileAsync: {
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: any[] | string;
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
};

function execFileSync

execFileSync: {
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: any[] | string;
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
};

Namespaces

namespace meteor/accounts-base

module 'meteor/accounts-base' {}

interface URLS

interface URLS {}

property enrollAccount

enrollAccount: (token: string) => string;

property resetPassword

resetPassword: (token: string) => string;

property verifyEmail

verifyEmail: (token: string) => string;

namespace meteor/accounts-base.Accounts

namespace meteor/accounts-base.Accounts {}

variable ui

var ui: {
    config(options: {
        requestPermissions?: Object;
        requestOfflineToken?: Object;
        forceApprovalPrompt?: Object;
        passwordSignupFields?: string;
    }): void;
};

variable urls

var urls: URLS;

function changePassword

changePassword: {
    (oldPassword: string, newPassword: string, callback?: Function): void;
    (oldPassword: string, newPassword: string, callback?: Function): void;
    (oldPassword: string, newPassword: string, callback?: Function): void;
    (oldPassword: string, newPassword: string, callback?: Function): void;
    (oldPassword: string, newPassword: string, callback?: Function): void;
    (oldPassword: string, newPassword: string, callback?: Function): void;
};

function config

config: {
    (options: {
        sendVerificationEmail?: boolean;
        forbidClientAccountCreation?: boolean;
        restrictCreationByEmailDomain?: string | Function;
        loginExpirationInDays?: number;
        oauthSecretKey?: string;
    }): void;
    (options: {
        sendVerificationEmail?: boolean;
        forbidClientAccountCreation?: boolean;
        restrictCreationByEmailDomain?: string | Function;
        loginExpirationInDays?: number;
        oauthSecretKey?: string;
    }): void;
    (options: {
        sendVerificationEmail?: boolean;
        forbidClientAccountCreation?: boolean;
        restrictCreationByEmailDomain?: string | Function;
        loginExpirationInDays?: number;
        oauthSecretKey?: string;
    }): void;
    (options: {
        sendVerificationEmail?: boolean;
        forbidClientAccountCreation?: boolean;
        restrictCreationByEmailDomain?: string | Function;
        loginExpirationInDays?: number;
        oauthSecretKey?: string;
    }): void;
    (options: {
        sendVerificationEmail?: boolean;
        forbidClientAccountCreation?: boolean;
        restrictCreationByEmailDomain?: string | Function;
        loginExpirationInDays?: number;
        oauthSecretKey?: string;
    }): void;
    (options: {
        sendVerificationEmail?: boolean;
        forbidClientAccountCreation?: boolean;
        restrictCreationByEmailDomain?: string | Function;
        loginExpirationInDays?: number;
        oauthSecretKey?: string;
    }): void;
};

function createUser

createUser: {
    (
        options: {
            username?: string;
            email?: string;
            password?: string;
            profile?: Object;
        },
        callback?: Function
    ): string;
    (
        options: {
            username?: string;
            email?: string;
            password?: string;
            profile?: Object;
        },
        callback?: Function
    ): string;
    (
        options: {
            username?: string;
            email?: string;
            password?: string;
            profile?: Object;
        },
        callback?: Function
    ): string;
    (
        options: {
            username?: string;
            email?: string;
            password?: string;
            profile?: Object;
        },
        callback?: Function
    ): string;
    (
        options: {
            username?: string;
            email?: string;
            password?: string;
            profile?: Object;
        },
        callback?: Function
    ): string;
    (
        options: {
            username?: string;
            email?: string;
            password?: string;
            profile?: Object;
        },
        callback?: Function
    ): string;
};

function forgotPassword

forgotPassword: {
    (options: { email?: string }, callback?: Function): void;
    (options: { email?: string }, callback?: Function): void;
    (options: { email?: string }, callback?: Function): void;
    (options: { email?: string }, callback?: Function): void;
    (options: { email?: string }, callback?: Function): void;
    (options: { email?: string }, callback?: Function): void;
};

function loggingIn

loggingIn: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

function loginServicesConfigured

loginServicesConfigured: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

function logout

logout: {
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
};

function logoutOtherClients

logoutOtherClients: {
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
};

function onEmailVerificationLink

onEmailVerificationLink: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

function onEnrollmentLink

onEnrollmentLink: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

function onLogin

onLogin: {
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
};

function onLoginFailure

onLoginFailure: {
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
    (func: Function): { stop: () => void };
};

function onPageLoadLogin

onPageLoadLogin: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

function onResetPasswordLink

onResetPasswordLink: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

function resetPassword

resetPassword: {
    (token: string, newPassword: string, callback?: Function): void;
    (token: string, newPassword: string, callback?: Function): void;
    (token: string, newPassword: string, callback?: Function): void;
    (token: string, newPassword: string, callback?: Function): void;
    (token: string, newPassword: string, callback?: Function): void;
    (token: string, newPassword: string, callback?: Function): void;
};

function user

user: {
    (): Meteor.User;
    (): Meteor.User;
    (): Meteor.User;
    (): Meteor.User;
    (): Meteor.User;
    (): Meteor.User;
};

function userId

userId: {
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
};

function verifyEmail

verifyEmail: {
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
};

namespace meteor/blaze

module 'meteor/blaze' {}

namespace meteor/blaze.Blaze

namespace meteor/blaze.Blaze {}

variable currentView

var currentView: View;

variable Template

var Template: TemplateStatic;

variable TemplateInstance

var TemplateInstance: TemplateInstanceStatic;

variable View

var View: ViewStatic;

function Each

Each: {
    (argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (argFunc: Function, contentFunc: Function, elseFunc?: Function): View;
};

function getData

getData: {
    (elementOrView?: HTMLElement | View): Object;
    (elementOrView?: View | HTMLElement): Object;
    (elementOrView?: View | HTMLElement): Object;
    (elementOrView?: View | HTMLElement): Object;
    (elementOrView?: View | HTMLElement): Object;
    (elementOrView?: View | HTMLElement): Object;
};

function getView

getView: {
    (element?: HTMLElement): View;
    (element?: HTMLElement): View;
    (element?: HTMLElement): View;
    (element?: HTMLElement): View;
    (element?: HTMLElement): View;
    (element?: HTMLElement): View;
};

function If

If: {
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
};

function isTemplate

isTemplate: {
    (value: any): boolean;
    (value: any): boolean;
    (value: any): boolean;
    (value: any): boolean;
    (value: any): boolean;
    (value: any): boolean;
};

function Let

Let: {
    (bindings: Function, contentFunc: Function): View;
    (bindings: Function, contentFunc: Function): View;
    (bindings: Function, contentFunc: Function): View;
    (bindings: Function, contentFunc: Function): View;
    (bindings: Function, contentFunc: Function): View;
    (bindings: Function, contentFunc: Function): View;
};

function remove

remove: {
    (renderedView: View): void;
    (renderedView: View): void;
    (renderedView: View): void;
    (renderedView: View): void;
    (renderedView: View): void;
    (renderedView: View): void;
};

function render

render: {
    (
        templateOrView: Template | View,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
};

function renderWithData

renderWithData: {
    (
        templateOrView: Template | View,
        data: Object | Function,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        data: Object | Function,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        data: Object | Function,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        data: Object | Function,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        data: Object | Function,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
    (
        templateOrView: View | Template,
        data: Object | Function,
        parentNode: Node,
        nextNode?: Node,
        parentView?: View
    ): View;
};

function toHTML

toHTML: {
    (templateOrView: Template | View): string;
    (templateOrView: View | Template): string;
    (templateOrView: View | Template): string;
    (templateOrView: View | Template): string;
    (templateOrView: View | Template): string;
    (templateOrView: View | Template): string;
};

function toHTMLWithData

toHTMLWithData: {
    (templateOrView: Template | View, data: Object | Function): string;
    (templateOrView: View | Template, data: Object | Function): string;
    (templateOrView: View | Template, data: Object | Function): string;
    (templateOrView: View | Template, data: Object | Function): string;
    (templateOrView: View | Template, data: Object | Function): string;
    (templateOrView: View | Template, data: Object | Function): string;
};

function Unless

Unless: {
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
    (conditionFunc: Function, contentFunc: Function, elseFunc?: Function): View;
};

function With

With: {
    (data: Object | Function, contentFunc: Function): View;
    (data: Object | Function, contentFunc: Function): View;
    (data: Object | Function, contentFunc: Function): View;
    (data: Object | Function, contentFunc: Function): View;
    (data: Object | Function, contentFunc: Function): View;
    (data: Object | Function, contentFunc: Function): View;
};

interface EventsMap

interface EventsMap {}

index signature

[key: string]: Function;

interface HelpersMap

interface HelpersMap {}

index signature

[key: string]: Function;

interface Template

interface Template {}

property $

$: any;

property created

created: Function;

property destroyed

destroyed: Function;

property head

head: Template;

property rendered

rendered: Function;

property renderFunction

renderFunction: Function;

property viewName

viewName: string;

method constructView

constructView: { (): View; (): View; (): View; (): View; (): View; (): View };

method events

events: {
    (eventsMap: EventsMap): void;
    (eventsMap: EventsMap): void;
    (eventsMap: EventsMap): void;
    (eventsMap: EventsMap): void;
    (eventsMap: EventsMap): void;
    (eventsMap: EventsMap): void;
};

method find

find: {
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
};

method findAll

findAll: {
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
};

method helpers

helpers: {
    (helpersMap: HelpersMap): void;
    (helpersMap: HelpersMap): void;
    (helpersMap: HelpersMap): void;
    (helpersMap: HelpersMap): void;
    (helpersMap: HelpersMap): void;
    (helpersMap: HelpersMap): void;
};

method onCreated

onCreated: {
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
};

method onDestroyed

onDestroyed: {
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
};

method onRendered

onRendered: {
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
    (cb: Function): void;
};

interface TemplateInstance

interface TemplateInstance {}

property data

data: Object;

property firstNode

firstNode: Object;

property lastNode

lastNode: Object;

property view

view: Object;

method $

$: {
    (selector: string): any;
    (selector: string): any;
    (selector: string): any;
    (selector: string): any;
    (selector: string): any;
    (selector: string): any;
};

method autorun

autorun: {
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
};

method find

find: {
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
    (selector: string): HTMLElement;
};

method findAll

findAll: {
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
    (selector: string): HTMLElement[];
};

subscribe: {
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
};

method subscriptionsReady

subscriptionsReady: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

interface TemplateInstanceStatic

interface TemplateInstanceStatic {}

construct signature

new (view: View): TemplateInstance;

interface TemplateStatic

interface TemplateStatic {}

method currentData

currentData: { (): any; (): any; (): any; (): any; (): any; (): any };

method instance

instance: {
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
};

method parentData

parentData: {
    (numLevels: number): any;
    (numLevels: number): any;
    (numLevels: number): any;
    (numLevels: number): any;
    (numLevels: number): any;
    (numLevels: number): any;
};

method registerHelper

registerHelper: {
    (name: string, func: Function): void;
    (name: string, func: Function): void;
    (name: string, func: Function): void;
    (name: string, func: Function): void;
    (name: string, func: Function): void;
    (name: string, func: Function): void;
};

construct signature

new (viewName?: string, renderFunction?: Function): Template;

interface View

interface View {}

property isCreated

isCreated: boolean;

property isDestroyed

isDestroyed: boolean;

property isRendered

isRendered: boolean;

property name

name: string;

property parentView

parentView: View;

property renderCount

renderCount: number;

property template

template: Template;

method autorun

autorun: {
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
    (runFunc: (computation: Tracker.Computation) => void): Tracker.Computation;
};

method firstNode

firstNode: { (): Node; (): Node; (): Node; (): Node; (): Node; (): Node };

method lastNode

lastNode: { (): Node; (): Node; (): Node; (): Node; (): Node; (): Node };

method onViewCreated

onViewCreated: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

method onViewDestroyed

onViewDestroyed: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

method onViewReady

onViewReady: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

method templateInstance

templateInstance: {
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
    (): TemplateInstance;
};

interface ViewStatic

interface ViewStatic {}

construct signature

new (name?: string, renderFunction?: Function): View;

namespace meteor/browser-policy-common

module 'meteor/browser-policy-common' {}

namespace meteor/browser-policy-common.BrowserPolicy

namespace meteor/browser-policy-common.BrowserPolicy {}

variable content

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;
};

variable framing

var framing: {
    disallow(): void;
    restrictToOrigin(origin: string): void;
    allowAll(): void;
};

namespace meteor/check

module 'meteor/check' {}

function check

check: {
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
    (value: any, pattern: any): void;
};

namespace meteor/check.Match

namespace meteor/check.Match {}

variable Any

var Any: any;

variable Boolean

var Boolean: any;

variable Integer

var Integer: any;

variable Object

var Object: any;

variable String

var String: any;

variable undefined

var undefined: any;

function Maybe

Maybe: {
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
};

function ObjectIncluding

ObjectIncluding: {
    (dico: any): boolean;
    (dico: any): boolean;
    (dico: any): boolean;
    (dico: any): boolean;
    (dico: any): boolean;
    (dico: any): boolean;
};

function OneOf

OneOf: {
    (...patterns: any[]): any;
    (...patterns: any[]): any;
    (...patterns: any[]): any;
    (...patterns: any[]): any;
    (...patterns: any[]): any;
    (...patterns: any[]): any;
};

function Optional

Optional: {
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
    (pattern: any): boolean;
};

function test

test: {
    (value: any, pattern: any): boolean;
    (value: any, pattern: any): boolean;
    (value: any, pattern: any): boolean;
    (value: any, pattern: any): boolean;
    (value: any, pattern: any): boolean;
    (value: any, pattern: any): boolean;
};

function Where

Where: {
    (condition: any): any;
    (condition: any): any;
    (condition: any): any;
    (condition: any): any;
    (condition: any): any;
    (condition: any): any;
};

namespace meteor/ddp

module 'meteor/ddp' {}

namespace meteor/ddp-rate-limiter

module 'meteor/ddp-rate-limiter' {}

namespace meteor/ddp-rate-limiter.DDPRateLimiter

namespace meteor/ddp-rate-limiter.DDPRateLimiter {}

function addRule

addRule: {
    (matcher: Matcher, numRequests: number, timeInterval: number): string;
    (matcher: Matcher, numRequests: number, timeInterval: number): string;
    (matcher: Matcher, numRequests: number, timeInterval: number): string;
    (matcher: Matcher, numRequests: number, timeInterval: number): string;
};

function removeRule

removeRule: {
    (ruleId: string): boolean;
    (ruleId: string): boolean;
    (ruleId: string): boolean;
    (ruleId: string): boolean;
};

interface Matcher

interface Matcher {}

property clientAddress

clientAddress?: string | ((clientAddress: string) => boolean);

property connectionId

connectionId?: string | ((connectionId: string) => boolean);

property name

name?: string | ((name: string) => boolean);

property type

type?: string | ((type: string) => boolean);

property userId

userId?: string | ((userId: string) => boolean);

namespace meteor/ddp.DDP

namespace meteor/ddp.DDP {}

function connect

connect: {
    (url: string): DDPStatic;
    (url: string): DDPStatic;
    (url: string): DDPStatic;
    (url: string): DDPStatic;
    (url: string): DDPStatic;
    (url: string): DDPStatic;
};

interface DDPStatic

interface DDPStatic {}

method apply

apply: {
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
};

method call

call: {
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
    (method: string, ...parameters: any[]): void;
};

method disconnect

disconnect: { (): void; (): void; (): void; (): void; (): void; (): void };

method methods

methods: {
    (IMeteorMethodsDictionary: any): any;
    (IMeteorMethodsDictionary: any): any;
    (IMeteorMethodsDictionary: any): any;
    (IMeteorMethodsDictionary: any): any;
    (IMeteorMethodsDictionary: any): any;
    (IMeteorMethodsDictionary: any): any;
};

method onReconnect

onReconnect: { (): void; (): void; (): void; (): void; (): void; (): void };

method reconnect

reconnect: { (): void; (): void; (): void; (): void; (): void; (): void };

method status

status: {
    (): DDPStatus;
    (): DDPStatus;
    (): DDPStatus;
    (): DDPStatus;
    (): DDPStatus;
    (): DDPStatus;
};

subscribe: {
    (name: string, ...rest: any[]): Meteor.SubscriptionHandle;
    (name: string, ...rest: any[]): Meteor.SubscriptionHandle;
    (name: string, ...rest: any[]): Meteor.SubscriptionHandle;
    (name: string, ...rest: any[]): Meteor.SubscriptionHandle;
    (name: string, ...rest: any[]): Meteor.SubscriptionHandle;
    (name: string, ...rest: any[]): Meteor.SubscriptionHandle;
};

interface DDPStatus

interface DDPStatus {}

property connected

connected: boolean;

property reason

reason?: string;

property retryCount

retryCount: number;

property retryTime

retryTime?: number;

property status

status: Status;

type Status

type Status = 'connected' | 'connecting' | 'failed' | 'waiting' | 'offline';

namespace meteor/ddp.DDPCommon

namespace meteor/ddp.DDPCommon {}

interface MethodInvocation

interface MethodInvocation {}

method setUserId

setUserId: {
    (userId: number): void;
    (userId: number): void;
    (userId: number): void;
    (userId: number): void;
    (userId: number): void;
    (userId: number): void;
};

method unblock

unblock: { (): void; (): void; (): void; (): void; (): void; (): void };

construct signature

new (options: {}): MethodInvocation;

namespace meteor/ejson

module 'meteor/ejson' {}

interface EJSON

interface EJSON extends EJSONable {}

interface EJSONable

interface EJSONable {}

index signature

[key: string]:
    | number
    | string
    | boolean
    | Object
    | number[]
    | string[]
    | Object[]
    | Date
    | Uint8Array
    | EJSONableCustomType;

interface EJSONableCustomType

interface EJSONableCustomType {}

method clone

clone: {
    (): EJSONableCustomType;
    (): EJSONableCustomType;
    (): EJSONableCustomType;
    (): EJSONableCustomType;
    (): EJSONableCustomType;
    (): EJSONableCustomType;
};

method equals

equals: {
    (other: Object): boolean;
    (other: Object): boolean;
    (other: Object): boolean;
    (other: Object): boolean;
    (other: Object): boolean;
    (other: Object): boolean;
};

method toJSONValue

toJSONValue: {
    (): JSONable;
    (): JSONable;
    (): JSONable;
    (): JSONable;
    (): JSONable;
    (): JSONable;
};

method typeName

typeName: {
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
};

interface JSONable

interface JSONable {}

index signature

[key: string]:
    | number
    | string
    | boolean
    | Object
    | number[]
    | string[]
    | Object[];

namespace meteor/ejson.EJSON

namespace meteor/ejson.EJSON {}

variable newBinary

var newBinary: any;

function addType

addType: {
    (name: string, factory: (val: JSONable) => EJSONableCustomType): void;
    (name: string, factory: (val: JSONable) => EJSONableCustomType): void;
    (name: string, factory: (val: JSONable) => EJSONableCustomType): void;
    (name: string, factory: (val: JSONable) => EJSONableCustomType): void;
    (name: string, factory: (val: JSONable) => EJSONableCustomType): void;
    (name: string, factory: (val: JSONable) => EJSONableCustomType): void;
};

function clone

clone: {
    <T>(val: T): T;
    <T>(val: T): T;
    <T>(val: T): T;
    <T>(val: T): T;
    <T>(val: T): T;
    <T>(val: T): T;
};

function equals

equals: {
    (a: EJSON, b: EJSON, options?: { keyOrderSensitive?: boolean }): boolean;
    (a: EJSON, b: EJSON, options?: { keyOrderSensitive?: boolean }): boolean;
    (a: EJSON, b: EJSON, options?: { keyOrderSensitive?: boolean }): boolean;
    (a: EJSON, b: EJSON, options?: { keyOrderSensitive?: boolean }): boolean;
    (a: EJSON, b: EJSON, options?: { keyOrderSensitive?: boolean }): boolean;
    (a: EJSON, b: EJSON, options?: { keyOrderSensitive?: boolean }): boolean;
};

function fromJSONValue

fromJSONValue: {
    (val: JSONable): any;
    (val: JSONable): any;
    (val: JSONable): any;
    (val: JSONable): any;
    (val: JSONable): any;
    (val: JSONable): any;
};

function isBinary

isBinary: {
    (x: Object): boolean;
    (x: Object): boolean;
    (x: Object): boolean;
    (x: Object): boolean;
    (x: Object): boolean;
    (x: Object): boolean;
};

function parse

parse: {
    (str: string): EJSON;
    (str: string): EJSON;
    (str: string): EJSON;
    (str: string): EJSON;
    (str: string): EJSON;
    (str: string): EJSON;
};

function stringify

stringify: {
    (
        val: EJSON,
        options?: { indent?: boolean | number | string; canonical?: boolean }
    ): string;
    (
        val: EJSON,
        options?: { indent?: string | number | boolean; canonical?: boolean }
    ): string;
    (
        val: EJSON,
        options?: { indent?: string | number | boolean; canonical?: boolean }
    ): string;
    (
        val: EJSON,
        options?: { indent?: string | number | boolean; canonical?: boolean }
    ): string;
    (
        val: EJSON,
        options?: { indent?: string | number | boolean; canonical?: boolean }
    ): string;
    (
        val: EJSON,
        options?: { indent?: string | number | boolean; canonical?: boolean }
    ): string;
};

function toJSONValue

toJSONValue: {
    (val: EJSON): JSONable;
    (val: EJSON): JSONable;
    (val: EJSON): JSONable;
    (val: EJSON): JSONable;
    (val: EJSON): JSONable;
    (val: EJSON): JSONable;
};

namespace meteor/email

module 'meteor/email' {}

variable MailComposer

var MailComposer: MailComposerStatic;

interface MailComposer

interface MailComposer {}

method addHeader

addHeader: {
    (name: string, value: string): void;
    (name: string, value: string): void;
    (name: string, value: string): void;
    (name: string, value: string): void;
};

method pipe

pipe: {
    (stream: any): void;
    (stream: any): void;
    (stream: any): void;
    (stream: any): void;
};

method setMessageOption

setMessageOption: {
    (from: string, to: string, body: string, html: string): void;
    (from: string, to: string, body: string, html: string): void;
    (from: string, to: string, body: string, html: string): void;
    (from: string, to: string, body: string, html: string): void;
};

method streamMessage

streamMessage: { (): void; (): void; (): void; (): void };

interface MailComposerOptions

interface MailComposerOptions {}

property charset

charset: string;

property encoding

encoding: string;

property escapeSMTP

escapeSMTP: boolean;

property forceEmbeddedImages

forceEmbeddedImages: boolean;

property keepBcc

keepBcc: boolean;

interface MailComposerStatic

interface MailComposerStatic {}

construct signature

new (options: MailComposerOptions): MailComposer;

namespace meteor/email.Email

namespace meteor/email.Email {}

function send

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;
    (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;
    (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;
    (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;
};

namespace meteor/http

module 'meteor/http' {}

namespace meteor/http.HTTP

namespace meteor/http.HTTP {}

function call

call: {
    (
        method: string,
        url: string,
        options?: HTTP.HTTPRequest,
        asyncCallback?: Function
    ): HTTP.HTTPResponse;
    (
        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
    ): HTTPResponse;
    (
        method: string,
        url: string,
        options?: HTTPRequest,
        asyncCallback?: Function
    ): HTTPResponse;
    (
        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
    ): HTTPResponse;
    (
        method: string,
        url: string,
        options?: HTTPRequest,
        asyncCallback?: Function
    ): HTTPResponse;
    (
        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
    ): HTTPResponse;
    (
        method: string,
        url: string,
        options?: HTTPRequest,
        asyncCallback?: Function
    ): HTTPResponse;
    (
        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
    ): HTTPResponse;
    (
        method: string,
        url: string,
        options?: HTTPRequest,
        asyncCallback?: Function
    ): HTTPResponse;
    (
        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
    ): HTTPResponse;
    (
        method: string,
        url: string,
        options?: HTTPRequest,
        asyncCallback?: Function
    ): HTTPResponse;
    (
        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
    ): HTTPResponse;
};

function del

del: {
    (
        url: string,
        callOptions?: HTTP.HTTPRequest,
        asyncCallback?: Function
    ): HTTP.HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
};

function get

get: {
    (
        url: string,
        callOptions?: HTTP.HTTPRequest,
        asyncCallback?: Function
    ): HTTP.HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
};

function post

post: {
    (
        url: string,
        callOptions?: HTTP.HTTPRequest,
        asyncCallback?: Function
    ): HTTP.HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
};

function put

put: {
    (
        url: string,
        callOptions?: HTTP.HTTPRequest,
        asyncCallback?: Function
    ): HTTP.HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
    (url: string, callOptions?: HTTPRequest, asyncCallback?: Function): HTTPResponse;
};

interface HTTPRequest

interface HTTPRequest {}

property auth

auth?: string;

property content

content?: string;

property data

data?: any;

property followRedirects

followRedirects?: boolean;

property headers

headers?: {
    [id: string]: string;
};

property npmRequestOptions

npmRequestOptions?: Object;

property params

params?: {
    [id: string]: string;
};

property query

query?: string;

property timeout

timeout?: number;

interface HTTPResponse

interface HTTPResponse {}

property content

content?: string;

property data

data?: any;

property headers

headers?: {
    [id: string]: string;
};

property statusCode

statusCode?: number;

namespace meteor/meteor

module 'meteor/meteor' {}

namespace meteor/meteor.Meteor

namespace meteor/meteor.Meteor {}

variable Error

var Error: ErrorStatic;

Error *

variable isClient

var isClient: boolean;

Global props *

variable isCordova

var isCordova: boolean;

variable isDevelopment

var isDevelopment: boolean;

Global props *

variable isProduction

var isProduction: boolean;

variable isServer

var isServer: boolean;

variable isTest

var isTest: boolean;

variable release

var release: string;

variable settings

var settings: Settings;

variable users

var users: Mongo.Collection<User>;

function absoluteUrl

absoluteUrl: {
    (
        path?: string,
        options?: { secure?: boolean; replaceLocalhost?: boolean; rootUrl?: string }
    ): string;
    (
        path?: string,
        options?: { secure?: boolean; replaceLocalhost?: boolean; rootUrl?: string }
    ): string;
    (
        path?: string,
        options?: { secure?: boolean; replaceLocalhost?: boolean; rootUrl?: string }
    ): string;
    (
        path?: string,
        options?: { secure?: boolean; replaceLocalhost?: boolean; rootUrl?: string }
    ): string;
    (
        path?: string,
        options?: { secure?: boolean; replaceLocalhost?: boolean; rootUrl?: string }
    ): string;
    (
        path?: string,
        options?: { secure?: boolean; replaceLocalhost?: boolean; rootUrl?: string }
    ): string;
};

Url *

function apply

apply: {
    (
        name: string,
        args: EJSONable[],
        options?: { wait?: boolean; onResultReceived?: Function },
        asyncCallback?: Function
    ): any;
    (
        name: string,
        args: EJSONable[],
        options?: { wait?: boolean; onResultReceived?: Function },
        asyncCallback?: Function
    ): any;
    (
        name: string,
        args: EJSONable[],
        options?: { wait?: boolean; onResultReceived?: Function },
        asyncCallback?: Function
    ): any;
    (
        name: string,
        args: EJSONable[],
        options?: { wait?: boolean; onResultReceived?: Function },
        asyncCallback?: Function
    ): any;
    (
        name: string,
        args: EJSONable[],
        options?: { wait?: boolean; onResultReceived?: Function },
        asyncCallback?: Function
    ): any;
    (
        name: string,
        args: EJSONable[],
        options?: { wait?: boolean; onResultReceived?: Function },
        asyncCallback?: Function
    ): any;
};

function bindEnvironment

bindEnvironment: {
    (func: Function): any;
    (func: Function): any;
    (func: Function): any;
    (func: Function): any;
    (func: Function): any;
    (func: Function): any;
};

function call

call: {
    (name: string, ...args: any[]): any;
    (name: string, ...args: any[]): any;
    (name: string, ...args: any[]): any;
    (name: string, ...args: any[]): any;
    (name: string, ...args: any[]): any;
    (name: string, ...args: any[]): any;
};

function clearInterval

clearInterval: {
    (id: number): void;
    (id: number): void;
    (id: number): void;
    (id: number): void;
    (id: number): void;
    (id: number): void;
};

function clearTimeout

clearTimeout: {
    (id: number): void;
    (id: number): void;
    (id: number): void;
    (id: number): void;
    (id: number): void;
    (id: number): void;
};

function defer

defer: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

function disconnect

disconnect: { (): void; (): void; (): void; (): void; (): void; (): void };

function loggingIn

loggingIn: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

function loginWith

loginWith: {
    <ExternalService>(
        options?: {
            requestPermissions?: string[];
            requestOfflineToken?: boolean;
            loginUrlParameters?: Object;
            userEmail?: string;
            loginStyle?: string;
            redirectUrl?: string;
        },
        callback?: Function
    ): void;
    <ExternalService>(
        options?: {
            requestPermissions?: string[];
            requestOfflineToken?: boolean;
            loginUrlParameters?: Object;
            userEmail?: string;
            loginStyle?: string;
            redirectUrl?: string;
        },
        callback?: Function
    ): void;
    <ExternalService>(
        options?: {
            requestPermissions?: string[];
            requestOfflineToken?: boolean;
            loginUrlParameters?: Object;
            userEmail?: string;
            loginStyle?: string;
            redirectUrl?: string;
        },
        callback?: Function
    ): void;
    <ExternalService>(
        options?: {
            requestPermissions?: string[];
            requestOfflineToken?: boolean;
            loginUrlParameters?: Object;
            userEmail?: string;
            loginStyle?: string;
            redirectUrl?: string;
        },
        callback?: Function
    ): void;
    <ExternalService>(
        options?: {
            requestPermissions?: string[];
            requestOfflineToken?: boolean;
            loginUrlParameters?: Object;
            userEmail?: string;
            loginStyle?: string;
            redirectUrl?: string;
        },
        callback?: Function
    ): void;
    <ExternalService>(
        options?: {
            requestPermissions?: string[];
            requestOfflineToken?: boolean;
            loginUrlParameters?: Object;
            userEmail?: string;
            loginStyle?: string;
            redirectUrl?: string;
        },
        callback?: Function
    ): void;
};

function loginWithFacebook

loginWithFacebook: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function loginWithGithub

loginWithGithub: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function loginWithGoogle

loginWithGoogle: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function loginWithMeetup

loginWithMeetup: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function loginWithMeteorDeveloperAccount

loginWithMeteorDeveloperAccount: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function loginWithPassword

loginWithPassword: {
    (user: Object | string, password: string, callback?: Function): void;
    (user: string | Object, password: string, callback?: Function): void;
    (user: string | Object, password: string, callback?: Function): void;
    (user: string | Object, password: string, callback?: Function): void;
    (user: string | Object, password: string, callback?: Function): void;
    (user: string | Object, password: string, callback?: Function): void;
};

function loginWithToken

loginWithToken: {
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
    (token: string, callback?: Function): void;
};

function loginWithTwitter

loginWithTwitter: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function loginWithWeibo

loginWithWeibo: {
    (options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
    (options?: LoginWithExternalServiceOptions, callback?: Function): void;
};

function logout

logout: {
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
};

function logoutOtherClients

logoutOtherClients: {
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
    (callback?: Function): void;
};

function methods

methods: {
    (methods: Object): void;
    (methods: Object): void;
    (methods: Object): void;
    (methods: Object): void;
    (methods: Object): void;
    (methods: Object): void;
};

Method *

function reconnect

reconnect: { (): void; (): void; (): void; (): void; (): void; (): void };

Connection *

function setInterval

setInterval: {
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
};

Timeout *

function setTimeout

setTimeout: {
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
    (func: Function, delay: number): number;
};

function startup

startup: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

utils *

function status

status: {
    (): DDP.DDPStatus;
    (): DDP.DDPStatus;
    (): DDP.DDPStatus;
    (): DDP.DDPStatus;
    (): DDP.DDPStatus;
    (): DDP.DDPStatus;
};

Status *

subscribe: {
    (name: string, ...args: any[]): Meteor.SubscriptionHandle;
    (name: string, ...args: any[]): SubscriptionHandle;
    (name: string, ...args: any[]): SubscriptionHandle;
    (name: string, ...args: any[]): SubscriptionHandle;
    (name: string, ...args: any[]): SubscriptionHandle;
    (name: string, ...args: any[]): SubscriptionHandle;
};

Pub/Sub *

function user

user: { (): User; (): User; (): User; (): User; (): User; (): User };

function userId

userId: {
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
};

function wrapAsync

wrapAsync: {
    (func: Function, context?: Object): any;
    (func: Function, context?: Object): any;
    (func: Function, context?: Object): any;
    (func: Function, context?: Object): any;
    (func: Function, context?: Object): any;
    (func: Function, context?: Object): any;
};

interface Error

interface Error {}

property details

details?: string;

property error

error: string | number;

property reason

reason?: string;

interface ErrorStatic

interface ErrorStatic {}

construct signature

new (error: string | number, reason?: string, details?: string): Error;

interface Event

interface Event {}

Event *

property currentTarget

currentTarget: HTMLElement;

property target

target: HTMLElement;

property type

type: string;

property which

which: number;

method isDefaultPrevented

isDefaultPrevented: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

method isImmediatePropagationStopped

isImmediatePropagationStopped: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

method isPropagationStopped

isPropagationStopped: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

method preventDefault

preventDefault: { (): void; (): void; (): void; (): void; (): void; (): void };

method stopImmediatePropagation

stopImmediatePropagation: {
    (): void;
    (): void;
    (): void;
    (): void;
    (): void;
    (): void;
};

method stopPropagation

stopPropagation: { (): void; (): void; (): void; (): void; (): void; (): void };

interface EventHandlerFunction

interface EventHandlerFunction extends Function {}

call signature

(event?: Meteor.Event, templateInstance?: Blaze.TemplateInstance): void;

interface EventMap

interface EventMap {}

index signature

[id: string]: Meteor.EventHandlerFunction;

interface LiveQueryHandle

interface LiveQueryHandle {}

method stop

stop: { (): void; (): void; (): void; (): void; (): void; (): void };

interface LoginWithExternalServiceOptions

interface LoginWithExternalServiceOptions {}

property forceApprovalPrompt

forceApprovalPrompt?: Boolean;

property loginHint

loginHint?: string;

property loginStyle

loginStyle?: string;

property loginUrlParameters

loginUrlParameters?: Object;

property redirectUrl

redirectUrl?: string;

property requestOfflineToken

requestOfflineToken?: Boolean;

property requestPermissions

requestPermissions?: string[];

interface Settings

interface Settings {}

Settings *

property public

public: {
    [id: string]: any;
};

index signature

[id: string]: any;

interface SubscriptionHandle

interface SubscriptionHandle {}

Pub/Sub *

method ready

ready: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

method stop

stop: { (): void; (): void; (): void; (): void; (): void; (): void };

interface User

interface User {}

property createdAt

createdAt?: number;

property emails

emails?: UserEmail[];

property profile

profile?: any;

property services

services?: any;

property username

username?: string;

interface UserEmail

interface UserEmail {}

User *

property address

address: string;

property verified

verified: boolean;

namespace meteor/mongo

module 'meteor/mongo' {}

namespace meteor/mongo.Mongo

namespace meteor/mongo.Mongo {}

variable Collection

var Collection: CollectionStatic;

variable Cursor

var Cursor: CursorStatic;

variable ObjectID

var ObjectID: ObjectIDStatic;

interface Collection

interface Collection<T> {}

method allow

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;
    (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;
    (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;
    (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;
    (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;
    (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;
};

method deny

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;
    (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;
    (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;
    (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;
    (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;
    (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;
};

method find

find: {
    (
        selector?: Selector | ObjectID | string,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            limit?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): Cursor<T>;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            limit?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): Cursor<T>;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            limit?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): Cursor<T>;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            limit?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): Cursor<T>;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            limit?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): Cursor<T>;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            limit?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): Cursor<T>;
};

method findOne

findOne: {
    (
        selector?: Selector | ObjectID | string,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): T;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): T;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): T;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): T;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): T;
    (
        selector?: string | Selector | ObjectID,
        options?: {
            sort?: SortSpecifier;
            skip?: number;
            fields?: FieldSpecifier;
            reactive?: boolean;
            transform?: Function;
        }
    ): T;
};

method insert

insert: {
    (doc: T, callback?: Function): string;
    (doc: T, callback?: Function): string;
    (doc: T, callback?: Function): string;
    (doc: T, callback?: Function): string;
    (doc: T, callback?: Function): string;
    (doc: T, callback?: Function): string;
};

method rawCollection

rawCollection: { (): any; (): any; (): any; (): any; (): any; (): any };

method rawDatabase

rawDatabase: { (): any; (): any; (): any; (): any; (): any; (): any };

method remove

remove: {
    (selector: Selector | ObjectID | string, callback?: Function): number;
    (selector: string | Selector | ObjectID, callback?: Function): number;
    (selector: string | Selector | ObjectID, callback?: Function): number;
    (selector: string | Selector | ObjectID, callback?: Function): number;
    (selector: string | Selector | ObjectID, callback?: Function): number;
    (selector: string | Selector | ObjectID, callback?: Function): number;
};

method update

update: {
    (
        selector: Selector | ObjectID | string,
        modifier: Modifier,
        options?: { multi?: boolean; upsert?: boolean },
        callback?: Function
    ): number;
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean; upsert?: boolean },
        callback?: Function
    ): number;
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean; upsert?: boolean },
        callback?: Function
    ): number;
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean; upsert?: boolean },
        callback?: Function
    ): number;
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean; upsert?: boolean },
        callback?: Function
    ): number;
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean; upsert?: boolean },
        callback?: Function
    ): number;
};

method upsert

upsert: {
    (
        selector: Selector | ObjectID | string,
        modifier: Modifier,
        options?: { multi?: boolean },
        callback?: Function
    ): { numberAffected?: number; insertedId?: string };
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean },
        callback?: Function
    ): { numberAffected?: number; insertedId?: string };
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean },
        callback?: Function
    ): { numberAffected?: number; insertedId?: string };
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean },
        callback?: Function
    ): { numberAffected?: number; insertedId?: string };
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean },
        callback?: Function
    ): { numberAffected?: number; insertedId?: string };
    (
        selector: string | Selector | ObjectID,
        modifier: Modifier,
        options?: { multi?: boolean },
        callback?: Function
    ): { numberAffected?: number; insertedId?: string };
};

interface CollectionStatic

interface CollectionStatic {}

construct signature

new <T>(
    name: string | null,
    options?: {
        connection?: Object;
        idGeneration?: string;
        transform?: Function;
    }
): Collection<T>;

interface Cursor

interface Cursor<T> {}

method count

count: {
    (applySkipLimit?: boolean): number;
    (applySkipLimit?: boolean): number;
    (applySkipLimit?: boolean): number;
    (applySkipLimit?: boolean): number;
    (applySkipLimit?: boolean): number;
    (applySkipLimit?: boolean): number;
};

method fetch

fetch: { (): Array<T>; (): T[]; (): T[]; (): T[]; (): T[]; (): T[] };

method forEach

forEach: {
    (
        callback: (doc: T, index: number, cursor: Cursor<T>) => void,
        thisArg?: any
    ): void;
    (
        callback: (doc: T, index: number, cursor: Cursor<T>) => void,
        thisArg?: any
    ): void;
    (
        callback: (doc: T, index: number, cursor: Cursor<T>) => void,
        thisArg?: any
    ): void;
    (
        callback: (doc: T, index: number, cursor: Cursor<T>) => void,
        thisArg?: any
    ): void;
    (
        callback: (doc: T, index: number, cursor: Cursor<T>) => void,
        thisArg?: any
    ): void;
    (
        callback: (doc: T, index: number, cursor: Cursor<T>) => void,
        thisArg?: any
    ): void;
};

method map

map: {
    <U>(
        callback: (doc: T, index: number, cursor: Cursor<T>) => U,
        thisArg?: any
    ): Array<U>;
    <U>(
        callback: (doc: T, index: number, cursor: Cursor<T>) => U,
        thisArg?: any
    ): U[];
    <U>(
        callback: (doc: T, index: number, cursor: Cursor<T>) => U,
        thisArg?: any
    ): U[];
    <U>(
        callback: (doc: T, index: number, cursor: Cursor<T>) => U,
        thisArg?: any
    ): U[];
    <U>(
        callback: (doc: T, index: number, cursor: Cursor<T>) => U,
        thisArg?: any
    ): U[];
    <U>(
        callback: (doc: T, index: number, cursor: Cursor<T>) => U,
        thisArg?: any
    ): U[];
};

method observe

observe: {
    (callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveCallbacks): Meteor.LiveQueryHandle;
};

method observeChanges

observeChanges: {
    (callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
    (callbacks: ObserveChangesCallbacks): Meteor.LiveQueryHandle;
};

interface CursorStatic

interface CursorStatic {}

construct signature

new <T>(): Cursor<T>;

interface FieldSpecifier

interface FieldSpecifier {}

index signature

[id: string]: Number;

interface Modifier

interface Modifier {}

interface ObjectID

interface ObjectID {}

interface ObjectIDStatic

interface ObjectIDStatic {}

construct signature

new (hexString?: string): ObjectID;

interface ObserveCallbacks

interface ObserveCallbacks {}

method added

added: {
    (document: Object): void;
    (document: Object): void;
    (document: Object): void;
    (document: Object): void;
    (document: Object): void;
    (document: Object): void;
};

method addedAt

addedAt: {
    (document: Object, atIndex: number, before: Object): void;
    (document: Object, atIndex: number, before: Object): void;
    (document: Object, atIndex: number, before: Object): void;
    (document: Object, atIndex: number, before: Object): void;
    (document: Object, atIndex: number, before: Object): void;
    (document: Object, atIndex: number, before: Object): void;
};

method changed

changed: {
    (newDocument: Object, oldDocument: Object): void;
    (newDocument: Object, oldDocument: Object): void;
    (newDocument: Object, oldDocument: Object): void;
    (newDocument: Object, oldDocument: Object): void;
    (newDocument: Object, oldDocument: Object): void;
    (newDocument: Object, oldDocument: Object): void;
};

method changedAt

changedAt: {
    (newDocument: Object, oldDocument: Object, indexAt: number): void;
    (newDocument: Object, oldDocument: Object, indexAt: number): void;
    (newDocument: Object, oldDocument: Object, indexAt: number): void;
    (newDocument: Object, oldDocument: Object, indexAt: number): void;
    (newDocument: Object, oldDocument: Object, indexAt: number): void;
    (newDocument: Object, oldDocument: Object, indexAt: number): void;
};

method movedTo

movedTo: {
    (document: Object, fromIndex: number, toIndex: number, before: Object): void;
    (document: Object, fromIndex: number, toIndex: number, before: Object): void;
    (document: Object, fromIndex: number, toIndex: number, before: Object): void;
    (document: Object, fromIndex: number, toIndex: number, before: Object): void;
    (document: Object, fromIndex: number, toIndex: number, before: Object): void;
    (document: Object, fromIndex: number, toIndex: number, before: Object): void;
};

method removed

removed: {
    (oldDocument: Object): void;
    (oldDocument: Object): void;
    (oldDocument: Object): void;
    (oldDocument: Object): void;
    (oldDocument: Object): void;
    (oldDocument: Object): void;
};

method removedAt

removedAt: {
    (oldDocument: Object, atIndex: number): void;
    (oldDocument: Object, atIndex: number): void;
    (oldDocument: Object, atIndex: number): void;
    (oldDocument: Object, atIndex: number): void;
    (oldDocument: Object, atIndex: number): void;
    (oldDocument: Object, atIndex: number): void;
};

interface ObserveChangesCallbacks

interface ObserveChangesCallbacks {}

method added

added: {
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
};

method addedBefore

addedBefore: {
    (id: string, fields: Object, before: Object): void;
    (id: string, fields: Object, before: Object): void;
    (id: string, fields: Object, before: Object): void;
    (id: string, fields: Object, before: Object): void;
    (id: string, fields: Object, before: Object): void;
    (id: string, fields: Object, before: Object): void;
};

method changed

changed: {
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
    (id: string, fields: Object): void;
};

method movedBefore

movedBefore: {
    (id: string, before: Object): void;
    (id: string, before: Object): void;
    (id: string, before: Object): void;
    (id: string, before: Object): void;
    (id: string, before: Object): void;
    (id: string, before: Object): void;
};

method removed

removed: {
    (id: string): void;
    (id: string): void;
    (id: string): void;
    (id: string): void;
    (id: string): void;
    (id: string): void;
};

interface Selector

interface Selector {}

index signature

[key: string]: any;

interface Selector

interface Selector extends Object {}

interface SortSpecifier

interface SortSpecifier {}

namespace meteor/random

module 'meteor/random' {}

namespace meteor/random.Random

namespace meteor/random.Random {}

function choice

choice: {
    (array: any[]): string;
    (str: string): string;
    (array: any[]): string;
    (str: string): string;
    (array: any[]): string;
    (str: string): string;
    (array: any[]): string;
    (str: string): string;
    (array: any[]): string;
    (str: string): string;
    (array: any[]): string;
    (str: string): string;
};

function fraction

fraction: {
    (): number;
    (): number;
    (): number;
    (): number;
    (): number;
    (): number;
};

function hexString

hexString: {
    (numberOfDigits: number): string;
    (numberOfDigits: number): string;
    (numberOfDigits: number): string;
    (numberOfDigits: number): string;
    (numberOfDigits: number): string;
    (numberOfDigits: number): string;
};

function id

id: {
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
};

function secret

secret: {
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
    (numberOfChars?: number): string;
};

namespace meteor/reactive-var

module 'meteor/reactive-var' {}

variable ReactiveVar

var ReactiveVar: ReactiveVarStatic;

interface ReactiveVar

interface ReactiveVar<T> {}

method get

get: { (): T; (): T; (): T; (): T; (): T; (): T };

method set

set: {
    (newValue: T): void;
    (newValue: T): void;
    (newValue: T): void;
    (newValue: T): void;
    (newValue: T): void;
    (newValue: T): void;
};

interface ReactiveVarStatic

interface ReactiveVarStatic {}

construct signature

new <T>(initialValue: T, equalsFunc?: Function): ReactiveVar<T>;

namespace meteor/session

module 'meteor/session' {}

namespace meteor/session.Session

namespace meteor/session.Session {}

function equals

equals: {
    (key: string, value: string | number | boolean | any): boolean;
    (key: string, value: any): boolean;
    (key: string, value: any): boolean;
    (key: string, value: any): boolean;
    (key: string, value: any): boolean;
    (key: string, value: any): boolean;
};

function get

get: {
    (key: string): any;
    (key: string): any;
    (key: string): any;
    (key: string): any;
    (key: string): any;
    (key: string): any;
};

function set

set: {
    (key: string, value: EJSONable | any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
};

function setDefault

setDefault: {
    (key: string, value: EJSONable | any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
    (key: string, value: any): void;
};

namespace meteor/templating

module 'meteor/templating' {}

variable Template

var Template: TemplateStatic;

interface TemplateStatic

interface TemplateStatic extends Blaze.TemplateStatic {}

property body

body: Blaze.Template;

construct signature

new (viewName?: string, renderFunction?: Function): Blaze.Template;

index signature

[index: string]: any | Blaze.Template;

namespace meteor/tiny-test

module 'meteor/tiny-test' {}

interface ILengthAble

interface ILengthAble {}

property length

length: number;

interface ITinytestAssertions

interface ITinytestAssertions {}

method equal

equal: {
    <T>(actual: T, expected: T, message?: string, not?: boolean): void;
    <T>(actual: T, expected: T, message?: string, not?: boolean): void;
    <T>(actual: T, expected: T, message?: string, not?: boolean): void;
    <T>(actual: T, expected: T, message?: string, not?: boolean): void;
    <T>(actual: T, expected: T, message?: string, not?: boolean): void;
    <T>(actual: T, expected: T, message?: string, not?: boolean): void;
};

method expect_fail

expect_fail: { (): void; (): void; (): void; (): void; (): void; (): void };

method fail

fail: {
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
};

method include

include: {
    <T>(
        s: Array<T> | Object | string,
        value: any,
        msg?: string,
        not?: boolean
    ): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
};

method instanceOf

instanceOf: {
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
};

method isFalse

isFalse: {
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
};

method isNan

isNan: {
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
};

method isNotNan

isNotNan: {
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
};

method isNotNull

isNotNull: {
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
};

method isNotUndefined

isNotUndefined: {
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
};

method isNull

isNull: {
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
};

method isTrue

isTrue: {
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
    (v: boolean, msg?: string): void;
};

method isUndefined

isUndefined: {
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
    (v: any, msg?: string): void;
};

method length

length: {
    (obj: ILengthAble, expected_length: number, msg?: string): void;
    (obj: ILengthAble, expected_length: number, msg?: string): void;
    (obj: ILengthAble, expected_length: number, msg?: string): void;
    (obj: ILengthAble, expected_length: number, msg?: string): void;
    (obj: ILengthAble, expected_length: number, msg?: string): void;
    (obj: ILengthAble, expected_length: number, msg?: string): void;
};

method matches

matches: {
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
};

method notEqual

notEqual: {
    <T>(actual: T, expected: T, message?: string): void;
    <T>(actual: T, expected: T, message?: string): void;
    <T>(actual: T, expected: T, message?: string): void;
    <T>(actual: T, expected: T, message?: string): void;
    <T>(actual: T, expected: T, message?: string): void;
    <T>(actual: T, expected: T, message?: string): void;
};

method notInclude

notInclude: {
    <T>(
        s: Array<T> | Object | string,
        value: any,
        msg?: string,
        not?: boolean
    ): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
    <T>(s: string | Object | T[], value: any, msg?: string, not?: boolean): void;
};

method notInstanceOf

notInstanceOf: {
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
    (obj: Object, klass: Function, message?: string): void;
};

method notMatches

notMatches: {
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
    (actual: any, regexp: RegExp, message?: string): void;
};

method ok

ok: {
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
    (doc: Object): void;
};

method runId

runId: {
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
    (): string;
};

method throws

throws: {
    (f: Function, expected?: string | RegExp): void;
    (f: Function, expected?: string | RegExp): void;
    (f: Function, expected?: string | RegExp): void;
    (f: Function, expected?: string | RegExp): void;
    (f: Function, expected?: string | RegExp): void;
    (f: Function, expected?: string | RegExp): void;
};

namespace meteor/tiny-test.Tinytest

namespace meteor/tiny-test.Tinytest {}

function add

add: {
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
};

function addAsync

addAsync: {
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
    (description: string, func: (test: ITinytestAssertions) => void): void;
};

namespace meteor/tools

module 'meteor/tools' {}

variable console

var console: Console;

function execFileAsync

execFileAsync: {
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: any[] | string;
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): any;
};

function execFileSync

execFileSync: {
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: any[] | string;
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
    (
        command: string,
        args?: any[],
        options?: {
            cwd?: Object;
            env?: Object;
            stdio?: string | any[];
            destination?: any;
            waitForClose?: string;
        }
    ): String;
};

interface PackageAPI

interface PackageAPI {}

method addAssets

addAssets: {
    (filenames: string | string[], architecture: string | string[]): void;
    (filenames: string | string[], architecture: string | string[]): void;
    (filenames: string | string[], architecture: string | string[]): void;
    (filenames: string | string[], architecture: string | string[]): void;
};

method addFiles

addFiles: {
    (
        filenames: string | string[],
        architecture?: string | string[],
        options?: { bare?: boolean }
    ): void;
    (
        filenames: string | string[],
        architecture?: string | string[],
        options?: { bare?: boolean }
    ): void;
    (
        filenames: string | string[],
        architecture?: string | string[],
        options?: { bare?: boolean }
    ): void;
    (
        filenames: string | string[],
        architecture?: string | string[],
        options?: { bare?: boolean }
    ): void;
};

method export

export: {
    (
        exportedObjects: string | string[],
        architecture?: string | string[],
        exportOptions?: Object,
        testOnly?: boolean
    ): void;
    (
        exportedObjects: string | string[],
        architecture?: string | string[],
        exportOptions?: Object,
        testOnly?: boolean
    ): void;
    (
        exportedObjects: string | string[],
        architecture?: string | string[],
        exportOptions?: Object,
        testOnly?: boolean
    ): void;
    (
        exportedObjects: string | string[],
        architecture?: string | string[],
        exportOptions?: Object,
        testOnly?: boolean
    ): void;
};

method imply

imply: {
    (packageNames: string | string[], architecture?: string | string[]): void;
    (packageNames: string | string[], architecture?: string | string[]): void;
    (packageNames: string | string[], architecture?: string | string[]): void;
    (packageNames: string | string[], architecture?: string | string[]): void;
};

method use

use: {
    (
        packageNames: string | string[],
        architecture?: string | string[],
        options?: { weak?: boolean; unordered?: boolean }
    ): void;
    (
        packageNames: string | string[],
        architecture?: string | string[],
        options?: { weak?: boolean; unordered?: boolean }
    ): void;
    (
        packageNames: string | string[],
        architecture?: string | string[],
        options?: { weak?: boolean; unordered?: boolean }
    ): void;
    (
        packageNames: string | string[],
        architecture?: string | string[],
        options?: { weak?: boolean; unordered?: boolean }
    ): void;
};

method versionsFrom

versionsFrom: {
    (meteorRelease: string | string[]): void;
    (meteorRelease: string | string[]): void;
    (meteorRelease: string | string[]): void;
    (meteorRelease: string | string[]): void;
};

construct signature

new (): PackageAPI;

namespace meteor/tools.App

namespace meteor/tools.App {}

function accessRule

accessRule: {
    (pattern: string, options?: { type?: string; launchExternal?: boolean }): void;
    (pattern: string, options?: { type?: string; launchExternal?: boolean }): void;
    (pattern: string, options?: { type?: string; launchExternal?: boolean }): void;
    (pattern: string, options?: { type?: string; launchExternal?: boolean }): void;
};

function configurePlugin

configurePlugin: {
    (id: string, config: Object): void;
    (id: string, config: Object): void;
    (id: string, config: Object): void;
    (id: string, config: Object): void;
};

function icons

icons: {
    (icons: Object): void;
    (icons: Object): void;
    (icons: Object): void;
    (icons: Object): void;
};

function info

info: {
    (options: {
        id?: string;
        version?: string;
        name?: string;
        description?: string;
        author?: string;
        email?: string;
        website?: string;
    }): void;
    (options: {
        id?: string;
        version?: string;
        name?: string;
        description?: string;
        author?: string;
        email?: string;
        website?: string;
    }): void;
    (options: {
        id?: string;
        version?: string;
        name?: string;
        description?: string;
        author?: string;
        email?: string;
        website?: string;
    }): void;
    (options: {
        id?: string;
        version?: string;
        name?: string;
        description?: string;
        author?: string;
        email?: string;
        website?: string;
    }): void;
};

function launchScreens

launchScreens: {
    (launchScreens: Object): void;
    (launchScreens: Object): void;
    (launchScreens: Object): void;
    (launchScreens: Object): void;
};

function setPreference

setPreference: {
    (name: string, value: string, platform?: string): void;
    (name: string, value: string, platform?: string): void;
    (name: string, value: string, platform?: string): void;
    (name: string, value: string, platform?: string): void;
};

namespace meteor/tools.Assets

namespace meteor/tools.Assets {}

function absoluteFilePath

absoluteFilePath: {
    (assetPath: string): string;
    (assetPath: string): string;
    (assetPath: string): string;
    (assetPath: string): string;
};

function getBinary

getBinary: {
    (assetPath: string, asyncCallback?: Function): EJSON;
    (assetPath: string, asyncCallback?: Function): EJSON;
    (assetPath: string, asyncCallback?: Function): EJSON;
    (assetPath: string, asyncCallback?: Function): EJSON;
};

function getText

getText: {
    (assetPath: string, asyncCallback?: Function): string;
    (assetPath: string, asyncCallback?: Function): string;
    (assetPath: string, asyncCallback?: Function): string;
    (assetPath: string, asyncCallback?: Function): string;
};

namespace meteor/tools.Cordova

namespace meteor/tools.Cordova {}

function depends

depends: {
    (dependencies: { [id: string]: string }): void;
    (dependencies: { [id: string]: string }): void;
    (dependencies: { [id: string]: string }): void;
    (dependencies: { [id: string]: string }): void;
};

namespace meteor/tools.Npm

namespace meteor/tools.Npm {}

function depends

depends: {
    (dependencies: { [id: string]: string }): void;
    (dependencies: { [id: string]: string }): void;
    (dependencies: { [id: string]: string }): void;
    (dependencies: { [id: string]: string }): void;
};

function require

require: {
    (name: string): any;
    (name: string): any;
    (name: string): any;
    (name: string): any;
};

namespace meteor/tools.Package

namespace meteor/tools.Package {}

function describe

describe: {
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
};

function onTest

onTest: {
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
};

function onUse

onUse: {
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
};

function registerBuildPlugin

registerBuildPlugin: {
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
};

namespace meteor/tracker

module 'meteor/tracker' {}

namespace meteor/tracker.Tracker

namespace meteor/tracker.Tracker {}

variable active

var active: boolean;

variable currentComputation

var currentComputation: Computation;

variable Dependency

var Dependency: DependencyStatic;

function afterFlush

afterFlush: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

function autorun

autorun: {
    (
        runFunc: (computation: Computation) => void,
        options?: { onError?: Function }
    ): Computation;
    (
        runFunc: (computation: Computation) => void,
        options?: { onError?: Function }
    ): Computation;
    (
        runFunc: (computation: Computation) => void,
        options?: { onError?: Function }
    ): Computation;
    (
        runFunc: (computation: Computation) => void,
        options?: { onError?: Function }
    ): Computation;
    (
        runFunc: (computation: Computation) => void,
        options?: { onError?: Function }
    ): Computation;
    (
        runFunc: (computation: Computation) => void,
        options?: { onError?: Function }
    ): Computation;
};

function Computation

Computation: { (): void; (): void; (): void; (): void; (): void; (): void };

function flush

flush: { (): void; (): void; (): void; (): void; (): void; (): void };

function nonreactive

nonreactive: {
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
    (func: Function): void;
};

function onInvalidate

onInvalidate: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

interface Computation

interface Computation {}

property firstRun

firstRun: boolean;

property invalidated

invalidated: boolean;

property stopped

stopped: boolean;

method invalidate

invalidate: { (): void; (): void; (): void; (): void; (): void; (): void };

method onInvalidate

onInvalidate: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

method onStop

onStop: {
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
    (callback: Function): void;
};

method stop

stop: { (): void; (): void; (): void; (): void; (): void; (): void };

interface Dependency

interface Dependency {}

method changed

changed: { (): void; (): void; (): void; (): void; (): void; (): void };

method depend

depend: {
    (fromComputation?: Computation): boolean;
    (fromComputation?: Computation): boolean;
    (fromComputation?: Computation): boolean;
    (fromComputation?: Computation): boolean;
    (fromComputation?: Computation): boolean;
    (fromComputation?: Computation): boolean;
};

method hasDependents

hasDependents: {
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
    (): boolean;
};

interface DependencyStatic

interface DependencyStatic {}

construct signature

new (): Dependency;

namespace Package

namespace Package {}

function describe

describe: {
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
    (options: {
        summary?: string;
        version?: string;
        name?: string;
        git?: string;
        documentation?: string;
        debugOnly?: boolean;
        prodOnly?: boolean;
        testOnly?: boolean;
    }): void;
};

function onTest

onTest: {
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
};

function onUse

onUse: {
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
    (func: (api: PackageAPI) => void): void;
};

function registerBuildPlugin

registerBuildPlugin: {
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
    (options?: {
        name?: string;
        use?: string | string[];
        sources?: string[];
        npmDependencies?: Object;
    }): void;
};

Package Files (3)

Dependencies (0)

No dependencies.

Dev Dependencies (13)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/meteor-typings.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/meteor-typings)

HTML

<a href="https://www.jsdocs.io/package/meteor-typings"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 years ago.
Package analyzed in 13276 ms.
Missing or incorrect documentation? Open an issue for this package.