first commit

node_modules/tsyringe/dist/typings/providers/class-provider.d.ts

@@ -0,0 +1,7 @@
+import constructor from "../types/constructor";
+import Provider from "./provider";
+import { DelayedConstructor } from "../lazy-helpers";
+export default interface ClassProvider<T> {
+    useClass: constructor<T> | DelayedConstructor<T>;
+}
+export declare function isClassProvider<T>(provider: Provider<T>): provider is ClassProvider<any>;

node_modules/tsyringe/dist/typings/providers/factory-provider.d.ts

@@ -0,0 +1,11 @@
+import DependencyContainer from "../types/dependency-container";
+import Provider from "./provider";
+/**
+ * Provide a dependency using a factory.
+ * Unlike the other providers, this does not support instance caching. If
+ * you need instance caching, your factory method must implement it.
+ */
+export default interface FactoryProvider<T> {
+    useFactory: (dependencyContainer: DependencyContainer) => T;
+}
+export declare function isFactoryProvider<T>(provider: Provider<T>): provider is FactoryProvider<any>;

node_modules/tsyringe/dist/typings/providers/index.d.ts

@@ -0,0 +1,6 @@
+export { default as ClassProvider, isClassProvider } from "./class-provider";
+export { default as FactoryProvider, isFactoryProvider } from "./factory-provider";
+export { default as InjectionToken, isNormalToken } from "./injection-token";
+export { default as Provider } from "./provider";
+export { default as TokenProvider, isTokenProvider } from "./token-provider";
+export { default as ValueProvider, isValueProvider } from "./value-provider";

node_modules/tsyringe/dist/typings/providers/injection-token.d.ts

@@ -0,0 +1,19 @@
+import constructor from "../types/constructor";
+import { DelayedConstructor } from "../lazy-helpers";
+import Transform from "../types/transform";
+declare type InjectionToken<T = any> = constructor<T> | string | symbol | DelayedConstructor<T>;
+export declare function isNormalToken(token?: InjectionToken<any>): token is string | symbol;
+export declare function isTokenDescriptor(descriptor: any): descriptor is TokenDescriptor;
+export declare function isTransformDescriptor(descriptor: any): descriptor is TransformDescriptor;
+export declare function isConstructorToken(token?: InjectionToken<any>): token is constructor<any> | DelayedConstructor<any>;
+export interface TokenDescriptor {
+    token: InjectionToken<any>;
+    multiple: boolean;
+    isOptional?: boolean;
+}
+export interface TransformDescriptor {
+    token: InjectionToken<any>;
+    transform: InjectionToken<Transform<any, any>>;
+    transformArgs: any[];
+}
+export default InjectionToken;

node_modules/tsyringe/dist/typings/providers/provider.d.ts

@@ -0,0 +1,7 @@
+import ClassProvider from "./class-provider";
+import ValueProvider from "./value-provider";
+import TokenProvider from "./token-provider";
+import FactoryProvider from "./factory-provider";
+declare type Provider<T = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T> | FactoryProvider<T>;
+export declare function isProvider(provider: any): provider is Provider;
+export default Provider;

node_modules/tsyringe/dist/typings/providers/token-provider.d.ts

@@ -0,0 +1,6 @@
+import InjectionToken from "./injection-token";
+import Provider from "./provider";
+export default interface TokenProvider<T> {
+    useToken: InjectionToken<T>;
+}
+export declare function isTokenProvider<T>(provider: Provider<T>): provider is TokenProvider<any>;

node_modules/tsyringe/dist/typings/providers/value-provider.d.ts

@@ -0,0 +1,5 @@
+import Provider from "./provider";
+export default interface ValueProvider<T> {
+    useValue: T;
+}
+export declare function isValueProvider<T>(provider: Provider<T>): provider is ValueProvider<T>;