@palmares/schemas 0.0.1

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

@@ -0,0 +1,1788 @@
+"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 Schema;
+    },
+    schema: function() {
+        return schema;
+    }
+});
+var _conf = require("../conf");
+var _utils = require("../utils");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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 Schema = /*#__PURE__*/ function() {
+    "use strict";
+    function Schema() {
+        _class_call_check(this, Schema);
+        // Those functions will assume control of the validation process on adapters, instead of the schema. Why this is used? The idea is that the Schema has NO idea
+        // that one of it's children might be an UnionSchema for example. The adapter might not support unions, so then we give control to the union. The parent schema
+        // Will already have an array of translated adapter schemas. This means for a union with Number and String it'll generate two schemas, one for number and one for the value as String.
+        // Of course this gets multiplied. So if we have a union with Number and String. We should take those two schemas from the array and validate them individually. This logic is
+        // handled by the union schema. If we have an intersection type for example, instead of validating One schema OR the other, we validate one schema AND the other. This will be handled
+        // by the schema that contains that intersection logic.
+        _define_property(this, "__beforeValidationCallbacks", new Map());
+        _define_property(this, "__cachedGetParent", void 0);
+        _define_property(this, "__alreadyAppliedModel", false);
+        _define_property(this, "__runBeforeParseAndData", void 0);
+        _define_property(this, "__rootFallbacksValidator", void 0);
+        _define_property(this, "__saveCallback", void 0);
+        _define_property(this, "__modelOmitCallback", void 0);
+        _define_property(this, "__parsers", {
+            high: new Map(),
+            medium: new Map(),
+            low: new Map(),
+            _fallbacks: new Set()
+        });
+        _define_property(this, "__refinements", []);
+        _define_property(this, "__nullable", {
+            message: 'Cannot be null',
+            allow: false
+        });
+        _define_property(this, "__optional", {
+            message: 'Required',
+            allow: false
+        });
+        _define_property(this, "__extends", undefined);
+        _define_property(this, "__transformedSchemas", {});
+        _define_property(this, "__defaultFunction", undefined);
+        _define_property(this, "__toRepresentation", undefined);
+        _define_property(this, "__toValidate", undefined);
+        _define_property(this, "__toInternal", undefined);
+        _define_property(this, "__type", {
+            message: 'Invalid type',
+            check: function() {
+                return true;
+            }
+        });
+    }
+    _create_class(Schema, [
+        {
+            key: "__getParent",
+            get: function get() {
+                return this.__cachedGetParent;
+            },
+            set: function set(value) {
+                this.__cachedGetParent = value;
+            }
+        },
+        {
+            key: "__validateByFallbacks",
+            value: /**
+   * This will validate the data with the fallbacks, so internally, without relaying on the schema adapter. This is nice because we can support things that the schema adapter is not able to support by default.
+   *
+   * @param errorsAsHashedSet - The errors as a hashed set. This is used to prevent duplicate errors.
+   * @param path - The path of the error.
+   * @param parseResult - The result of the parse method.
+   */ function __validateByFallbacks(path, parseResult, options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        // eslint-disable-next-line ts/no-unnecessary-condition
+                        if (_this.__rootFallbacksValidator) return [
+                            2,
+                            _this.__rootFallbacksValidator.validate(options.errorsAsHashedSet || new Set(), path, parseResult, options)
+                        ];
+                        return [
+                            2,
+                            parseResult
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "__validateByAdapter",
+            value: /**
+   * This will validate by the adapter. In other words, we send the data to the schema adapter and then we validate that data.
+   * So understand that, first we send the data to the adapter, the adapter validates it, then, after we validate from the adapter
+   * we validate with the fallbacks so we can do all of the extra validations not handled by the adapter.
+   *
+   * @param value - The value to be validated.
+   * @param errorsAsHashedSet - The errors as a hashed set. This is used to prevent duplicate errors on the validator.
+   * @param path - The path of the error so we can construct an object with the nested paths of the error.
+   * @param parseResult - The result of the parse method.
+   *
+   * @returns The result and the errors of the parse method.
+   */ function __validateByAdapter(adapter, fieldAdapter, schema, value, path, options) {
+                return _async_to_generator(function() {
+                    var parseResult, adapterParseResult;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                parseResult = {
+                                    errors: [],
+                                    parsed: value
+                                };
+                                // On the next iteration we will reset the errors and the parsed value
+                                parseResult.errors = [];
+                                parseResult.parsed = value;
+                                // eslint-disable-next-line ts/no-unnecessary-condition
+                                if (fieldAdapter === undefined || typeof fieldAdapter.parse !== 'function') return [
+                                    2,
+                                    parseResult
+                                ];
+                                return [
+                                    4,
+                                    fieldAdapter.parse(adapter, adapter.field, schema.transformed, value, options.args)
+                                ];
+                            case 1:
+                                adapterParseResult = _state.sent();
+                                parseResult.parsed = adapterParseResult.parsed;
+                                if (!adapterParseResult.errors) return [
+                                    3,
+                                    5
+                                ];
+                                if (!Array.isArray(adapterParseResult.errors)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    Promise.all(adapterParseResult.errors.map(function() {
+                                        var _ref = _async_to_generator(function(error) {
+                                            return _ts_generator(this, function(_state) {
+                                                return [
+                                                    2,
+                                                    (0, _utils.formatErrorFromParseMethod)(adapter, fieldAdapter, error, path, options.errorsAsHashedSet || new Set())
+                                                ];
+                                            });
+                                        });
+                                        return function(error) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 2:
+                                parseResult.errors = _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                return [
+                                    4,
+                                    (0, _utils.formatErrorFromParseMethod)(adapter, fieldAdapter, parseResult.errors, path, options.errorsAsHashedSet || new Set())
+                                ];
+                            case 4:
+                                parseResult.errors = [
+                                    _state.sent()
+                                ];
+                                _state.label = 5;
+                            case 5:
+                                return [
+                                    2,
+                                    parseResult
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "__transformToAdapter",
+            value: // eslint-disable-next-line ts/require-await
+            function __transformToAdapter(_options) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        throw new Error('Not implemented');
+                    });
+                })();
+            }
+        },
+        {
+            key: "__parsersToTransformValue",
+            value: /** */ function __parsersToTransformValue(value, parsersToUse) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var shouldStop, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, parserName, parser, result, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value1, parserName1, parser1, result1, err, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _step_value2, parserName2, parser2, result2, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                shouldStop = false;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    7,
+                                    8,
+                                    9
+                                ]);
+                                _iterator = _this.__parsers.high.entries()[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    6
+                                ];
+                                _step_value = _sliced_to_array(_step.value, 2), parserName = _step_value[0], parser = _step_value[1];
+                                if (!(_instanceof(parsersToUse, Set) === false || parsersToUse.has(parserName))) return [
+                                    3,
+                                    4
+                                ];
+                                return [
+                                    4,
+                                    Promise.resolve(parser(value))
+                                ];
+                            case 3:
+                                result = _state.sent();
+                                if (result.preventNextParsers) shouldStop = true;
+                                value = result.value;
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 6:
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 7:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 8:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 9:
+                                if (!(shouldStop === false)) return [
+                                    3,
+                                    18
+                                ];
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                _state.label = 10;
+                            case 10:
+                                _state.trys.push([
+                                    10,
+                                    16,
+                                    17,
+                                    18
+                                ]);
+                                _iterator1 = _this.__parsers.medium.entries()[Symbol.iterator]();
+                                _state.label = 11;
+                            case 11:
+                                if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                                    3,
+                                    15
+                                ];
+                                _step_value1 = _sliced_to_array(_step1.value, 2), parserName1 = _step_value1[0], parser1 = _step_value1[1];
+                                if (!(_instanceof(parsersToUse, Set) === false || parsersToUse.has(parserName1))) return [
+                                    3,
+                                    13
+                                ];
+                                return [
+                                    4,
+                                    Promise.resolve(parser1(value))
+                                ];
+                            case 12:
+                                result1 = _state.sent();
+                                if (result1.preventNextParsers) shouldStop = true;
+                                value = result1.value;
+                                return [
+                                    3,
+                                    14
+                                ];
+                            case 13:
+                                return [
+                                    3,
+                                    14
+                                ];
+                            case 14:
+                                _iteratorNormalCompletion1 = true;
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 15:
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 16:
+                                err = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 17:
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 18:
+                                if (!(shouldStop === false)) return [
+                                    3,
+                                    27
+                                ];
+                                _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                _state.label = 19;
+                            case 19:
+                                _state.trys.push([
+                                    19,
+                                    25,
+                                    26,
+                                    27
+                                ]);
+                                _iterator2 = _this.__parsers.low.entries()[Symbol.iterator]();
+                                _state.label = 20;
+                            case 20:
+                                if (!!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done)) return [
+                                    3,
+                                    24
+                                ];
+                                _step_value2 = _sliced_to_array(_step2.value, 2), parserName2 = _step_value2[0], parser2 = _step_value2[1];
+                                if (!(_instanceof(parsersToUse, Set) === false || parsersToUse.has(parserName2))) return [
+                                    3,
+                                    22
+                                ];
+                                return [
+                                    4,
+                                    Promise.resolve(parser2(value))
+                                ];
+                            case 21:
+                                result2 = _state.sent();
+                                if (result2.preventNextParsers) shouldStop = true;
+                                value = result2.value;
+                                return [
+                                    3,
+                                    23
+                                ];
+                            case 22:
+                                return [
+                                    3,
+                                    23
+                                ];
+                            case 23:
+                                _iteratorNormalCompletion2 = true;
+                                return [
+                                    3,
+                                    20
+                                ];
+                            case 24:
+                                return [
+                                    3,
+                                    27
+                                ];
+                            case 25:
+                                err = _state.sent();
+                                _didIteratorError2 = true;
+                                _iteratorError2 = err;
+                                return [
+                                    3,
+                                    27
+                                ];
+                            case 26:
+                                try {
+                                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                        _iterator2.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError2) {
+                                        throw _iteratorError2;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 27:
+                                return [
+                                    2,
+                                    value
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "__parse",
+            value: function __parse(value) {
+                var path = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], options = arguments.length > 2 ? arguments[2] : void 0;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _options_schemaAdapter, shouldRunToInternalToBubbleUp, shouldCallDefaultFunction, shouldCallToValidateCallback, schemaAdapterFieldType, parseResult, adapterToUse, parsedResultsAfterFallbacks, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, callback, parsedValuesAfterValidationCallbacks, err, parsedValuesAfterValidatingByAdapter, doesNotHaveErrors, hasToInternalCallback, shouldCallToInternalDuringParse, hasNoErrors, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, functionToModifyResult, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!(typeof _this.__runBeforeParseAndData === 'function')) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    _this.__runBeforeParseAndData(_this)
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                // This is used to run the toInternal command. If we didn't do this, we would need to parse through all of the schemas to run the toInternal command,
+                                // from the leafs (ObjectSchemas) to the root schema. This is not a good idea, so what we do is that during validation the leafs attach a function to
+                                // the options.toInternalToBubbleUp like `options.toInternalToBubbleUp.push(async () => (value[key] = await (schema as any).__toInternal(parsed)));``
+                                // This way, when the root schema finishes the validation, it will run all of the functions in the toInternalToBubbleUp array, modifying the parsed value.
+                                shouldRunToInternalToBubbleUp = options.toInternalToBubbleUp === undefined;
+                                if (shouldRunToInternalToBubbleUp) options.toInternalToBubbleUp = [];
+                                if (_instanceof(options.errorsAsHashedSet, Set) === false) options.errorsAsHashedSet = new Set();
+                                shouldCallDefaultFunction = value === undefined && typeof _this.__defaultFunction === 'function';
+                                shouldCallToValidateCallback = typeof _this.__toValidate === 'function';
+                                schemaAdapterFieldType = _this.constructor.name.replace('Schema', '').toLowerCase();
+                                if (!shouldCallDefaultFunction) return [
+                                    3,
+                                    4
+                                ];
+                                return [
+                                    4,
+                                    _this.__defaultFunction()
+                                ];
+                            case 3:
+                                value = _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                if (!shouldCallToValidateCallback) return [
+                                    3,
+                                    6
+                                ];
+                                return [
+                                    4,
+                                    Promise.resolve(_this.__toValidate(value))
+                                ];
+                            case 5:
+                                value = _state.sent();
+                                _state.label = 6;
+                            case 6:
+                                parseResult = {
+                                    errors: [],
+                                    parsed: value
+                                };
+                                if (options.appendFallbacksBeforeAdapterValidation === undefined) options.appendFallbacksBeforeAdapterValidation = function(name, callback) {
+                                    _this.__beforeValidationCallbacks.set(name, callback);
+                                };
+                                if (!(_this.__transformedSchemas[((_options_schemaAdapter = options.schemaAdapter) === null || _options_schemaAdapter === void 0 ? void 0 : _options_schemaAdapter.constructor.name) || (0, _conf.getDefaultAdapter)().constructor.name].transformed === false)) return [
+                                    3,
+                                    8
+                                ];
+                                return [
+                                    4,
+                                    _this.__transformToAdapter(options)
+                                ];
+                            case 7:
+                                _state.sent();
+                                _state.label = 8;
+                            case 8:
+                                return [
+                                    4,
+                                    _this.__parsersToTransformValue(value, _this.__parsers._fallbacks)
+                                ];
+                            case 9:
+                                value = _state.sent();
+                                adapterToUse = options.schemaAdapter ? options.schemaAdapter : Object.values(_this.__transformedSchemas)[0].adapter;
+                                return [
+                                    4,
+                                    _this.__validateByFallbacks(path, {
+                                        errors: [],
+                                        parsed: value
+                                    }, options)
+                                ];
+                            case 10:
+                                parsedResultsAfterFallbacks = _state.sent();
+                                parseResult.parsed = parsedResultsAfterFallbacks.parsed;
+                                // eslint-disable-next-line ts/no-unnecessary-condition
+                                parseResult.errors = (parseResult.errors || []).concat(parsedResultsAfterFallbacks.errors || []);
+                                if (!(_this.__beforeValidationCallbacks.size > 0)) return [
+                                    3,
+                                    19
+                                ];
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 11;
+                            case 11:
+                                _state.trys.push([
+                                    11,
+                                    16,
+                                    17,
+                                    18
+                                ]);
+                                _iterator = _this.__beforeValidationCallbacks.values()[Symbol.iterator]();
+                                _state.label = 12;
+                            case 12:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    15
+                                ];
+                                callback = _step.value;
+                                return [
+                                    4,
+                                    callback(adapterToUse, adapterToUse[schemaAdapterFieldType], _this, _this.__transformedSchemas[adapterToUse.constructor.name].schemas, value, path, options)
+                                ];
+                            case 13:
+                                parsedValuesAfterValidationCallbacks = _state.sent();
+                                parseResult.parsed = parsedValuesAfterValidationCallbacks.parsed;
+                                parseResult.errors = parsedValuesAfterValidationCallbacks.errors;
+                                _state.label = 14;
+                            case 14:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 15:
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 16:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 17:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 18:
+                                return [
+                                    3,
+                                    21
+                                ];
+                            case 19:
+                                return [
+                                    4,
+                                    _this.__validateByAdapter(adapterToUse, adapterToUse[schemaAdapterFieldType], _this.__transformedSchemas[adapterToUse.constructor.name].schemas[0], value, path, options)
+                                ];
+                            case 20:
+                                parsedValuesAfterValidatingByAdapter = _state.sent();
+                                parseResult.parsed = parsedValuesAfterValidatingByAdapter.parsed;
+                                // eslint-disable-next-line ts/no-unnecessary-condition
+                                parseResult.errors = (parseResult.errors || []).concat(parsedValuesAfterValidatingByAdapter.errors);
+                                _state.label = 21;
+                            case 21:
+                                doesNotHaveErrors = !Array.isArray(parseResult.errors) || parseResult.errors.length === 0;
+                                hasToInternalCallback = typeof _this.__toInternal === 'function';
+                                shouldCallToInternalDuringParse = doesNotHaveErrors && hasToInternalCallback && Array.isArray(options.toInternalToBubbleUp) === false;
+                                // eslint-disable-next-line ts/no-unnecessary-condition
+                                hasNoErrors = parseResult.errors === undefined || (parseResult.errors || []).length === 0;
+                                return [
+                                    4,
+                                    Promise.all(_this.__refinements.map(function() {
+                                        var _ref = _async_to_generator(function(refinement) {
+                                            var errorOrNothing;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        return [
+                                                            4,
+                                                            Promise.resolve(refinement(parseResult.parsed))
+                                                        ];
+                                                    case 1:
+                                                        errorOrNothing = _state.sent();
+                                                        if (typeof errorOrNothing === 'undefined') return [
+                                                            2
+                                                        ];
+                                                        parseResult.errors.push({
+                                                            isValid: false,
+                                                            code: errorOrNothing.code,
+                                                            message: errorOrNothing.message,
+                                                            path: path
+                                                        });
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(refinement) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 22:
+                                _state.sent();
+                                if (!(shouldCallToInternalDuringParse && hasNoErrors)) return [
+                                    3,
+                                    24
+                                ];
+                                return [
+                                    4,
+                                    _this.__toInternal(value)
+                                ];
+                            case 23:
+                                parseResult.parsed = _state.sent();
+                                _state.label = 24;
+                            case 24:
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                if (!(shouldRunToInternalToBubbleUp && hasNoErrors)) return [
+                                    3,
+                                    32
+                                ];
+                                _state.label = 25;
+                            case 25:
+                                _state.trys.push([
+                                    25,
+                                    30,
+                                    31,
+                                    32
+                                ]);
+                                _iterator1 = (options.toInternalToBubbleUp || [])[Symbol.iterator]();
+                                _state.label = 26;
+                            case 26:
+                                if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                                    3,
+                                    29
+                                ];
+                                functionToModifyResult = _step1.value;
+                                return [
+                                    4,
+                                    functionToModifyResult()
+                                ];
+                            case 27:
+                                _state.sent();
+                                _state.label = 28;
+                            case 28:
+                                _iteratorNormalCompletion1 = true;
+                                return [
+                                    3,
+                                    26
+                                ];
+                            case 29:
+                                return [
+                                    3,
+                                    32
+                                ];
+                            case 30:
+                                err = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                                return [
+                                    3,
+                                    32
+                                ];
+                            case 31:
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 32:
+                                return [
+                                    2,
+                                    parseResult
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            /**
+   * 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.
+   */ key: "refine",
+            value: function refine(refinementCallback) {
+                this.__refinements.push(refinementCallback);
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                this.__optional = {
+                    message: typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : 'Required',
+                    allow: typeof (options === null || options === void 0 ? void 0 : options.allow) === 'boolean' ? options.allow : true
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                this.__nullable = {
+                    message: typeof (options === null || options === void 0 ? void 0 : options.message) === 'string' ? options.message : 'Cannot be null',
+                    allow: typeof (options === null || options === void 0 ? void 0 : options.allow) === 'boolean' ? options.allow : true
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * Appends a custom schema to the schema, this way it will bypass the creation of the schema in runtime.
+   *
+   * By default when validating, on the first validation we create the schema. Just during the first validation. With this function, you bypass that,
+   * so you can speed up the validation process.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   * import * as z from 'zod';
+   *
+   * const numberSchema = p.number().appendSchema(z.number());
+   *
+   * const { errors, parsed } = await numberSchema.parse(1);
+   * ```
+   *
+   * @param schema - The schema to be appended.
+   * @param args - The arguments for the schema.
+   * @param args.adapter - The adapter to be used. If not provided, the default adapter will be used.
+   *
+   * @returns The same schema again.
+   */ key: "appendSchema",
+            value: function appendSchema(schema, args) {
+                var adapter = (args === null || args === void 0 ? void 0 : args.adapter) || (0, _conf.getDefaultAdapter)();
+                this.__transformedSchemas[adapter.constructor.name] = {
+                    transformed: true,
+                    adapter: adapter,
+                    schemas: [
+                        schema
+                    ]
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                // To representation is true by default, unless to internal is true.
+                var toRepresentation = typeof (args === null || args === void 0 ? void 0 : args.toRepresentation) === 'boolean' ? args.toRepresentation : typeof (args === null || args === void 0 ? void 0 : args.toInternal) !== 'boolean';
+                var toInternal = typeof (args === null || args === void 0 ? void 0 : args.toInternal) === 'boolean' ? args.toInternal : false;
+                if (toInternal) {
+                    if (this.__toInternal) {
+                        var toInternal1 = this.__toInternal;
+                        this.__toInternal = function() {
+                            var _ref = _async_to_generator(function(value) {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                toInternal1(value)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                2,
+                                                undefined
+                                            ];
+                                    }
+                                });
+                            });
+                            return function(value) {
+                                return _ref.apply(this, arguments);
+                            };
+                        }();
+                    // eslint-disable-next-line ts/require-await
+                    } else this.__toInternal = /*#__PURE__*/ _async_to_generator(function() {
+                        return _ts_generator(this, function(_state) {
+                            return [
+                                2,
+                                undefined
+                            ];
+                        });
+                    });
+                } else if (toRepresentation) {
+                    if (this.__toRepresentation) {
+                        var toRepresentation1 = this.__toRepresentation;
+                        this.__toRepresentation = function() {
+                            var _ref = _async_to_generator(function(value) {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                toRepresentation1(value)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                2,
+                                                undefined
+                                            ];
+                                    }
+                                });
+                            });
+                            return function(value) {
+                                return _ref.apply(this, arguments);
+                            };
+                        }();
+                    // eslint-disable-next-line ts/require-await
+                    } else this.__toRepresentation = /*#__PURE__*/ _async_to_generator(function() {
+                        return _ts_generator(this, function(_state) {
+                            return [
+                                2,
+                                undefined
+                            ];
+                        });
+                    });
+                }
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                this.__saveCallback = callback;
+                return this;
+            }
+        },
+        {
+            key: "validate",
+            value: /**
+   * This function is used to validate the schema and save the value to the database. It is used in
+   * conjunction with the {@link onSave} function.
+   *
+   * Different from other validation libraries, palmares schemas is aware that you want to save. On your routes/functions
+   * we recommend to ALWAYS use this function instead of {@link parse} directly. This is because this function by default
+   * will return an object with the property `save` or the `errors`. If the errors are present, you can return the errors
+   * to the user. If the save property is present, you can use to save the value to an external source. e.g. a database.
+   *
+   * @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 value - The value to be validated.
+   *
+   * @returns An object with the property isValid, if the value is valid, the function `save` will be present.
+   * If the value is invalid, the property errors will be present.
+   */ function validate(value) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _ref, errors, parsed;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.__parse(value, [], {})
+                                ];
+                            case 1:
+                                _ref = _state.sent(), errors = _ref.errors, parsed = _ref.parsed;
+                                // eslint-disable-next-line ts/no-unnecessary-condition
+                                if ((errors || []).length <= 0) return [
+                                    2,
+                                    {
+                                        isValid: false,
+                                        errors: errors
+                                    }
+                                ];
+                                return [
+                                    2,
+                                    {
+                                        isValid: true,
+                                        save: /*#__PURE__*/ _async_to_generator(function() {
+                                            return _ts_generator(this, function(_state) {
+                                                return [
+                                                    2,
+                                                    _this._save.bind(_this)(parsed)
+                                                ];
+                                            });
+                                        })
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_save",
+            value: /**
+   * Internal function, when we call the {@link validate} function it's this function that gets called
+   * when the user uses the `save` function returned by the {@link validate} function if the value is valid.
+   *
+   * @param value - The value to be saved.
+   *
+   * @returns The value to representation.
+   */ function _save(value) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!_this.__saveCallback) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    _this.__saveCallback(value)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                return [
+                                    2,
+                                    _this.data(result)
+                                ];
+                            case 2:
+                                return [
+                                    2,
+                                    _this.data(value)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "parse",
+            value: /**
+   * This function is used to validate and parse the value to the internal representation of the schema.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const numberSchema = p.number().allowString();
+   *
+   * const { errors, parsed } = await numberSchema.parse('123');
+   *
+   * console.log(parsed); // 123
+   * ```
+   *
+   * @param value - The value to be parsed.
+   *
+   * @returns The parsed value.
+   */ function parse(value) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this.__parse(value, [], {})
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "data",
+            value: /**
+   * This function is used to transform the value to the representation without validating it.
+   * This is useful when you want to return a data from a query directly to the user. But for example
+   * you are returning the data of a user, you can clean the password or any other sensitive data.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const userSchema = p.object({
+   *   id: p.number().optional(),
+   *   name: p.string(),
+   *   email: p.string().email(),
+   *   password: p.string().optional()
+   * }).toRepresentation(async (value) => {
+   *   return {
+   *    id: value.id,
+   *    name: value.name,
+   *   email: value.email
+   *  }
+   * });
+   *
+   * const user = await userSchema.data({
+   *   id: 1,
+   *   name: 'John Doe',
+   *   email: 'john@gmail.com',
+   *   password: '123456'
+   * });
+   * ```
+   */ function data(value) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!(typeof _this.__runBeforeParseAndData === 'function')) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    _this.__runBeforeParseAndData(_this)
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                return [
+                                    4,
+                                    _this.__parsersToTransformValue(value)
+                                ];
+                            case 3:
+                                value = _state.sent();
+                                if (!_this.__toRepresentation) return [
+                                    3,
+                                    5
+                                ];
+                                return [
+                                    4,
+                                    Promise.resolve(_this.__toRepresentation(value))
+                                ];
+                            case 4:
+                                value = _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                if (!(_this.__defaultFunction && value === undefined)) return [
+                                    3,
+                                    7
+                                ];
+                                return [
+                                    4,
+                                    Promise.resolve(_this.__defaultFunction())
+                                ];
+                            case 6:
+                                value = _state.sent();
+                                _state.label = 7;
+                            case 7:
+                                return [
+                                    2,
+                                    value
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "instanceOf",
+            value: function instanceOf(args) {
+                this.__type.check = typeof args.check === 'function' ? args.check : this.__type.check;
+                this.__type.message = typeof args.message === 'string' ? args.message : this.__type.message;
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                var isFunction = typeof defaultValueOrFunction === 'function';
+                if (isFunction) this.__defaultFunction = defaultValueOrFunction;
+                else this.__defaultFunction = /*#__PURE__*/ _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            defaultValueOrFunction
+                        ];
+                    });
+                });
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                this.__extends = {
+                    callback: callback,
+                    toStringCallback: toStringCallback
+                };
+                return this;
+            }
+        },
+        {
+            /**
+   * 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.
+   * @param options - Options for the toRepresentation function.
+   * @param options.after - Whether the toRepresentationCallback should be called after the existing toRepresentationCallback. Defaults to true.
+   * @param options.before - Whether the toRepresentationCallback should be called before the existing toRepresentationCallback. Defaults to true.
+   *
+   * @returns The schema with a new return type
+   */ key: "toRepresentation",
+            value: function toRepresentation(toRepresentationCallback, options) {
+                if (this.__toRepresentation) {
+                    var before = typeof (options === null || options === void 0 ? void 0 : options.before) === 'boolean' ? options.before : typeof (options === null || options === void 0 ? void 0 : options.after) === 'boolean' ? !options.after : true;
+                    var existingToRepresentation = this.__toRepresentation;
+                    console.log('existing to representation', existingToRepresentation, before, options === null || options === void 0 ? void 0 : options.after);
+                    this.__toRepresentation = function() {
+                        var _ref = _async_to_generator(function(value) {
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        if (!before) return [
+                                            3,
+                                            2
+                                        ];
+                                        return [
+                                            4,
+                                            existingToRepresentation(value)
+                                        ];
+                                    case 1:
+                                        return [
+                                            2,
+                                            toRepresentationCallback.apply(void 0, [
+                                                _state.sent()
+                                            ])
+                                        ];
+                                    case 2:
+                                        return [
+                                            4,
+                                            toRepresentationCallback(value)
+                                        ];
+                                    case 3:
+                                        return [
+                                            2,
+                                            existingToRepresentation.apply(void 0, [
+                                                _state.sent()
+                                            ])
+                                        ];
+                                    case 4:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        });
+                        return function(value) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }();
+                } else this.__toRepresentation = toRepresentationCallback;
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                if (this.__toInternal) {
+                    var toInternal = this.__toInternal;
+                    this.__toInternal = function() {
+                        var _ref = _async_to_generator(function(value) {
+                            var newValue;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            toInternal(value)
+                                        ];
+                                    case 1:
+                                        newValue = _state.sent();
+                                        return [
+                                            2,
+                                            toInternalCallback(newValue)
+                                        ];
+                                }
+                            });
+                        });
+                        return function(value) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }();
+                } else this.__toInternal = toInternalCallback;
+                return this;
+            }
+        },
+        {
+            /**
+   * 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) {
+                this.__toValidate = toValidateCallback;
+                return this;
+            }
+        },
+        {
+            key: "compile",
+            value: /**
+   * Used to transform the given schema on a stringfied version of the adapter.
+   */ function compile(adapter) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var data, stringVersions;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.__transformToAdapter({
+                                        shouldAddStringVersion: true,
+                                        force: true
+                                    })
+                                ];
+                            case 1:
+                                data = _state.sent();
+                                stringVersions = data.map(function(value) {
+                                    return value.asString;
+                                });
+                                return [
+                                    2,
+                                    stringVersions
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            key: "new",
+            value: function _new() {
+                for(var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++){
+                    _args[_key] = arguments[_key];
+                }
+                var result = new Schema();
+                var adapterInstance = (0, _conf.getDefaultAdapter)();
+                result.__transformedSchemas[adapterInstance.constructor.name] = {
+                    transformed: false,
+                    adapter: adapterInstance,
+                    schemas: []
+                };
+                return result;
+            }
+        }
+    ]);
+    return Schema;
+}();
+var schema = Schema.new;