/*
* Custom Type Definitions
* When including 3rd party modules you also need to include the type definition for the module
- * if they don't provide one within the module. You can try to install it with typings
+ * if they don't provide one within the module. You can try to install it with @types
-typings install node --save
+npm install @types/node
+npm install @types/lodash
- * If you can't find the type definition in the registry we can make an ambient definition in
+ * If you can't find the type definition in the registry we can make an ambient/global definition in
* this file for now. For example
-declare module "my-module" {
- export function doesSomething(value: string): string;
+declare module 'my-module' {
+ export function doesSomething(value: string): string;
+}
+
+ * If you are using a CommonJS module that is using module.exports then you will have to write your
+ * types using export = yourObjectOrFunction with a namespace above it
+ * notice how we have to create a namespace that is equal to the function we're
+ * assigning the export to
+
+declare module 'jwt-decode' {
+ function jwtDecode(token: string): any;
+ namespace jwtDecode {}
+ export = jwtDecode;
}
*
*
declare var assert: any;
+declare var _: any;
+declare var $: any;
*
* If you're importing a module that uses Node.js modules which are CommonJS you need to import as
+ * in the files such as main.browser.ts or any file within app/
*
import * as _ from 'lodash'
- * You can include your type definitions in this file until you create one for the typings registry
- * see https://github.com/typings/registry
+ * You can include your type definitions in this file until you create one for the @types
*
*/
+// support NodeJS modules without type definitions
+declare module '*';
+
+/*
+// for legacy tslint etc to understand rename 'modern-lru' with your package
+// then comment out `declare module '*';`. For each new module copy/paste
+// this method of creating an `any` module type definition
+declare module 'modern-lru' {
+ let x: any;
+ export = x;
+}
+*/
// Extra variables that live on Global that will be replaced by webpack DefinePlugin
declare var ENV: string;
declare var HMR: boolean;
+declare var System: SystemJS;
+
+interface SystemJS {
+ import: (path?: string) => Promise<any>;
+}
+
interface GlobalEnvironment {
- ENV;
- HMR;
+ ENV: string;
+ HMR: boolean;
+ SystemJS: SystemJS;
+ System: SystemJS;
+}
+
+interface Es6PromiseLoader {
+ (id: string): (exportName?: string) => Promise<any>;
}
+type FactoryEs6PromiseLoader = () => Es6PromiseLoader;
+type FactoryPromise = () => Promise<any>;
+
+type AsyncRoutes = {
+ [component: string]: Es6PromiseLoader |
+ Function |
+ FactoryEs6PromiseLoader |
+ FactoryPromise
+};
+
+type IdleCallbacks = Es6PromiseLoader |
+ Function |
+ FactoryEs6PromiseLoader |
+ FactoryPromise ;
+
interface WebpackModule {
hot: {
data?: any,
idle: any,
accept(dependencies?: string | string[], callback?: (updatedDependencies?: any) => void): void;
- decline(dependencies?: string | string[]): void;
+ decline(deps?: any | string | string[]): void;
dispose(callback?: (data?: any) => void): void;
addDisposeHandler(callback?: (data?: any) => void): void;
removeDisposeHandler(callback?: (data?: any) => void): void;
}
interface WebpackRequire {
- context(file: string, flag?: boolean, exp?: RegExp): any;
+ (id: string): any;
+ (paths: string[], callback: (...modules: any[]) => void): void;
+ ensure(ids: string[], callback: (req: WebpackRequire) => void, chunkName?: string): void;
+ context(directory: string, useSubDirectories?: boolean, regExp?: RegExp): WebpackContext;
}
+interface WebpackContext extends WebpackRequire {
+ keys(): string[];
+}
interface ErrorStackTraceLimit {
stackTraceLimit: number;
}
-
-
// Extend typings
interface NodeRequire extends WebpackRequire {}
interface ErrorConstructor extends ErrorStackTraceLimit {}
+interface NodeRequireFunction extends Es6PromiseLoader {}
interface NodeModule extends WebpackModule {}
interface Global extends GlobalEnvironment {}
-
-
-declare namespace Reflect {
- function decorate(decorators: ClassDecorator[], target: Function): Function;
- function decorate(
- decorators: (PropertyDecorator | MethodDecorator)[],
- target: Object,
- targetKey: string | symbol,
- descriptor?: PropertyDescriptor): PropertyDescriptor;
-
- function metadata(metadataKey: any, metadataValue: any): {
- (target: Function): void;
- (target: Object, propertyKey: string | symbol): void;
- };
- function defineMetadata(metadataKey: any, metadataValue: any, target: Object): void;
- function defineMetadata(
- metadataKey: any,
- metadataValue: any,
- target: Object,
- targetKey: string | symbol): void;
- function hasMetadata(metadataKey: any, target: Object): boolean;
- function hasMetadata(metadataKey: any, target: Object, targetKey: string | symbol): boolean;
- function hasOwnMetadata(metadataKey: any, target: Object): boolean;
- function hasOwnMetadata(metadataKey: any, target: Object, targetKey: string | symbol): boolean;
- function getMetadata(metadataKey: any, target: Object): any;
- function getMetadata(metadataKey: any, target: Object, targetKey: string | symbol): any;
- function getOwnMetadata(metadataKey: any, target: Object): any;
- function getOwnMetadata(metadataKey: any, target: Object, targetKey: string | symbol): any;
- function getMetadataKeys(target: Object): any[];
- function getMetadataKeys(target: Object, targetKey: string | symbol): any[];
- function getOwnMetadataKeys(target: Object): any[];
- function getOwnMetadataKeys(target: Object, targetKey: string | symbol): any[];
- function deleteMetadata(metadataKey: any, target: Object): boolean;
- function deleteMetadata(metadataKey: any, target: Object, targetKey: string | symbol): boolean;
-}
-
-
-// We need this here since there is a problem with Zone.js typings
-interface Thenable<T> {
- then<U>(
- onFulfilled?: (value: T) => U | Thenable<U>,
- onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
- then<U>(
- onFulfilled?: (value: T) => U | Thenable<U>,
- onRejected?: (error: any) => void): Thenable<U>;
- catch<U>(onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
-}