diff --git a/types/yup/index.d.ts b/types/yup/index.d.ts
index 821b0e3526..5d8713db68 100644
--- a/types/yup/index.d.ts
+++ b/types/yup/index.d.ts
@@ -5,6 +5,7 @@
 //                 Moreton Bay Regional Council <https://github.com/MoretonBayRC>,
 //                 Sindre Seppola <https://github.com/sseppola>
 //                 Yash Kulshrestha <https://github.com/YashdalfTheGray>
+//                 Vincent Pizzo <https://github.com/vincentjames501>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
 
@@ -47,6 +48,9 @@ export type AnySchemaConstructor =
     | ArraySchemaConstructor
     | ObjectSchemaConstructor;
 
+export type TestOptionsMessage = string
+    | ((params: object & Partial<TestMessageParams>) => string);
+
 export interface Schema<T> {
     clone(): this;
     label(label: string): this;
@@ -67,11 +71,11 @@ export interface Schema<T> {
     withMutation(fn: (current: this) => void): void;
     default(value?: any): this;
     nullable(isNullable: boolean): this;
-    required(message?: string): this;
+    required(message?: TestOptionsMessage): this;
     notRequired(): this;
-    typeError(message?: string): this;
-    oneOf(arrayOfValues: any[], message?: string): this;
-    notOneOf(arrayOfValues: any[], message?: string): this;
+    typeError(message?: TestOptionsMessage): this;
+    oneOf(arrayOfValues: any[], message?: TestOptionsMessage): this;
+    notOneOf(arrayOfValues: any[], message?: TestOptionsMessage): this;
     when(keys: string | any[], builder: WhenOptions<this>): this;
     test(
         name: string,
@@ -102,20 +106,20 @@ export interface StringSchemaConstructor {
 }
 
 export interface StringSchema extends Schema<string> {
-    min(limit: number | Ref, message?: string): StringSchema;
-    max(limit: number | Ref, message?: string): StringSchema;
+    min(limit: number | Ref, message?: TestOptionsMessage): StringSchema;
+    max(limit: number | Ref, message?: TestOptionsMessage): StringSchema;
     matches(
         regex: RegExp,
         messageOrOptions?:
-            | string
-            | { message?: string; excludeEmptyString?: boolean }
+            | TestOptionsMessage
+            | { message?: TestOptionsMessage; excludeEmptyString?: boolean }
     ): StringSchema;
-    email(message?: string): StringSchema;
-    url(message?: string): StringSchema;
+    email(message?: TestOptionsMessage): StringSchema;
+    url(message?: TestOptionsMessage): StringSchema;
     ensure(): StringSchema;
-    trim(message?: string): StringSchema;
-    lowercase(message?: string): StringSchema;
-    uppercase(message?: string): StringSchema;
+    trim(message?: TestOptionsMessage): StringSchema;
+    lowercase(message?: TestOptionsMessage): StringSchema;
+    uppercase(message?: TestOptionsMessage): StringSchema;
 }
 
 export interface NumberSchemaConstructor {
@@ -124,13 +128,13 @@ export interface NumberSchemaConstructor {
 }
 
 export interface NumberSchema extends Schema<number> {
-    min(limit: number | Ref, message?: string): NumberSchema;
-    max(limit: number | Ref, message?: string): NumberSchema;
-    lessThan(limit: number | Ref, message?: string): NumberSchema;
-    moreThan(limit: number | Ref, message?: string): NumberSchema;
-    positive(message?: string): NumberSchema;
-    negative(message?: string): NumberSchema;
-    integer(message?: string): NumberSchema;
+    min(limit: number | Ref, message?: TestOptionsMessage): NumberSchema;
+    max(limit: number | Ref, message?: TestOptionsMessage): NumberSchema;
+    lessThan(limit: number | Ref, message?: TestOptionsMessage): NumberSchema;
+    moreThan(limit: number | Ref, message?: TestOptionsMessage): NumberSchema;
+    positive(message?: TestOptionsMessage): NumberSchema;
+    negative(message?: TestOptionsMessage): NumberSchema;
+    integer(message?: TestOptionsMessage): NumberSchema;
     truncate(): NumberSchema;
     round(type: "floor" | "ceil" | "trunc" | "round"): NumberSchema;
 }
@@ -149,8 +153,8 @@ export interface DateSchemaConstructor {
 }
 
 export interface DateSchema extends Schema<Date> {
-    min(limit: Date | string | Ref, message?: string): DateSchema;
-    max(limit: Date | string | Ref, message?: string): DateSchema;
+    min(limit: Date | string | Ref, message?: TestOptionsMessage): DateSchema;
+    max(limit: Date | string | Ref, message?: TestOptionsMessage): DateSchema;
 }
 
 export interface ArraySchemaConstructor {
@@ -160,8 +164,8 @@ export interface ArraySchemaConstructor {
 
 export interface ArraySchema<T> extends Schema<T[]> {
     of<U>(type: Schema<U>): ArraySchema<U>;
-    min(limit: number | Ref, message?: string): ArraySchema<T>;
-    max(limit: number | Ref, message?: string): ArraySchema<T>;
+    min(limit: number | Ref, message?: TestOptionsMessage): ArraySchema<T>;
+    max(limit: number | Ref, message?: TestOptionsMessage): ArraySchema<T>;
     ensure(): ArraySchema<T>;
     compact(rejector?: (value: any) => boolean): ArraySchema<T>;
 }
@@ -177,7 +181,7 @@ export interface ObjectSchema<T> extends Schema<T> {
         noSortEdges?: Array<[string, string]>
     ): ObjectSchema<T>;
     from(fromKey: string, toKey: string, alias?: boolean): ObjectSchema<T>;
-    noUnknown(onlyKnownKeys?: boolean, message?: string): ObjectSchema<T>;
+    noUnknown(onlyKnownKeys?: boolean, message?: TestOptionsMessage): ObjectSchema<T>;
     transformKeys(callback: (key: any) => any): void;
     camelCase(): ObjectSchema<T>;
     constantCase(): ObjectSchema<T>;
@@ -256,9 +260,7 @@ export interface TestOptions {
     /**
      * The validation error message
      */
-    message?:
-        | string
-        | ((params: object & Partial<TestMessageParams>) => string);
+    message?: TestOptionsMessage;
 
     /**
      * Values passed to message for interpolation
diff --git a/types/yup/yup-tests.ts b/types/yup/yup-tests.ts
index efef78d319..4a6ecae98f 100644
--- a/types/yup/yup-tests.ts
+++ b/types/yup/yup-tests.ts
@@ -126,10 +126,15 @@ mixed.default(() => ({ number: 5 }));
 mixed.default();
 mixed.nullable(true);
 mixed.required();
+mixed.required('Foo');
+mixed.required(() => 'Foo');
 mixed.notRequired(); // $ExpectType MixedSchema
 mixed.typeError("type error");
+mixed.typeError(() => "type error");
 mixed.oneOf(["hello", "world"], "message");
+mixed.oneOf(["hello", "world"], () => "message");
 mixed.notOneOf(["hello", "world"], "message");
+mixed.notOneOf(["hello", "world"], () => "message");
 mixed.when("isBig", {
     is: value => true,
     then: yup.number().min(5),
@@ -255,26 +260,56 @@ yup.object()
 const strSchema = yup.string(); // $ExpectType StringSchema
 strSchema.isValid("hello"); // => true
 strSchema.required();
+strSchema.required("req");
+strSchema.required(() => "req");
 strSchema.min(5, "message");
+strSchema.min(5, () => "message");
 strSchema.max(5, "message");
+strSchema.max(5, () => "message");
 strSchema.matches(/(hi|bye)/);
+strSchema.matches(/(hi|bye)/, "invalid");
+strSchema.matches(/(hi|bye)/, () => "invalid");
 strSchema.email();
+strSchema.email("invalid");
+strSchema.email(() => "invalid");
 strSchema.url();
+strSchema.url("bad url");
+strSchema.url(() => "bad url");
 strSchema.ensure();
 strSchema.trim();
+strSchema.trim("trimmed");
+strSchema.trim(() => "trimmed");
 strSchema.lowercase();
+strSchema.lowercase("lower");
+strSchema.lowercase(() => "lower");
 strSchema.uppercase();
+strSchema.uppercase("upper");
+strSchema.uppercase(() => "upper");
 
 // Number schema
 const numSchema = yup.number(); // $ExpectType NumberSchema
 numSchema.isValid(10); // => true
+numSchema.min(5);
 numSchema.min(5, "message");
+numSchema.min(5, () => "message");
+numSchema.max(5);
 numSchema.max(5, "message");
+numSchema.max(5, () => "message");
 numSchema.positive();
+numSchema.positive("pos");
+numSchema.positive(() => "pos");
 numSchema.negative();
+numSchema.negative("neg");
+numSchema.negative(() => "neg");
 numSchema.lessThan(5);
+numSchema.lessThan(5, "lt");
+numSchema.lessThan(5, () => "lt");
 numSchema.moreThan(5);
+numSchema.moreThan(5, "mt");
+numSchema.moreThan(5, () => "mt");
 numSchema.integer();
+numSchema.integer("int");
+numSchema.integer(() => "int");
 numSchema.truncate();
 numSchema.round("floor");
 numSchema
@@ -293,17 +328,27 @@ dateSchema.min(new Date());
 dateSchema.min("2017-11-12");
 dateSchema.min(new Date(), "message");
 dateSchema.min("2017-11-12", "message");
+dateSchema.min("2017-11-12", () => "message");
 dateSchema.max(new Date());
 dateSchema.max("2017-11-12");
 dateSchema.max(new Date(), "message");
 dateSchema.max("2017-11-12", "message");
+dateSchema.max("2017-11-12", () => "message");
 
 // Array Schema
 const arrSchema = yup.array().of(yup.number().min(2));
 arrSchema.isValid([2, 3]); // => true
 arrSchema.isValid([1, -24]); // => false
 arrSchema.required();
+arrSchema.required("req");
+arrSchema.required(() => "req");
 arrSchema.ensure();
+arrSchema.max(5);
+arrSchema.max(5, "max");
+arrSchema.max(5, () => "max");
+arrSchema.min(5);
+arrSchema.min(5, "min");
+arrSchema.min(5, () => "min");
 arrSchema.compact(value => value === null);
 
 yup.array(); // $ExpectType ArraySchema<{}>
@@ -334,6 +379,7 @@ objSchema.from("prop", "myProp", true);
 objSchema.noUnknown();
 objSchema.noUnknown(true);
 objSchema.noUnknown(true, "message");
+objSchema.noUnknown(true, () => "message");
 objSchema.transformKeys(key => key.toUpperCase());
 objSchema.camelCase();
 objSchema.constantCase();