@palmares/schemas 0.0.1

package/dist/esm/src/validators/string.js

@@ -0,0 +1,174 @@
+export function stringValidation() {
+    return {
+        type: 'medium',
+        callback: async (value, path, _options)=>{
+            return {
+                parsed: value,
+                errors: typeof value === 'string' ? [] : [
+                    {
+                        isValid: typeof value === 'string',
+                        code: 'string',
+                        path: path || [],
+                        message: 'The value must be a string. Received: ' + typeof value
+                    }
+                ]
+            };
+        }
+    };
+}
+export function maxLength(args) {
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = args.inclusive ? value.length <= args.value : value.length < args.value;
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'maxLength',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function minLength(args) {
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = args.inclusive ? value.length >= args.value : value.length > args.value;
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'minLength',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function endsWith(args) {
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = value.endsWith(args.value);
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'endsWith',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function startsWith(args) {
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = value.startsWith(args.value);
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'startsWith',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function includes(args) {
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = value.includes(args.value);
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'includes',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function regex(args) {
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = args.value.test(value);
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'regex',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function uuid(args) {
+    // const uuidRegex =
+    //   /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
+    const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = uuidRegex.test(value);
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'uuid',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}
+export function email(args) {
+    const emailRegex = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
+    return {
+        type: 'low',
+        callback: async (value, path, _options)=>{
+            const isValid = emailRegex.test(value);
+            return {
+                parsed: value,
+                errors: isValid ? [] : [
+                    {
+                        isValid: false,
+                        code: 'email',
+                        path: path || [],
+                        message: args.message
+                    }
+                ]
+            };
+        }
+    };
+}

package/dist/esm/src/validators/types.js

@@ -0,0 +1 @@
+export { };

package/dist/esm/src/validators/union.js

@@ -0,0 +1,38 @@
+export function unionValidation(schemas) {
+    return {
+        type: 'high',
+        callback: async (value, path, options)=>{
+            const parsedValues = {
+                parsed: value,
+                errors: []
+            };
+            const startingToInternalBubbleUpLength = options.toInternalToBubbleUp?.length || 0;
+            // eslint-disable-next-line ts/prefer-for-of
+            for(let i = 0; i < schemas.length; i++){
+                const schemaWithProtected = schemas[i];
+                const parsedData = await schemaWithProtected.__parse(value, path, options);
+                parsedValues.parsed = parsedData.parsed;
+                if (Array.isArray(parsedData.errors)) if (Array.isArray(parsedValues.errors)) parsedValues.errors.push(...parsedData.errors);
+                else parsedValues.errors = parsedData.errors;
+                const hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors = // eslint-disable-next-line ts/no-unnecessary-condition
+                parsedData.errors === undefined || (parsedData.errors || []).length === 0;
+                if (hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors) {
+                    return {
+                        parsed: parsedValues.parsed,
+                        errors: []
+                    };
+                } else if (startingToInternalBubbleUpLength < (options.toInternalToBubbleUp?.length || 0)) {
+                    // If there is a new toInternalToBubbleUp we should remove the ones that we added since this is not a valid schema,
+                    // we shouldn't be calling the `toInternal` on that schemas.
+                    const numberOfElementsToRemove = (options.toInternalToBubbleUp?.length || 0) - startingToInternalBubbleUpLength;
+                    options.toInternalToBubbleUp?.splice(startingToInternalBubbleUpLength, numberOfElementsToRemove);
+                }
+            }
+            return {
+                parsed: parsedValues.parsed,
+                // eslint-disable-next-line ts/no-unnecessary-condition
+                errors: parsedValues.errors ? parsedValues.errors : []
+            };
+        }
+    };
+}

package/dist/esm/src/validators/utils.js

@@ -0,0 +1,120 @@
+const priorityByType = {
+    low: 0,
+    medium: 1,
+    high: 2
+};
+const typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value])=>{
+    acc[value] = key;
+    return acc;
+}, {});
+/**
+ * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list has lower priority validators on the end of the list and higher
+ * priority validators on the start of the list. Maybe in the future we can change that to a binary tree, but for now this is enough.
+ *
+ * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3 times on the schema in order to make the validation work. Each validator had
+ * a different return type, i didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created this class. So pretty much, over here and
+ * on each validator we can define the type it is. It can actually be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last, the `high` validators
+ * are the ones that are going to be executed first. High validators validate if the value is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
+ *
+ * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number? No, right? So the high validator can stop the execution of the other validators.
+ * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the `max` allowed 10? No, right? So the medium validator can stop the execution of
+ * the other validators.
+ *
+ * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also more powerful, because if we need to add any extra priorities we can do that easily
+ * without changing the schema.
+ */ export default class Validator {
+    child;
+    parent;
+    priority;
+    fallbacks = [];
+    constructor(type){
+        this.priority = priorityByType[type];
+    }
+    /**
+   * We create all of the validators on the schema in order, i actually didn't want to go on that route but i found it easier to do so.
+   *
+   * The logic here is simple, if it's not the same priority we will walk on the linked list until we find a validator that matches the priority we are expecting. If we can't walk anymore, we create
+   * the next priority validator and append it to the linked list. Be aware that it's a double linked list, so we can walk both ways, from the end to the start and from the start to the end.
+   * So you don't really need to start from the root, the linked list can start from anywhere and it will find it's way through.
+   *
+   * I know there are better ways to do this instead of walking through the linked list, but like i explained before, this is enough for now.
+   *
+   * If the priority is higher than the current priority saved on the schema, we should substitute the rootValidator on the schema with the new one.
+   *
+   * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema.
+   * @param type - The type of the fallback that we are adding.
+   * @param fallback - The fallback function that we are adding.
+   * @param childOrParent - If we are adding a fallback to the child or to the parent.
+   * @param options - The options that we are passing to the fallback.
+   */ checkAppendOrCreate(schema, type, fallback, childOrParent, options) {
+        const schemaWithProtected = schema;
+        if (this[childOrParent]) this[childOrParent].addFallback(schemaWithProtected, type, fallback, options);
+        else {
+            const nextPriority = childOrParent === 'child' ? this.priority - 1 : this.priority + 1;
+            if (Object.keys(typeByPriority).includes(String(nextPriority))) {
+                const nextType = typeByPriority[nextPriority];
+                const validatorInstance = new Validator(nextType);
+                this[childOrParent] = validatorInstance;
+                this[childOrParent][childOrParent === 'parent' ? 'child' : 'parent'] = this;
+                this[childOrParent].addFallback(schemaWithProtected, type, fallback, options);
+                if (nextPriority > schemaWithProtected.__rootFallbacksValidator.priority) schemaWithProtected.__rootFallbacksValidator = validatorInstance;
+            }
+        }
+    }
+    addFallback(schema, type, fallback, options) {
+        const priority = priorityByType[type];
+        if (this.priority === priority) {
+            if (typeof options?.at === 'number') this.fallbacks.splice(options.at, options.removeCurrent === true ? 1 : 0, fallback);
+            else this.fallbacks.push(fallback);
+        } else if (priority > this.priority) this.checkAppendOrCreate(schema, type, fallback, 'parent', options);
+        else if (priority < this.priority) this.checkAppendOrCreate(schema, type, fallback, 'child', options);
+    }
+    /**
+   * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest priority to the lowest priority.
+   * A validator can stop the execution of the other validators if it feels like so. Like on the example of a value being null or undefined.
+   *
+   * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is used to avoid duplicated errors.
+   * @param path - The path that we are validating right now.
+   * @param parseResult - The result of the parsing, it contains the parsed value and the errors that we found.
+   * @param options - The options that we are passing to the fallback.
+   */ async validate(errorsAsHashedSet, path, parseResult, options) {
+        let doesItShouldPreventChildValidation = false;
+        for (const fallback of this.fallbacks){
+            const { parsed, errors, preventChildValidation } = await fallback(parseResult.parsed, path, options);
+            parseResult.parsed = parsed;
+            for (const error of errors){
+                if (error.isValid === false) {
+                    const hashedError = JSON.stringify(error);
+                    if (errorsAsHashedSet.has(hashedError)) continue;
+                    if (!Array.isArray(parseResult.errors)) parseResult.errors = [];
+                    parseResult.errors.push(error);
+                }
+            }
+            doesItShouldPreventChildValidation = doesItShouldPreventChildValidation || preventChildValidation || false;
+        }
+        if (this.child && doesItShouldPreventChildValidation === false) return this.child.validate(errorsAsHashedSet, path, parseResult, options);
+        return parseResult;
+    }
+    /**
+   * This static method takes care of everything for you. This means that you should only call this method for appending new fallbacks, it takes care of creating the root validator
+   * and making sure that the rootValidator on the schema is the highest priority one.
+   *
+   * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema. We automatically define the rootValidator on the schema
+   * so you don't need to worry about that.
+   * @param fallback - The fallback that we are adding. This is an object that contains the type of the fallback and the callback that we are adding.
+   * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent` are passed to the `addFallback` method.
+   */ static createAndAppendFallback(schema, fallback, options) {
+        const schemaWithProtected = schema;
+        let validatorInstance = schemaWithProtected.__rootFallbacksValidator;
+        // eslint-disable-next-line ts/no-unnecessary-condition
+        if (schemaWithProtected.__rootFallbacksValidator === undefined) {
+            validatorInstance = new Validator(fallback.type);
+            schemaWithProtected.__rootFallbacksValidator = validatorInstance;
+        }
+        validatorInstance.addFallback(schema, fallback.type, fallback.callback, options);
+        return validatorInstance;
+    }
+    toString(ident = 0) {
+        return `Priority: ${this.priority}\nFallbacks: ${this.fallbacks.length}\n${this.child ? `Children:\n${this.child.toString(ident + 2)}` : ''}`;
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@palmares/schemas",
+  "version": "0.0.1",
+  "description": "This defines a default schema definition for validation of data, it abstract popular schema validation libraries like zod, yup, valibot and others\"",
+  "main": "./dist/cjs/src/index.js",
+  "module": "./dist/esm/src/index.js",
+  "types": "./dist/cjs/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/cjs/types/index.d.ts",
+      "node": "./dist/cjs/src/index.js",
+      "require": "./dist/cjs/src/index.js",
+      "import": "./dist/esm/src/index.js",
+      "default": "./dist/esm/src/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/palmaresHQ/palmares.git"
+  },
+  "keywords": [
+    "palmares",
+    "schema",
+    "package"
+  ],
+  "type": "module",
+  "author": "Nicolas Melo",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/palmaresHQ/palmares/issues"
+  },
+  "homepage": "https://github.com/palmaresHQ/palmares#readme",
+  "dependencies": {
+    "@palmares/databases": "0.0.2",
+    "@palmares/core": "0.0.4"
+  },
+  "scripts": {
+    "clear": "rimraf ./dist",
+    "build:types": "tsc --project tsconfig.types.json",
+    "build:cjs": "swc ./src -d ./dist/cjs --config-file ../../build/.commonjs.swcrc",
+    "build:module": "swc ./src -d ./dist/esm --config-file ../../build/.esm.swcrc",
+    "build": "pnpm run clear && pnpm run build:cjs && pnpm run build:module && pnpm run build:types",
+    "build:types:watch": "tsc --project tsconfig.types.json --watch --preserveWatchOutput",
+    "build:cjs:watch": "swc ./src -d ./dist/cjs --config-file ../../build/.commonjs.swcrc --watch",
+    "build:module:watch": "swc ./src -d ./dist/esm --config-file ../../build/.esm.swcrc --watch",
+    "build:watch": "pnpm run build:cjs:watch & pnpm run build:module:watch & pnpm run build:types:watch"
+  }
+}

package/src/adapter/fields/array.ts

@@ -0,0 +1,31 @@
+import FieldAdapter from '.';
+
+import type WithFallback from '../../utils';
+import type { NumberAdapterTranslateArgs } from '../types';
+
+export function arrayFieldAdapter<
+  TTranslate extends ArrayFieldAdapter['translate'],
+  TToString extends ArrayFieldAdapter['toString'],
+  TFormatError extends ArrayFieldAdapter['formatError'],
+  TParse extends ArrayFieldAdapter['parse']
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
+  class CustomArrayFieldAdapter extends ArrayFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomArrayFieldAdapter as typeof ArrayFieldAdapter & {
+    new (): ArrayFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    };
+  };
+}
+
+export default class ArrayFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: NumberAdapterTranslateArgs): any | WithFallback<'array'> {}
+}

package/src/adapter/fields/boolean.ts

@@ -0,0 +1,48 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type SchemaAdapter from '..';
+import type WithFallback from '../../utils';
+import type { BooleanAdapterTranslateArgs } from '../types';
+
+export function booleanFieldAdapter<
+  TTranslate extends BooleanFieldAdapter['translate'],
+  TToString extends BooleanFieldAdapter['toString'],
+  TFormatError extends BooleanFieldAdapter['formatError'],
+  TParse extends BooleanFieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomBooleanFieldAdapter extends BooleanFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomBooleanFieldAdapter as typeof BooleanFieldAdapter & {
+    new (): BooleanFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+
+export default class BooleanFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: BooleanAdapterTranslateArgs): any | WithFallback<'boolean'> {}
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: BooleanAdapterTranslateArgs
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+}

package/src/adapter/fields/datetime.ts

@@ -0,0 +1,49 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type SchemaAdapter from '..';
+import type WithFallback from '../../utils';
+import type { DatetimeAdapterTranslateArgs } from '../types';
+
+
+export function datetimeFieldAdapter<
+  TTranslate extends DatetimeFieldAdapter['translate'],
+  TToString extends DatetimeFieldAdapter['toString'],
+  TFormatError extends DatetimeFieldAdapter['formatError'],
+  TParse extends DatetimeFieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomDatetimeFieldAdapter extends DatetimeFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomDatetimeFieldAdapter as typeof DatetimeFieldAdapter & {
+    new (): DatetimeFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+
+export default class DatetimeFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: DatetimeAdapterTranslateArgs): any | WithFallback<'datetime'> {}
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: DatetimeAdapterTranslateArgs
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+}

package/src/adapter/fields/index.ts

@@ -0,0 +1,72 @@
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type { SupportedSchemas } from '../../types';
+import type WithFallback from '../../utils';
+import type SchemaAdapter from '../index';
+import type { AdapterToStringArgs, AdapterTranslateArgs, ErrorCodes } from '../types';
+
+export function fieldAdapter<
+  TTranslate extends FieldAdapter['translate'],
+  TToString extends FieldAdapter['toString'],
+  TFormatError extends FieldAdapter['formatError'],
+  TParse extends FieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomFieldAdapter extends FieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomFieldAdapter as typeof FieldAdapter & {
+    new (): FieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+export default class FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: AdapterTranslateArgs<SupportedSchemas>, _base?: any): any | WithFallback<SupportedSchemas> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'translate' });
+  }
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: Omit<AdapterTranslateArgs<SupportedSchemas>, 'withFallback'>,
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+
+  toString(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _args: AdapterToStringArgs,
+    _base?: any
+  ): Promise<string> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'toString' });
+  }
+
+  // eslint-disable-next-line ts/require-await
+  async formatError(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _error: any,
+    _metadata?: any
+  ): Promise<{
+    message: string;
+    path: (string | number)[];
+    code: ErrorCodes;
+  }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'formatError' });
+  }
+}

package/src/adapter/fields/number.ts

@@ -0,0 +1,49 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type SchemaAdapter from '..';
+import type WithFallback from '../../utils';
+import type { NumberAdapterTranslateArgs } from '../types';
+
+
+export function numberFieldAdapter<
+  TTranslate extends NumberFieldAdapter['translate'],
+  TToString extends NumberFieldAdapter['toString'],
+  TFormatError extends NumberFieldAdapter['formatError'],
+  TParse extends NumberFieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomNumberFieldAdapter extends NumberFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomNumberFieldAdapter as typeof NumberFieldAdapter & {
+    new (): NumberFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+
+export default class NumberFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: NumberAdapterTranslateArgs): any | WithFallback<'number'> {}
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: NumberAdapterTranslateArgs
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+}