@palmares/schemas 0.0.1

package/dist/cjs/src/schema/number.js

@@ -0,0 +1,960 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return NumberSchema;
+    },
+    number: function() {
+        return number;
+    }
+});
+var _schema = /*#__PURE__*/ _interop_require_default(require("./schema"));
+var _conf = require("../conf");
+var _constants = require("../constants");
+var _utils = require("../utils");
+var _number = require("../validators/number");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var NumberSchema = /*#__PURE__*/ function(Schema) {
+    "use strict";
+    _inherits(NumberSchema, Schema);
+    var _super = _create_super(NumberSchema);
+    function NumberSchema() {
+        _class_call_check(this, NumberSchema);
+        var _this;
+        _this = _super.apply(this, arguments);
+        _define_property(_assert_this_initialized(_this), "__is", void 0);
+        _define_property(_assert_this_initialized(_this), "__integer", void 0);
+        _define_property(_assert_this_initialized(_this), "__maxDigits", void 0);
+        _define_property(_assert_this_initialized(_this), "__decimalPlaces", void 0);
+        _define_property(_assert_this_initialized(_this), "__max", void 0);
+        _define_property(_assert_this_initialized(_this), "__min", void 0);
+        _define_property(_assert_this_initialized(_this), "__allowNegative", void 0);
+        _define_property(_assert_this_initialized(_this), "__allowPositive", void 0);
+        return _this;
+    }
+    _create_class(NumberSchema, [
+        {
+            key: "__transformToAdapter",
+            value: function __transformToAdapter(options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            (0, _utils.defaultTransformToAdapter)(function() {
+                                var _ref = _async_to_generator(function(adapter) {
+                                    return _ts_generator(this, function(_state) {
+                                        return [
+                                            2,
+                                            (0, _utils.defaultTransform)('number', _this, adapter, adapter.number, function() {
+                                                return {
+                                                    is: _this.__is,
+                                                    min: _this.__min,
+                                                    allowNegative: _this.__allowNegative,
+                                                    allowPositive: _this.__allowPositive,
+                                                    max: _this.__max,
+                                                    integer: _this.__integer,
+                                                    optional: _this.__optional,
+                                                    nullable: _this.__nullable,
+                                                    maxDigits: _this.__maxDigits,
+                                                    decimalPlaces: _this.__decimalPlaces,
+                                                    parsers: {
+                                                        nullable: _this.__nullable.allow,
+                                                        optional: _this.__optional.allow
+                                                    }
+                                                };
+                                            }, {
+                                                max: _number.max,
+                                                min: _number.min
+                                            }, {
+                                                validatorsIfFallbackOrNotSupported: (0, _number.numberValidation)(),
+                                                shouldAddStringVersion: options.shouldAddStringVersion,
+                                                // eslint-disable-next-line ts/require-await
+                                                fallbackIfNotSupported: /*#__PURE__*/ _async_to_generator(function() {
+                                                    return _ts_generator(this, function(_state) {
+                                                        return [
+                                                            2,
+                                                            []
+                                                        ];
+                                                    });
+                                                })
+                                            })
+                                        ];
+                                    });
+                                });
+                                return function(adapter) {
+                                    return _ref.apply(this, arguments);
+                                };
+                            }(), _this.__transformedSchemas, options, 'number')
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            /**
+   * This let's you refine the schema with custom validations. This is useful when you want to validate something that is not supported by default by the schema adapter.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const numberSchema = p.number().refine((value) => {
+   *   if (value < 0) return { code: 'invalid_number', message: 'The number should be greater than 0' };
+   * });
+   *
+   * const { errors, parsed } = await numberSchema.parse(-1);
+   *
+   * console.log(errors); // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   * ```
+   *
+   * @param refinementCallback - The callback that will be called to validate the value.
+   * @param options - Options for the refinement.
+   * @param options.isAsync - Whether the callback is async or not. Defaults to true.
+   *
+   * @returns The schema.
+   */ key: "refine",
+            value: function refine(refinementCallback) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "refine", this).call(this, refinementCallback);
+            }
+        },
+        {
+            /**
+   * Allows the value to be either undefined or null.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const numberSchema = p.number().optional();
+   *
+   * const { errors, parsed } = await numberSchema.parse(undefined);
+   *
+   * console.log(parsed); // undefined
+   *
+   * const { errors, parsed } = await numberSchema.parse(null);
+   *
+   * console.log(parsed); // null
+   *
+   * const { errors, parsed } = await numberSchema.parse(1);
+   *
+   * console.log(parsed); // 1
+   * ```
+   *
+   * @returns - The schema we are working with.
+   */ key: "optional",
+            value: function optional(options) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "optional", this).call(this, options);
+            }
+        },
+        {
+            /**
+   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value is NULL by setting
+   * the { message: 'Your custom message', allow: false } on the options.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const numberSchema = p.number().nullable();
+   *
+   * const { errors, parsed } = await numberSchema.parse(null);
+   *
+   * console.log(parsed); // null
+   *
+   * const { errors, parsed } = await numberSchema.parse(undefined);
+   *
+   * console.log(errors); // [{ isValid: false, code: 'invalid_type', message: 'Invalid type', path: [] }]
+   * ```
+   *
+   * @param options - The options for the nullable function.
+   * @param options.message - The message to be shown when the value is not null. Defaults to 'Cannot be null'.
+   * @param options.allow - Whether the value can be null or not. Defaults to true.
+   *
+   * @returns The schema.
+   */ key: "nullable",
+            value: function nullable(options) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "nullable", this).call(this, options);
+            }
+        },
+        {
+            /**
+   * This method will remove the value from the representation of the schema. If the value is undefined it will keep that way
+   * otherwise it will set the value to undefined after it's validated.
+   * This is used in conjunction with the {@link data} function, the {@link parse} function or {@link validate}
+   * function. This will remove the value from the representation of the schema.
+   *
+   * By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
+   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
+   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const userSchema = p.object({
+   *   id: p.number().optional(),
+   *   name: p.string(),
+   *   password: p.string().omit()
+   * });
+   *
+   * const user = await userSchema.data({
+   *  id: 1,
+   *  name: 'John Doe',
+   *  password: '123456'
+   * });
+   *
+   * console.log(user); // { id: 1, name: 'John Doe' }
+   * ```
+   *
+   *
+   * @param args - By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
+   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
+   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   *
+   * @returns The schema.
+   */ key: "omit",
+            value: function omit(args) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "omit", this).call(this, args);
+            }
+        },
+        {
+            /**
+   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external source
+   * like a database. You should always return the schema after you save the value, that way we will always have the correct type
+   * of the schema after the save operation.
+   *
+   * You can use the {@link toRepresentation} function to transform and clean the value it returns after the save.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * import { User } from './models';
+   *
+   * const userSchema = p.object({
+   *   id: p.number().optional(),
+   *   name: p.string(),
+   *   email: p.string().email(),
+   * }).onSave(async (value) => {
+   *   // Create or update the user on the database using palmares models or any other library of your choice.
+   *   if (value.id)
+   *      await User.default.set(value, { search: { id: value.id } });
+   *   else
+   *      await User.default.set(value);
+   *
+   *   return value;
+   * });
+   *
+   *
+   * // Then, on your controller, do something like this:
+   * const { isValid, save, errors } = await userSchema.validate(req.body);
+   * if (isValid) {
+   *    const savedValue = await save();
+   *    return Response.json(savedValue, { status: 201 });
+   * }
+   *
+   * return Response.json({ errors }, { status: 400 });
+   * ```
+   *
+   * @param callback - The callback that will be called to save the value on an external source.
+   *
+   * @returns The schema.
+   */ key: "onSave",
+            value: function onSave(callback) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "onSave", this).call(this, callback);
+            }
+        },
+        {
+            /**
+   * This function is used to add a default value to the schema. If the value is either undefined or null, the default value will be used.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const numberSchema = p.number().default(0);
+   *
+   * const { errors, parsed } = await numberSchema.parse(undefined);
+   *
+   * console.log(parsed); // 0
+   * ```
+   */ key: "default",
+            value: function _default(defaultValueOrFunction) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "default", this).call(this, defaultValueOrFunction);
+            }
+        },
+        {
+            /**
+   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call this function to let you customize
+   * the custom schema your own way. Our API does not support passthrough? No problem, you can use this function to customize the zod schema.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const numberSchema = p.number().extends((schema) => {
+   *   return schema.nonnegative();
+   * });
+   *
+   * const { errors, parsed } = await numberSchema.parse(-1);
+   *
+   * console.log(errors); // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * ```
+   *
+   * @param callback - The callback that will be called to customize the schema.
+   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want to compile the underlying schema
+   * to a string so you can save it for future runs.
+   *
+   * @returns The schema.
+   */ key: "extends",
+            value: function _extends(callback, toStringCallback) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "extends", this).call(this, callback, toStringCallback);
+            }
+        },
+        {
+            /**
+   * This function is used to transform the value to the representation of the schema. When using the {@link data} function. With this function you have full
+   * control to add data cleaning for example, transforming the data and whatever. Another use case is when you want to return deeply nested recursive data.
+   * The schema maps to itself.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const recursiveSchema = p.object({
+   *   id: p.number().optional(),
+   *   name: p.string(),
+   * }).toRepresentation(async (value) => {
+   *    return {
+   *      id: value.id,
+   *      name: value.name,
+   *      children: await Promise.all(value.children.map(async (child) => await recursiveSchema.data(child)))
+   *    }
+   * });
+   *
+   * const data = await recursiveSchema.data({
+   *    id: 1,
+   *    name: 'John Doe',
+   * });
+   * ```
+   *
+   * @example
+   * ```
+   * import * as p from '@palmares/schemas';
+   *
+   * const colorToRGBSchema = p.string().toRepresentation(async (value) => {
+   *    switch (value) {
+   *      case 'red': return { r: 255, g: 0, b: 0 };
+   *      case 'green': return { r: 0, g: 255, b: 0 };
+   *      case 'blue': return { r: 0, g: 0, b: 255 };
+   *      default: return { r: 0, g: 0, b: 0 };
+   *   }
+   * });
+   * ```
+   * @param toRepresentationCallback - The callback that will be called to transform the value to the representation.
+   *
+   * @returns The schema with a new return type
+   */ key: "toRepresentation",
+            value: function toRepresentation(toRepresentationCallback) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "toRepresentation", this).call(this, toRepresentationCallback);
+            }
+        },
+        {
+            /**
+   * This function is used to transform the value to the internal representation of the schema. This is useful when you want to transform the value
+   * to a type that the schema adapter can understand. For example, you might want to transform a string to a date. This is the function you use.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const dateSchema = p.string().toInternal((value) => {
+   *   return new Date(value);
+   * });
+   *
+   * const date = await dateSchema.parse('2021-01-01');
+   *
+   * console.log(date); // Date object
+   *
+   * const rgbToColorSchema = p.object({
+   *   r: p.number().min(0).max(255),
+   *   g: p.number().min(0).max(255),
+   *   b: p.number().min(0).max(255),
+   * }).toInternal(async (value) => {
+   *    if (value.r === 255 && value.g === 0 && value.b === 0) return 'red';
+   *    if (value.r === 0 && value.g === 255 && value.b === 0) return 'green';
+   *    if (value.r === 0 && value.g === 0 && value.b === 255) return 'blue';
+   *    return `rgb(${value.r}, ${value.g}, ${value.b})`;
+   * });
+   * ```
+   *
+   * @param toInternalCallback - The callback that will be called to transform the value to the internal representation.
+   *
+   * @returns The schema with a new return type.
+   */ key: "toInternal",
+            value: function toInternal(toInternalCallback) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "toInternal", this).call(this, toInternalCallback);
+            }
+        },
+        {
+            /**
+   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string, you can convert that string to a date
+   * here BEFORE the validation. This pretty much transforms the value to a type that the schema adapter can understand.
+   *
+   * @example
+   * ```
+   * import * as p from '@palmares/schemas';
+   * import * as z from 'zod';
+   *
+   * const customRecordToMapSchema = p.schema().appendSchema(z.map()).toValidate(async (value) => {
+   *    return new Map(value); // Before validating we transform the value to a map.
+   * });
+   *
+   * const { errors, parsed } = await customRecordToMapSchema.parse({ key: 'value' });
+   * ```
+   *
+   * @param toValidateCallback - The callback that will be called to validate the value.
+   *
+   * @returns The schema with a new return type.
+   */ key: "toValidate",
+            value: function toValidate(toValidateCallback) {
+                return _get(_get_prototype_of(NumberSchema.prototype), "toValidate", this).call(this, toValidateCallback);
+            }
+        },
+        {
+            /**
+   * Defines a list of numbers that are allowed, it's not a range but the actual numbers that are allowed, it's useful
+   * when you want to allow only specific set of numbers.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schema';
+   *
+   * const schema = p.number().is([1, 2, 3]);
+   *
+   * schema.parse(1); // { errors: [], parsed: 1 }
+   * schema.parse(2); // { errors: [], parsed: 2 }
+   * schema.parse(3); // { errors: [], parsed: 3 }
+   * schema.parse(4); // { errors: [{ code: 'is', message: 'The value should be equal to 1,2,3' }], parsed: 4 }
+   * ```
+   *
+   * @param value - The list of numbers that are allowed
+   *
+   * @returns - The schema instance
+   */ key: "is",
+            value: function is(value) {
+                this.__is = {
+                    value: value,
+                    message: "The value should be equal to ".concat(value.join(','))
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * Allows only numbers that are less than the value passed. If you want to allow the number to be equal to the value, you can pass the option `inclusive` as `true`.
+   * Otherwise, it will only allow numbers less than the value.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schema';
+   *
+   * const schema = p.number().max(10);
+   *
+   * schema.parse(10); // { errors: [{ code: 'max', message: 'The number should be less than 10' }], parsed: 10 }
+   * schema.parse(9); // { errors: [], parsed: 9 }
+   *
+   * const schema = p.number().max(10, { inclusive: true });
+   *
+   * schema.parse(10); // { errors: [], parsed: 10 }
+   * ```
+   *
+   * @param value - The value to compare with the number
+   * @param options - The options to be passed to the validation
+   * @param options.inclusive - If you want to allow the number to be equal to the value, you can pass this option
+   * @param options.message - The message to be returned if the validation fails
+   *
+   * @returns - The schema instance
+   */ key: "max",
+            value: function max(value, options) {
+                var inclusive = typeof (options === null || options === void 0 ? void 0 : options.inclusive) === 'boolean' ? options.inclusive : false;
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : (0, _constants.DEFAULT_NUMBER_MAX_EXCEPTION)(value, inclusive);
+                this.__max = {
+                    value: value,
+                    inclusive: inclusive,
+                    message: message
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * This method will validate if the number is greater than the value passed. If you want to allow the number to be equal to the value, you can pass the option `inclusive` as `true`.
+   * Otherwise, it will only allow numbers greater than the value.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schema';
+   *
+   * const schema = p.number().min(10);
+   *
+   * schema.parse(10); // { errors: [], parsed: 10 }
+   * schema.parse(9); // { errors: [{ code: 'min', message: 'The number should be greater than 10' }], parsed: 9 }
+   *
+   * const schema = p.number().min(10, { inclusive: true });
+   *
+   * schema.parse(10); // { errors: [], parsed: 10 }
+   * ```
+   *
+   * @param value - The value to compare with the number
+   * @param options - The options to be passed to the validation
+   * @param options.inclusive - If you want to allow the number to be equal to the value, you can pass this option
+   * @param options.message - The message to be returned if the validation fails
+   *
+   * @returns - The schema instance
+   */ key: "min",
+            value: function min(value, options) {
+                var inclusive = typeof (options === null || options === void 0 ? void 0 : options.inclusive) === 'boolean' ? options.inclusive : false;
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : (0, _constants.DEFAULT_NUMBER_MIN_EXCEPTION)(value, inclusive);
+                this.__min = {
+                    value: value,
+                    inclusive: inclusive,
+                    message: message
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * Allows only negative numbers. If you want to allow zero, you can pass the option `allowZero` as `true`. Otherwise, it will only allow negative numbers.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schema';
+   *
+   * const schema = p.number().negative();
+   *
+   * schema.parse(-10); // { errors: [], parsed: -10 }
+   * schema.parse(0); // { errors: [{ code: 'negative', message: 'The number should be negative' }], parsed: 0 }
+   *
+   * const schema = p.number().negative({ allowZero: true });
+   *
+   * schema.parse(0); // { errors: [], parsed: 0 }
+   * ```
+   *
+   * @param options - The options to be passed to the validation
+   * @param options.allowZero - If you want to allow zero, you can pass this option as `true`. Otherwise, it will only allow negative numbers.
+   * @param options.message - The message to be returned if the validation fails
+   *
+   * @returns - The schema instance
+   */ key: "negative",
+            value: function negative(options) {
+                var allowZero = typeof (options === null || options === void 0 ? void 0 : options.allowZero) === 'boolean' ? options.allowZero : true;
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : (0, _constants.DEFAULT_NUMBER_NEGATIVE_EXCEPTION)(allowZero);
+                this.__allowNegative = {
+                    allowZero: allowZero,
+                    message: message
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * Allows only positive numbers. If you want to allow zero, you can pass the option `allowZero` as `true`. Otherwise, it will only allow positive numbers greater than zero.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schema';
+   *
+   * const schema = p.number().positive();
+   *
+   * schema.parse(10); // { errors: [], parsed: 10 }
+   * schema.parse(0); // { errors: [{ code: 'positive', message: 'The number should be positive' }], parsed: 0 }
+   *
+   * const schema = p.number().positive({ allowZero: true });
+   * schema.parse(0); // { errors: [], parsed: 0 }
+   * ```
+   *
+   * @param options - The options to be passed to the validation
+   * @param options.allowZero - If you want to allow zero, you can pass this option as `true`. Otherwise, it will only allow positive numbers greater than zero.
+   * @param options.message - The message to be returned if the validation fails
+   *
+   * @returns - The schema instance
+   */ key: "positive",
+            value: function positive(options) {
+                var allowZero = typeof (options === null || options === void 0 ? void 0 : options.allowZero) === 'boolean' ? options.allowZero : true;
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : (0, _constants.DEFAULT_NUMBER_NEGATIVE_EXCEPTION)(allowZero);
+                this.__allowPositive = {
+                    allowZero: allowZero,
+                    message: message
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * This method will validate the number to have the exact number of decimal places. It's usually useful for decimal numbers like currencies.
+   *
+   * @example
+   * ```
+   * const schema = number().decimalPlaces(2);
+   *
+   * schema.parse(10.00); // { errors: [], parsed: 10.00}
+   *
+   * schema.parse(10.000); // { errors: [{ code: 'decimal_places', message: 'The number should have 2 decimal places' }], parsed: 10.000}
+   * ```
+   *
+   * @param value - The number of decimal places.
+   * @param options - The options.
+   * @param options.message - The message to show if the validation fails.
+   *
+   * @returns The schema so you can chain other methods.
+   */ key: "decimalPlaces",
+            value: function decimalPlaces(value, options) {
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : "The number should have ".concat(value, " decimal places");
+                this.__decimalPlaces = {
+                    value: value,
+                    message: message
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * This method will validate the number to have at most the number of digits specified. If used in conjunction with {@link decimalPlaces}, this number should be bigger than the
+   * value of the decimal places.
+   *
+   * Think about that
+   *
+   * - If you have a number with 2 decimal places, the number 10.00 has 4 digits and 2 decimal places.
+   * - The number 10.000 has 5 digits and 3 decimal places.
+   *
+   * @example
+   * ```
+   * const schema = number().maxDigits(4);
+   *
+   * schema.parse(10); // { errors: [], parsed: 10}
+   * schema.parse(100); // { errors: [], parsed: 100}
+   * schema.parse(1000); // { errors: [], parsed: 1000}
+   * ```
+   *
+   * @param value - The maximum number of digits, counting the digits before and after the decimal point.
+   * @param options - Custom options for the validation.
+   * @param options.message - The message to show if the validation fails.
+   *
+   * @returns - The schema so you can chain other methods.
+   */ key: "maxDigits",
+            value: function maxDigits(value, options) {
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : "The number should have at most ".concat(value, " digits");
+                this.__maxDigits = {
+                    value: value,
+                    message: message
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * With this method we will validate if the number is an integer. If it's not, we will return an error.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schema';
+   *
+   * const schema = p.number().integer();
+   *
+   * schema.parse(10); // { errors: [], parsed: 10 }
+   * schema.parse(10.1); // { errors: [{ code: 'integer', message: 'The number should be an integer' }], parsed: 10.1 }
+   * ```
+   *
+   * @param options - The options to be passed to the validation
+   * @param options.message - The message to be returned if the validation fails
+   *
+   * @returns - The schema instance
+   */ key: "integer",
+            value: function integer(options) {
+                var message = typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : (0, _constants.DEFAULT_NUMBER_INTEGER_EXCEPTION)();
+                this.__integer = {
+                    message: message
+                };
+                return this;
+            }
+        }
+    ], [
+        {
+            key: "new",
+            value: function _new() {
+                var returnValue = new NumberSchema();
+                var adapterInstance = (0, _conf.getDefaultAdapter)();
+                returnValue.__transformedSchemas[adapterInstance.constructor.name] = {
+                    transformed: false,
+                    adapter: adapterInstance,
+                    schemas: []
+                };
+                return returnValue;
+            }
+        }
+    ]);
+    return NumberSchema;
+}(_schema.default);
+var number = function() {
+    return NumberSchema.new();
+};