elaborated strict mode.

Author: Dummy

README.md

@@ -146,6 +146,7 @@ console.log(fakeCalculator.divide(9, 5)); //prints 1338
 - Doesn't rely on object instances - you can produce a strong-typed fake from nothing, ensuring that everything is mocked.
 
 # Beware
+## Names that conflict with Substitute.js
 Let's say we have a class with a method called `received`, `didNotReceive` or `mimick` keyword - how do we mock it? 
 
 Simple! We disable the proxy methods temporarily while invoking the method by using the `disableFor` method which disables these special methods.
@@ -167,4 +168,18 @@ Substitute.disableFor(fake).received(1337);
 
 //now we can assert that we received a call to the "received" method.
 fake.received().received(1337);
+```
+
+## Strict mode
+If you have `strict` set to `true` in your `tsconfig.json`, you may need to toggle off strict null checks. The framework does not currently support this.
+
+However, it is only needed for your test projects anyway.
+
+```json
+{
+    "compilerOptions": {
+        "strict": true,
+        "strictNullChecks": false
+    }
+}
 ```

dist/spec/index.test.d.ts

@@ -4,9 +4,9 @@ export declare class Example {
     a: string;
     c(arg1: string, arg2: string): string;
     readonly d: number;
-    v: string;
+    v: string | null | undefined;
     received(stuff: number | string): void;
     returnPromise(): Promise<Dummy>;
-    foo(): string;
+    foo(): string | undefined | null;
 }
 export {};

dist/spec/index.test.js.map

@@ -12,13 +12,13 @@ export declare class AllArguments extends Argument<any> {
 }
 export declare class Arg {
     static all(): AllArguments;
-    static any(): any;
+    static any(): Argument<any> & any;
     static any<T extends 'string'>(type: T): Argument<string> & string;
     static any<T extends 'number'>(type: T): Argument<number> & number;
     static any<T extends 'boolean'>(type: T): Argument<boolean> & boolean;
     static any<T extends 'array'>(type: T): Argument<any[]> & any[];
     static any<T extends 'function'>(type: T): Argument<Function> & Function;
-    static any<T extends 'string' | 'number' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'array'>(type: T): any;
-    static is<T>(predicate: (input: T) => boolean): Argument<T> & T;
+    static any<T extends 'string' | 'number' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'array'>(type: T): Argument<any> & any;
+    static is<T>(predicate: (input: any) => boolean): Argument<T> & T;
     private static toStringify;
 }

dist/src/Arguments.d.ts

@@ -1,7 +1,7 @@
 import { AllArguments } from "./Arguments";
 export declare type NoArgumentFunctionSubstitute<TReturnType> = (() => (TReturnType & NoArgumentMockObjectMixin<TReturnType>));
 export declare type FunctionSubstitute<TArguments extends any[], TReturnType> = ((...args: TArguments) => (TReturnType & MockObjectMixin<TArguments, TReturnType>)) & ((allArguments: AllArguments) => (TReturnType & MockObjectMixin<TArguments, TReturnType>));
-export declare type PropertySubstitute<TReturnType> = TReturnType & Partial<NoArgumentMockObjectMixin<TReturnType>>;
+export declare type PropertySubstitute<TReturnType> = (TReturnType & Partial<NoArgumentMockObjectMixin<TReturnType>>);
 declare type BaseMockObjectMixin<TReturnType> = {
     returns: (...args: TReturnType[]) => void;
 };