@availity/yup 3.2.0 → 4.1.1-alpha.2

package/CHANGELOG.md

@@ -3,6 +3,44 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 4.1.0 (2021-11-18)
+
+
+### Features
+
+* **yup:** allow custom type error message for dateRange ([cc36cde](https://github.com/Availity/sdk-js/commit/cc36cde7d403f9787343fcecbf1d0fd9d8ac6bf7))
+
+
+
+
+
+# 4.0.0 (2021-11-02)
+
+
+### Bug Fixes
+
+* **yup:** package change for major version update ([9ad040f](https://github.com/Availity/sdk-js/commit/9ad040ff7a4f7cbe7d5fdd37932d953287db805c)), closes [/github.com/jquense/yup/blob/375f1b9ed41f5043e123ea87a01a2dfe333c3927/CHANGELOG.md#0320-2020-12-03](https://github.com//github.com/jquense/yup/blob/375f1b9ed41f5043e123ea87a01a2dfe333c3927/CHANGELOG.md/issues/0320-2020-12-03)
+
+
+### BREAKING CHANGES
+
+* **yup:** the version of yup this package requires contains breaking changes from 0.32.0 onward
+
+
+
+
+
+## [3.2.1](https://github.com/Availity/sdk-js/compare/@availity/yup@3.2.0...@availity/yup@3.2.1) (2021-10-29)
+
+
+### Bug Fixes
+
+* **yup:** fixes start date before end date logic ([6cc0ff7](https://github.com/Availity/sdk-js/commit/6cc0ff736358bc5aaf738a84d8abb258e85f57f4))
+
+
+
+
+
 # 3.2.0 (2021-10-22)
 
 

package/lib/date.js

@@ -34,8 +34,8 @@ var defaultOpts = {
 };
 var formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD', 'MM-DD-YYYY'];
 
-var AvDateSchema = /*#__PURE__*/function (_mixed) {
-  (0, _inherits2["default"])(AvDateSchema, _mixed);
+var AvDateSchema = /*#__PURE__*/function (_MixedSchema) {
+  (0, _inherits2["default"])(AvDateSchema, _MixedSchema);
 
   var _super = (0, _createSuper2["default"])(AvDateSchema);
 
@@ -53,8 +53,8 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
     _this.format = format;
     _this.getValidDate = _this.getValidDate.bind((0, _assertThisInitialized2["default"])(_this));
 
-    _this.withMutation(function () {
-      if (!_this.tests.some(function (test) {
+    _this.withMutation(function (schema) {
+      if (!schema.tests.some(function (test) {
         var _test$OPTIONS;
 
         return (test === null || test === void 0 ? void 0 : (_test$OPTIONS = test.OPTIONS) === null || _test$OPTIONS === void 0 ? void 0 : _test$OPTIONS.name) === 'typeError';
@@ -62,8 +62,8 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
         (0, _get2["default"])((_thisSuper = (0, _assertThisInitialized2["default"])(_this), (0, _getPrototypeOf2["default"])(AvDateSchema.prototype)), "typeError", _thisSuper).call(_thisSuper, 'Date is invalid.');
       }
 
-      _this.transform(function mutate(value) {
-        return this.getValidDate(value);
+      schema.transform(function mutate(value) {
+        return schema.getValidDate(value);
       });
     });
 
@@ -167,6 +167,6 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
     }
   }]);
   return AvDateSchema;
-}(_yup.mixed);
+}(_yup.MixedSchema);
 
 exports["default"] = AvDateSchema;

package/lib/dateRange.js

@@ -13,32 +13,28 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
 var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
 
-var _moment = _interopRequireDefault(require("moment"));
-
 var _yup = require("yup");
 
+var _moment = _interopRequireDefault(require("moment"));
+
 var _get = _interopRequireDefault(require("lodash/get"));
 
 var _merge2 = _interopRequireDefault(require("lodash/merge"));
 
 var defaultOptions = {
   startKey: 'startDate',
-  endKey: 'endDate',
-  format: 'MM/DD/YYYY'
+  endKey: 'endDate'
 };
 var defaultValue = {};
-var formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+var displayFormat = 'MM/DD/YYYY';
+var formats = [displayFormat, 'YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
 
-var DateRangeSchema = /*#__PURE__*/function (_mixed) {
-  (0, _inherits2["default"])(DateRangeSchema, _mixed);
+var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
+  (0, _inherits2["default"])(DateRangeSchema, _MixedSchema);
 
   var _super = (0, _createSuper2["default"])(DateRangeSchema);
 
@@ -52,27 +48,24 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
 
     var _merge = (0, _merge2["default"])({}, defaultOptions, options),
         startKey = _merge.startKey,
-        endKey = _merge.endKey,
-        format = _merge.format;
+        endKey = _merge.endKey;
 
     _this.startKey = startKey;
-    _this.endKey = endKey;
-    _this.format = format;
-    _this.getValidDate = _this.getValidDate.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.endKey = endKey; // this.format = format;
 
-    _this.withMutation(function () {
-      _this.transform(function mutate(value) {
+    _this.withMutation(function (schema) {
+      schema.transform(function mutate(value) {
         var start = (0, _get["default"])(value, startKey);
         var end = (0, _get["default"])(value, endKey);
         var startDate;
         var endDate;
 
         if (start) {
-          startDate = this.getValidDate(start);
+          startDate = schema.getValidDate(start);
         }
 
         if (end) {
-          endDate = this.getValidDate(end);
+          endDate = schema.getValidDate(end);
         }
 
         return {
@@ -82,53 +75,38 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
       });
     });
 
-    return (0, _possibleConstructorReturn2["default"])(_this, _this.test({
-      message: 'Start date must come before end date.',
-      name: 'startBeforeEnd',
-      exclusive: true,
-      test: function test() {
-        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-            startDate = _ref.startDate,
-            endDate = _ref.endDate;
-
-        if (!startDate || !endDate) {
-          return true;
-        }
-
-        return startDate.isSameOrBefore(endDate);
-      }
-    }));
+    return _this;
   }
 
   (0, _createClass2["default"])(DateRangeSchema, [{
     key: "getValidDate",
     value: function getValidDate(value) {
-      return (0, _moment["default"])(value, [this.format].concat(formats), true);
+      return (0, _moment["default"])(value, formats, true);
     }
   }, {
     key: "distance",
     value: function distance() {
-      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-          _ref2$min = _ref2.min;
-
-      _ref2$min = _ref2$min === void 0 ? {} : _ref2$min;
-      var minValue = _ref2$min.value,
-          _ref2$min$units = _ref2$min.units,
-          minUnits = _ref2$min$units === void 0 ? 'day' : _ref2$min$units,
-          minErrorMessage = _ref2$min.errorMessage,
-          _ref2$max = _ref2.max;
-      _ref2$max = _ref2$max === void 0 ? {} : _ref2$max;
-      var maxValue = _ref2$max.value,
-          _ref2$max$units = _ref2$max.units,
-          maxUnits = _ref2$max$units === void 0 ? 'day' : _ref2$max$units,
-          maxErrorMessage = _ref2$max.errorMessage;
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
+          _ref$min = _ref.min;
+
+      _ref$min = _ref$min === void 0 ? {} : _ref$min;
+      var minValue = _ref$min.value,
+          _ref$min$units = _ref$min.units,
+          minUnits = _ref$min$units === void 0 ? 'day' : _ref$min$units,
+          minErrorMessage = _ref$min.errorMessage,
+          _ref$max = _ref.max;
+      _ref$max = _ref$max === void 0 ? {} : _ref$max;
+      var maxValue = _ref$max.value,
+          _ref$max$units = _ref$max.units,
+          maxUnits = _ref$max$units === void 0 ? 'day' : _ref$max$units,
+          maxErrorMessage = _ref$max.errorMessage;
       return this.test({
         name: 'distance',
         exclusive: true,
         test: function test() {
-          var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-              endDate = _ref3.endDate,
-              startDate = _ref3.startDate;
+          var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
+              endDate = _ref2.endDate,
+              startDate = _ref2.startDate;
 
           if (!minValue && !maxValue || !startDate || !endDate) return true;
 
@@ -153,56 +131,51 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
   }, {
     key: "min",
     value: function min(_min, message) {
-      var format = this.format;
+      // it works for date, but not daterange. maybe that can tell us more about what is going on
       var minDate = this.getValidDate(_min);
       return this.test({
-        message: message || "Date Range must start on or after ".concat(minDate.format(format)),
+        message: message || "Date Range must start on or after ".concat(minDate.format(displayFormat)),
         name: 'min',
         exclusive: true,
         params: {
           min: _min
         },
         test: function test() {
-          var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-              startDate = _ref4.startDate;
-
-          if (!startDate || !_min) {
-            return true;
-          }
+          var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
+              startDate = _ref3.startDate;
 
-          return minDate.isValid() && minDate.isSameOrBefore(startDate);
+          // is minDate valid and is it before the given date
+          return !startDate || !_min ? true : minDate.isValid() && minDate.isSameOrBefore(startDate);
         }
       });
     }
   }, {
     key: "max",
     value: function max(_max, message) {
-      var format = this.format;
       var maxDate = this.getValidDate(_max);
       return this.test({
-        message: message || "Date Range must end on or before ".concat(maxDate.format(format)),
+        message: message || "Date Range must end on or before ".concat(maxDate.format(displayFormat)),
         name: 'max',
         exclusive: true,
         params: {
           max: _max
         },
         test: function test() {
-          var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-              endDate = _ref5.endDate;
+          var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
+              endDate = _ref4.endDate;
 
-          if (!endDate || !_max) return true;
-          return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
+          // is maxDate valid and is it after the given date
+          return !endDate || !_max ? true : maxDate.isValid() && maxDate.isSameOrAfter(endDate);
         }
       });
     }
   }, {
     key: "between",
     value: function between(min, max, message) {
-      var format = this.format;
       var minDate = this.getValidDate(min);
       var maxDate = this.getValidDate(max);
       return this.test({
-        message: message || "Date Range must be between ".concat(minDate.format(format), " and ").concat(maxDate.format(format)),
+        message: message || "Date Range must be between ".concat(minDate.format(displayFormat), " and ").concat(maxDate.format(displayFormat)),
         name: 'between',
         exclusive: true,
         params: {
@@ -210,9 +183,9 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
           max: max
         },
         test: function test() {
-          var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-              startDate = _ref6.startDate,
-              endDate = _ref6.endDate;
+          var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
+              startDate = _ref5.startDate,
+              endDate = _ref5.endDate;
 
           if (!startDate || !endDate || !min || !max) return true;
           return maxDate.isValid() && minDate.isValid() && maxDate.isSameOrAfter(endDate) && minDate.isSameOrBefore(startDate);
@@ -230,9 +203,9 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
         exclusive: true,
         message: msg || 'This field is required.',
         test: function test() {
-          var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
-              startDate = _ref7.startDate,
-              endDate = _ref7.endDate;
+          var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
+              startDate = _ref6.startDate,
+              endDate = _ref6.endDate;
 
           return !_isRequired || startDate && endDate;
         }
@@ -240,7 +213,8 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
     }
   }, {
     key: "typeError",
-    value: function typeError() {
+    value: function typeError(_ref7) {
+      var message = _ref7.message;
       return this.test({
         name: 'typeError',
         exclusive: true,
@@ -252,7 +226,11 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
           var errors = [];
 
           if ((!startDate || !endDate) && (startDate || endDate)) {
-            errors.push('Start and End Date are required.');
+            errors.push(message || 'Start and End Date are required.');
+          }
+
+          if (startDate && endDate && !startDate.isSameOrBefore(endDate)) {
+            errors.push('Start date must come before end date.');
           }
 
           if (startDate && !startDate.isValid()) {
@@ -281,6 +259,6 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
     }
   }]);
   return DateRangeSchema;
-}(_yup.mixed);
+}(_yup.MixedSchema);
 
 exports["default"] = DateRangeSchema;

package/lib/index.js

@@ -9,16 +9,16 @@ exports.dateRange = exports.avDate = void 0;
 
 var _yup = require("yup");
 
+var _date = _interopRequireDefault(require("./date"));
+
+var _dateRange = _interopRequireDefault(require("./dateRange"));
+
 var _isRequired = _interopRequireDefault(require("./isRequired"));
 
 var _npi = _interopRequireDefault(require("./npi"));
 
 var _phone = _interopRequireDefault(require("./phone"));
 
-var _date = _interopRequireDefault(require("./date"));
-
-var _dateRange = _interopRequireDefault(require("./dateRange"));
-
 var avDate = function avDate(opts) {
   return new _date["default"](opts);
 };
@@ -30,11 +30,11 @@ var dateRange = function dateRange(opts) {
 };
 
 exports.dateRange = dateRange;
-(0, _yup.addMethod)(_yup.string, 'isRequired', _isRequired["default"]);
-(0, _yup.addMethod)(_yup.number, 'isRequired', _isRequired["default"]);
 (0, _yup.addMethod)(_yup.array, 'isRequired', _isRequired["default"]);
+(0, _yup.addMethod)(_yup.number, 'isRequired', _isRequired["default"]);
 (0, _yup.addMethod)(_yup.object, 'isRequired', _isRequired["default"]);
-(0, _yup.addMethod)(_yup.string, 'npi', _npi["default"]);
+(0, _yup.addMethod)(_yup.string, 'isRequired', _isRequired["default"]);
 (0, _yup.addMethod)(_yup.number, 'npi', _npi["default"]);
-(0, _yup.addMethod)(_yup.string, 'phone', _phone["default"]);
-(0, _yup.addMethod)(_yup.number, 'phone', _phone["default"]);
+(0, _yup.addMethod)(_yup.string, 'npi', _npi["default"]);
+(0, _yup.addMethod)(_yup.number, 'phone', _phone["default"]);
+(0, _yup.addMethod)(_yup.string, 'phone', _phone["default"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@availity/yup",
-  "version": "3.2.0",
+  "version": "4.1.1-alpha.2+3679957",
   "description": "Additional Methods for Yup validation library",
   "main": "lib/index.js",
   "module": "src/index.js",
@@ -21,11 +21,11 @@
   },
   "devDependencies": {
     "moment": "^2.24.0",
-    "yup": "^0.28.1"
+    "yup": "^0.32.9"
   },
   "peerDependencies": {
     "moment": "^2.24.0",
-    "yup": "^0.28.1"
+    "yup": "^0.32.9"
   },
-  "gitHead": "a247c20c27816eb3e3b68b983d12631a6cadd72b"
+  "gitHead": "36799574f86674e1a41228c10bfba8d303958e02"
 }

package/src/date.js

@@ -1,4 +1,4 @@
-import { mixed } from 'yup';
+import { MixedSchema } from 'yup';
 import moment from 'moment';
 
 const defaultOpts = {
@@ -7,7 +7,7 @@ const defaultOpts = {
 
 const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD', 'MM-DD-YYYY'];
 
-export default class AvDateSchema extends mixed {
+export default class AvDateSchema extends MixedSchema {
   constructor({ format = 'MM/DD/YYYY' } = defaultOpts) {
     super({
       type: 'avDate',
@@ -16,12 +16,12 @@ export default class AvDateSchema extends mixed {
     this.format = format;
     this.getValidDate = this.getValidDate.bind(this);
 
-    this.withMutation(() => {
-      if (!this.tests.some((test) => test?.OPTIONS?.name === 'typeError')) {
+    this.withMutation((schema) => {
+      if (!schema.tests.some((test) => test?.OPTIONS?.name === 'typeError')) {
         super.typeError('Date is invalid.');
       }
-      this.transform(function mutate(value) {
-        return this.getValidDate(value);
+      schema.transform(function mutate(value) {
+        return schema.getValidDate(value);
       });
     });
   }

package/src/dateRange.js

@@ -1,66 +1,52 @@
+import { MixedSchema, ValidationError } from 'yup';
 import moment from 'moment';
-import { mixed, ValidationError } from 'yup';
 import get from 'lodash/get';
 import merge from 'lodash/merge';
 
 const defaultOptions = {
   startKey: 'startDate',
   endKey: 'endDate',
-  format: 'MM/DD/YYYY',
 };
 
 const defaultValue = {};
 
-const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+const displayFormat = 'MM/DD/YYYY';
 
-export default class DateRangeSchema extends mixed {
+const formats = [displayFormat, 'YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+
+export default class DateRangeSchema extends MixedSchema {
   constructor(options) {
     super({
       type: 'dateRange',
     });
 
-    const { startKey, endKey, format } = merge({}, defaultOptions, options);
+    const { startKey, endKey } = merge({}, defaultOptions, options);
 
     this.startKey = startKey;
     this.endKey = endKey;
-    this.format = format;
-    this.getValidDate = this.getValidDate.bind(this);
+    // this.format = format;
 
-    this.withMutation(() => {
-      this.transform(function mutate(value) {
+    this.withMutation((schema) => {
+      schema.transform(function mutate(value) {
         const start = get(value, startKey);
         const end = get(value, endKey);
 
         let startDate;
         let endDate;
         if (start) {
-          startDate = this.getValidDate(start);
+          startDate = schema.getValidDate(start);
         }
 
         if (end) {
-          endDate = this.getValidDate(end);
+          endDate = schema.getValidDate(end);
         }
-
         return { startDate, endDate };
       });
     });
-
-    return this.test({
-      message: 'Start date must come before end date.',
-      name: 'startBeforeEnd',
-      exclusive: true,
-      test({ startDate, endDate } = defaultValue) {
-        if (!startDate || !endDate) {
-          return true;
-        }
-
-        return startDate.isSameOrBefore(endDate);
-      },
-    });
   }
 
   getValidDate(value) {
-    return moment(value, [this.format, ...formats], true);
+    return moment(value, formats, true);
   }
 
   distance({
@@ -99,48 +85,43 @@ export default class DateRangeSchema extends mixed {
   }
 
   min(min, message) {
-    const { format } = this;
-
+    // it works for date, but not daterange. maybe that can tell us more about what is going on
     const minDate = this.getValidDate(min);
+
     return this.test({
-      message: message || `Date Range must start on or after ${minDate.format(format)}`,
+      message: message || `Date Range must start on or after ${minDate.format(displayFormat)}`,
       name: 'min',
       exclusive: true,
       params: { min },
       test({ startDate } = defaultValue) {
-        if (!startDate || !min) {
-          return true;
-        }
-        return minDate.isValid() && minDate.isSameOrBefore(startDate);
+        // is minDate valid and is it before the given date
+        return !startDate || !min ? true : minDate.isValid() && minDate.isSameOrBefore(startDate);
       },
     });
   }
 
   max(max, message) {
-    const { format } = this;
-
     const maxDate = this.getValidDate(max);
 
     return this.test({
-      message: message || `Date Range must end on or before ${maxDate.format(format)}`,
+      message: message || `Date Range must end on or before ${maxDate.format(displayFormat)}`,
       name: 'max',
       exclusive: true,
       params: { max },
       test({ endDate } = defaultValue) {
-        if (!endDate || !max) return true;
-        return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
+        // is maxDate valid and is it after the given date
+        return !endDate || !max ? true : maxDate.isValid() && maxDate.isSameOrAfter(endDate);
       },
     });
   }
 
   between(min, max, message) {
-    const { format } = this;
-
     const minDate = this.getValidDate(min);
     const maxDate = this.getValidDate(max);
 
     return this.test({
-      message: message || `Date Range must be between ${minDate.format(format)} and ${maxDate.format(format)}`,
+      message:
+        message || `Date Range must be between ${minDate.format(displayFormat)} and ${maxDate.format(displayFormat)}`,
       name: 'between',
       exclusive: true,
       params: { min, max },
@@ -164,7 +145,7 @@ export default class DateRangeSchema extends mixed {
     });
   }
 
-  typeError() {
+  typeError({ message }) {
     return this.test({
       name: 'typeError',
       exclusive: true,
@@ -172,7 +153,11 @@ export default class DateRangeSchema extends mixed {
         const errors = [];
 
         if ((!startDate || !endDate) && (startDate || endDate)) {
-          errors.push('Start and End Date are required.');
+          errors.push(message || 'Start and End Date are required.');
+        }
+
+        if (startDate && endDate && !startDate.isSameOrBefore(endDate)) {
+          errors.push('Start date must come before end date.');
         }
 
         if (startDate && !startDate.isValid()) {

package/src/index.js

@@ -1,20 +1,20 @@
 import { addMethod, array, number, object, string } from 'yup';
+import AvDateSchema from './date';
+import DateRangeSchema from './dateRange';
 import isRequired from './isRequired';
 import npi from './npi';
 import phone from './phone';
-import AvDate from './date';
-import DateRange from './dateRange';
 
-export const avDate = (opts) => new AvDate(opts);
-export const dateRange = (opts) => new DateRange(opts);
+export const avDate = (opts) => new AvDateSchema(opts);
+export const dateRange = (opts) => new DateRangeSchema(opts);
 
-addMethod(string, 'isRequired', isRequired);
-addMethod(number, 'isRequired', isRequired);
 addMethod(array, 'isRequired', isRequired);
+addMethod(number, 'isRequired', isRequired);
 addMethod(object, 'isRequired', isRequired);
+addMethod(string, 'isRequired', isRequired);
 
-addMethod(string, 'npi', npi);
 addMethod(number, 'npi', npi);
+addMethod(string, 'npi', npi);
 
-addMethod(string, 'phone', phone);
 addMethod(number, 'phone', phone);
+addMethod(string, 'phone', phone);

package/types/date.d.ts

@@ -1,21 +1,19 @@
-import * as yup from 'yup';
+import { MixedSchema } from 'yup';
 
-declare module 'yup' {
-  interface DateOpts {
-    format?: string | 'MM/DD/YYYY';
-  }
-
-  interface AvDateSchema<T extends string | null | undefined = string> extends MixedSchema<T> {
-    min(date: string, errorMessage?: string): DateRangeSchema<T>;
-    max(date: string, errorMessage?: string): DateRangeSchema<T>;
-    between(minDate: string, maxDate: string, errorMessage?: string): AvDateSchema<T>;
-    isRequired(required?: boolean, errorMessage?: string): AvDateSchema<T>;
-  }
+interface DateOpts {
+  format?: string | 'MM/DD/YYYY';
+}
 
-  export interface AvDateSchemaConstructor {
-    (opts: DateOpts): AvDateSchema;
-    new (opts: DateOpts): AvDateSchema;
-  }
+interface AvDateSchema<T extends string | null | undefined = string> extends MixedSchema<T> {
+  min(date: string, errorMessage?: string): DateRangeSchema<T>;
+  max(date: string, errorMessage?: string): DateRangeSchema<T>;
+  between(minDate: string, maxDate: string, errorMessage?: string): AvDateSchema<T>;
+  isRequired(required?: boolean, errorMessage?: string): AvDateSchema<T>;
+}
 
-  export const avDate: AvDateSchemaConstructor;
+export interface AvDateSchemaConstructor {
+  (opts?: DateOpts): AvDateSchema;
+  new (opts?: DateOpts): AvDateSchema;
 }
+
+export const avDate: AvDateSchemaConstructor;

package/types/dateRange.d.ts

@@ -1,40 +1,38 @@
-import * as yup from 'yup';
+import { MixedSchema } from 'yup';
 
-declare module 'yup' {
-  type DateRangeObject = {
-    [startDate: any]: string;
-    [endDate: any]: string;
-  };
+type DateRangeObject = {
+  startDate: string;
+  endDate: string;
+};
 
-  interface DateRangeOpts {
-    startKey?: string | 'startDate';
-    endKey?: string | 'endKey';
-    format?: string | 'MM/DD/YYYY';
-  }
-
-  type DistanceValue = {
-    value: number;
-    units?: string;
-    errorMessage?: string;
-  };
+interface DateRangeOpts {
+  startKey?: string | 'startDate';
+  endKey?: string | 'endKey';
+  format?: string | 'MM/DD/YYYY';
+}
 
-  type DistanceOpts = {
-    min?: DistanceValue;
-    max?: DistanceValue;
-  };
+type DistanceValue = {
+  value: number;
+  units?: string;
+  errorMessage?: string;
+};
 
-  interface DateRangeSchema<T extends DateRangeObject | null | undefined = DateRangeObject> extends MixedSchema<T> {
-    min(date: string, errorMessage?: string): DateRangeSchema<T>;
-    max(date: string, errorMessage?: string): DateRangeSchema<T>;
-    between(minDate: string, maxDate: string, errorMessage?: string): DateRangeSchema<T>;
-    isRequired(required?: boolean, errorMessage?: string): DateRangeSchema<T>;
-    distance(distanceOpts: DistanceOpts): DateRangeSchema<T>;
-  }
+type DistanceOpts = {
+  min?: DistanceValue;
+  max?: DistanceValue;
+};
 
-  export interface DateRangeSchemaConstructor {
-    (opts: DateRangeOpts): DateRangeSchema;
-    new (opts: DateRangeOpts): DateRangeSchema;
-  }
+interface DateRangeSchema<T extends DateRangeObject | null | undefined = DateRangeObject> extends MixedSchema<T> {
+  min(date: string, errorMessage?: string): DateRangeSchema<T>;
+  max(date: string, errorMessage?: string): DateRangeSchema<T>;
+  between(minDate: string, maxDate: string, errorMessage?: string): DateRangeSchema<T>;
+  isRequired(required?: boolean, errorMessage?: string): DateRangeSchema<T>;
+  distance(distanceOpts: DistanceOpts): DateRangeSchema<T>;
+}
 
-  export const dateRange: DateRangeSchemaConstructor;
+export interface DateRangeSchemaConstructor {
+  (opts?: DateRangeOpts): DateRangeSchema;
+  new (opts?: DateRangeOpts): DateRangeSchema;
 }
+
+export const dateRange: DateRangeSchemaConstructor;

package/types/index.d.ts

@@ -1,25 +1,28 @@
 import * as yup from 'yup';
-import './dateRange.d.ts';
-import './date.d.ts';
+
+import { dateRange } from './dateRange';
+import { avDate } from './date';
+
+export { avDate, dateRange };
 
 declare module 'yup' {
-  interface StringSchema<T extends string | null | undefined = string> extends Schema<T> {
+  interface StringSchema<T extends string | null | undefined = string> extends yup.StringSchema<T> {
     isRequired(required?: boolean, errorMessage?: string): StringSchema<T>;
     npi(errorMessage?: string): StringSchema<T>;
     phone(errorMessage?: string): StringSchema<T>;
   }
 
-  interface ArraySchema<T> extends BasicArraySchema<T[]> {
+  interface ArraySchema<T> extends yup.ArraySchema<T[]> {
     isRequired(required?: boolean, errorMessage?: string): ArraySchema<T>;
   }
 
-  interface NumberSchema<T extends number | null | undefined = number> extends Schema<T> {
+  interface NumberSchema<T extends number | null | undefined = number> extends yup.NumberSchema<T> {
     isRequired(required?: boolean, errorMessage?: string): NumberSchema<T>;
     npi(errorMessage?: string): NumberSchema<T>;
     phone(errorMessage?: string): NumberSchema<T>;
   }
 
-  interface ObjectSchema<T> extends Schema<T> {
-    isRequired(required?: boolean, errorMessage?: string): ObjectSchema<T>;
+  interface ObjectSchema<TShape extends Record<string, any>> extends yup.ObjectSchema<TShape> {
+    isRequired(required?: boolean, errorMessage?: string): ObjectSchema<TShape>;
   }
 }