meteor-typings

meteor-typings

Version 1.4.1
Published 7 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;