structure-verifier 0.0.15 → 0.0.17

package/README.md

@@ -1,422 +1,570 @@
-# structure-verifier 0.0.9
+# structure-verifier
 
-structure-verifier is a typescript library to validate data of "any" type and to ensure that it corresponds to a data type.
+Libreria de validacion para TypeScript orientada a esquemas declarativos, tipado inferido y errores detallados por ruta.
 
-## Installation
+Ideal para validar payloads de API, formularios, configuraciones y estructuras anidadas complejas.
+
+Version actual: 0.0.17
+
+## Contenido
+
+- Caracteristicas
+- Instalacion
+- Inicio rapido
+- Conceptos base
+- API publica
+- Referencia completa de validadores
+- Transformaciones de valores
+- Tipado inferido
+- Manejo de errores
+- Ejemplos avanzados
+- Scripts de desarrollo
+
+## Caracteristicas
+
+- Validadores para number, string, boolean, uuid, date, array, object y any.
+- Soporte para estructuras anidadas con errores por ruta.
+- API fluida por clases y API de fabrica mediante Verifiers.
+- Tipado inferido en compile-time para mantener consistencia del dominio.
+- Personalizacion de mensajes por regla y por validador.
+- Integracion con dayjs (exportado como datetime) para manejo de fechas.
+
+## Instalacion
 
 ```bash
-    npm install structure-verifier
+npm install structure-verifier
 ```
 
-## Example use
+## Inicio rapido
 
-```typescript
+```ts
 import { Verifiers as V, VerificationError } from "structure-verifier";
-//////////Verificator object creation
-const v = new V.Number();
-/////////Running validations
 
-try {
-    let value = v.check(10);
-    /////////Will get the value without error
-} catch (error:any) {
-    console.log(error as VerificationError);
-}
+const userVerifier = V.ObjectNotNull(
+  {
+    id: V.UUIDNotNull({ version: 4 }),
+    name: V.StringNotNull({ minLength: 2 }),
+    age: V.Number({ min: 0 }),
+    active: V.BooleanNotNull(),
+    tags: V.ArrayNotNull(V.StringNotNull()).minLength(1),
+  },
+  {
+    strictMode: true,
+  },
+);
 
 try {
-    let value = v.check('TEST');
-} catch (error:any) {
-    ///////////Will get the error, because the value is not a number
-    console.log(error as VerificationError);
+  const user = userVerifier.check({
+    id: "550e8400-e29b-41d4-a716-446655440000",
+    name: "Ana",
+    age: "31",
+    active: "true",
+    tags: ["admin"],
+  });
+
+  console.log(user);
+} catch (error) {
+  if (error instanceof VerificationError) {
+    console.log(error.message);
+    console.log(error.errors);
+    console.log(error.errorsObj);
+  }
 }
 ```
 
-### Alternative Import with Verifiers Object
-
-You can also import the `Verifiers` object which contains all available validators:
-
-```typescript
-import { Verifiers, VerificationError } from "structure-verifier";
-
-// Available verifiers:
-const numberVal = new Verifiers.Number();           // VNumber
-const numberNotNullVal = new Verifiers.NumberNotNull(); // VNumberNotNull
-const stringVal = new Verifiers.String();           // VString
-const stringNotNullVal = new Verifiers.StringNotNull(); // VStringNotNull
-const booleanVal = new Verifiers.Boolean();         // VBoolean
-const booleanNotNullVal = new Verifiers.BooleanNotNull(); // VBooleanNotNull
-const objectVal = new Verifiers.Object({ properties: {} }); // VObject
-const objectNotNullVal = new Verifiers.ObjectNotNull({ properties: {} }); // VObjectNotNull
-const arrayVal = new Verifiers.Array({ verifier: new Verifiers.Number() }); // VArray
-const arrayNotNullVal = new Verifiers.ArrayNotNull({ verifier: new Verifiers.Number() }); // VArrayNotNull
-const anyVal = new Verifiers.Any();                 // VAny
-const dateVal = new Verifiers.Date();               // VDate
-const dateNotNullVal = new Verifiers.DateNotNull(); // VDateNotNull
-const uuidVal = new Verifiers.UUID();               // VUUID
-const uuidNotNullVal = new Verifiers.UUIDNotNull(); // VUUIDNotNull
-```
-## Types
-In case it is necessary to infer the type of the response, it is achieved by using InferType
-
-```typescript
-    import { InferType, Verifiers as V } from "structure-verifier";
-    
-    const val = new V.Number();
-    type valType = InferType<typeof val>;
-
-    function action(data:valType){
-        ...
-    }
-```
-## Validations
+## Conceptos base
+
+### 1) Nullable vs NotNull
+
+- VNumber, VString, VBoolean, VDate, VUUID, VArray y VObject retornan tipo nullable.
+- Sus versiones NotNull retornan el tipo requerido.
+- Tambien puedes promover un validador nullable a requerido con required().
+
+### 2) Reglas comunes
 
-### Numbers
-Validations to numerical data
-```typescript
-    const numberVal = new V.Number();////return number|null
-    const notNullNumberVal = new V.NumberNotNull() ////return number
+Muchos validadores comparten estas opciones:
+
+- isRequired: fuerza que el valor exista.
+- emptyAsNull: transforma string vacio a null antes de validar.
+- defaultValue: valor por defecto para undefined y, en algunos casos, null.
+- badTypeMessage: reemplaza el mensaje de tipo invalido.
+
+### 3) Mensajes personalizados
+
+Las reglas aceptan mensajes de estas formas:
+
+- String fijo.
+- Funcion callback con el objeto de valores de la regla.
+- Objeto con estructura val + message.
+
+Ejemplo:
+
+```ts
+const age = V.NumberNotNull().min(18, (v) => `Edad minima: ${v.min}`);
 ```
-Number exclusive conditions
-
-- **min:** - Used to denote the smallest valid number.
-- **max:** - Used to denote the biggest valid number.
-- **in:** - Used to denote an array of valid numbers that the value must be one of. 
-- **notIn:** - Used to denote an array of numbers that the value must not be one of.
-- **maxDecimalPlaces:** - Used to denote the maximum number of decimal places allowed.
-- **minDecimalPlaces:** - Used to denote the minimum number of decimal places required.
-
-#### Example
-```typescript
-    const numberVal = new V.Number({
-        min:10,
-        max:20,
-        in: [15,16,17],
-        notIn: [18,19,20],
-        maxDecimalPlaces: 0,
-        minDecimalPlaces: 0
-    });
-    /////Validate a number or null that meets all conditions otherwise error (VerificationError)
+
+## API publica
+
+Import principal:
+
+```ts
+import {
+  Verifiers,
+  VerificationError,
+  Verifier,
+  InferType,
+  InferFactoryType,
+  VAny,
+  VArray,
+  VArrayNotNull,
+  VBoolean,
+  VBooleanNotNull,
+  VDate,
+  VDateNotNull,
+  VNumber,
+  VNumberNotNull,
+  VObject,
+  VObjectNotNull,
+  VString,
+  VStringNotNull,
+  VUUID,
+  VUUIDNotNull,
+  datetime,
+} from "structure-verifier";
 ```
-***
-### Strings 
-Validations for string data.
 
-```typescript
-    const stringVal = new V.String(); // Returns string | null
-    const notNullStringVal = new V.StringNotNull(); // Returns string
+Tambien se exportan los tipos de condiciones:
+
+- VAnyConditions
+- VArrayConditions
+- VBooleanConditions
+- VDateConditions
+- VNumberConditions
+- VObjectConditions
+- VObjectConditionsNotNull
+- VStringConditions
+- VUUIDConditions
+
+## Estilos de uso
+
+### API de fabrica (recomendada)
+
+```ts
+import { Verifiers as V } from "structure-verifier";
+
+const nameV = V.StringNotNull({ minLength: 3 });
 ```
-String Exclusive Conditions
-- **minLength:** - Specifies the minimum length the string must have.
-- **maxLength:** - Specifies the maximum length the string can have.
-- **regex:** - Specifies a regular expression pattern the string must match.
-- **notRegex:** - Specifies a regular expression pattern the string must not match.
-- **in:** - Specifies an array of valid string values; the string must be one of these values.
-- **notIn:** - Specifies an array of string values that the string must not be one of.
-- **strictMode:** - When true, ensures the value is strictly a string (not coerced from another type).
-- **ignoreCase:** - When true, makes the in condition case-insensitive.
-
-#### Example
-```typescript
-    const stringVal = new V.String({
-        minLength: 5,
-        maxLength: 10,
-        regex: /^[a-zA-Z]+$/,
-        notRegex: /[^a-zA-Z]/,
-        in: ['apple', 'banana', 'cherry'],
-        notIn: ['date', 'fig', 'grape'],
-        strictMode: true,
-        ignoreCase: true
-    });
-    ///// Validate a string or null that meets all conditions otherwise error (VerificationError)
+
+### Clases directas
+
+```ts
+import { VStringNotNull } from "structure-verifier";
+
+const nameV = new VStringNotNull({ minLength: 3 });
 ```
-***
-### Booleans 
-Validations for boolean data.
 
-```typescript
-const booleanVal = new V.Boolean(); // Returns boolean | null
-const notNullBooleanVal = new V.BooleanNotNull(); // Returns boolean
+### Callable constructors
+
+En Verifiers puedes usar los miembros como funcion o con new.
+
+```ts
+const a = V.NumberNotNull({ min: 1 });
+const b = new V.NumberNotNull({ min: 1 });
 ```
 
-Boolean Exclusive Conditions
+## Referencia completa de validadores
 
-*No exclusive conditions for boolean validation*
+### Number y NumberNotNull
 
-#### Example
-```typescript
-const booleanVal = new V.Boolean();
-const notNullBooleanVal = new V.BooleanNotNull();
+Retorno:
 
-try {
-    console.log(booleanVal.check('true'));  // Output: true
-    console.log(booleanVal.check('FALSE')); // Output: false
-    console.log(booleanVal.check(null));    // Output: null
-    console.log(notNullBooleanVal.check('1'));   // Output: true
-    console.log(notNullBooleanVal.check(0));     // Output: false
-} catch (error) {
-    console.error(error);
-}
-```
-***
-### Objects 
-Validations for object data.
+- VNumber: number | null
+- VNumberNotNull: number
 
-```typescript
-const objectVal = new V.Object({ properties: {  name: new V.String({ minLength: 3 })/* properties with validations */ } }); // Returns object {name:""} | null
-const notNullObjectVal = new V.ObjectNotNull({ properties: {  name: new V.String({ minLength: 3 })/* properties with validations */ } }); // Returns object {name:""}
-```
+Condiciones:
 
-Object Exclusive Conditions
+- min
+- max
+- in
+- notIn
+- maxDecimalPlaces
+- minDecimalPlaces
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
 
-- **invalidPropertyMessage:** - Custom message for invalid properties.
-- **strictMode:** - When `true`, ensures the object has exactly the same properties as defined.
-- **ignoreCase:** - When `true`, makes the property names case-insensitive.
-- **takeAllValues:** - When `true`, allows taking all values from the input object, not just those defined in the properties.
+Comportamiento clave:
 
-#### Example
-```typescript
-const objectVal = new V.Object({
-    properties: {
-        name: new V.String({ minLength: 3 }),
-        age: new V.Number({ min: 18, max: 99 }),
-    },
-    strictMode: true,
-    ignoreCase: true,
-    invalidPropertyMessage: {
-        message: () => "no es una propiedad valida",
-        val: undefined
-    }
-});
+- Convierte el valor usando Number(data).
+- Rechaza string vacio y NaN.
 
-const notNullObjectVal = new V.ObjectNotNull({
-    properties: {
-        name: new V.StringNotNull({ minLength: 3 }),
-        age: new V.NumberNotNull({ min: 18, max: 99 }),
-    },
-    strictMode: true,
-    ignoreCase: true,
-    invalidPropertyMessage: {
-        message: () => "no es una propiedad valida",
-        val: undefined
-    }
-});
+Ejemplo:
 
-try {
-    console.log(objectVal.check({ name: 'John', age: 25 }));  // Output: { name: 'John', age: 25 }
-    console.log(objectVal.check(null));                      // Output: null
-    console.log(notNullObjectVal.check({ name: 'Jane', age: 30 }));   // Output: { name: 'Jane', age: 30 }
-} catch (error) {
-    console.error(error);
-}
+```ts
+const priceV = V.NumberNotNull().min(0).maxDecimalPlaces(2);
+const price = priceV.check("25.99");
 ```
-***
-### Arrays
-Validations for array data.
 
-```typescript
-const arrayVal = new V.Array({verifier: new V.Number()}); // Returns Array | null
-const notNullArrayVal = new V.ArrayNotNull({verifier: new V.Number()}); // Returns Array
-```
+### String y StringNotNull
 
-Array Exclusive Conditions
+Retorno:
 
-- **minLength**: Minimum length of the array.
-- **maxLength**: Maximum length of the array.
+- VString: string | null
+- VStringNotNull: string
 
-#### Example
-```typescript
-const arrayVal = new V.Array({ verifier: new V.Number(), minLength: 1, maxLength: 5 });
-const notNullArrayVal = new V.ArrayNotNull({ verifier: new V.Number(), minLength: 2 });
+Condiciones:
 
-try {
-    console.log(arrayVal.check([1, 2, 3]));  // Output: [1, 2, 3]
-    console.log(arrayVal.check([]));         // Throws VerificationError (array too short)
-    console.log(arrayVal.check(null));       // Output: null
-    console.log(notNullArrayVal.check([1, 2]));   // Output: [1, 2]
-    console.log(notNullArrayVal.check([1]));      // Throws VerificationError (array too short)
-} catch (error) {
-    console.error(error);
-}
-```
-***
-### Any 
-Validations for any data.
+- minLength
+- maxLength
+- regex
+- notRegex
+- in
+- notIn
+- strictMode
+- ignoreCase
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
 
-```typescript
-const anyVal = new V.Any(); // Returns any type
-```
+Comportamiento clave:
 
-VAny Exclusive Conditions
+- En modo normal convierte con String(data).
+- En strictMode exige string real.
+- ignoreCase afecta in y notIn.
 
-*No exclusive conditions for any validation*
+Ejemplo:
 
-#### Example
-```typescript
-const anyVal = new V.Any();
+```ts
+const roleV = V.StringNotNull()
+  .ignoreCase()
+  .in(["admin", "user", "guest"])
+  .trim()
+  .toLowerCase();
 
-try {
-    console.log(anyVal.check('true'));  // Output: 'true'
-    console.log(anyVal.check('FALSE')); // Output: 'FALSE'
-    console.log(anyVal.check(null));    // Output: null
-    console.log(anyVal.check('1'));     // Output: '1'
-    console.log(anyVal.check(0));       // Output: 0
-} catch (error) {
-    console.error(error);
-}
+const role = roleV.check(" ADMIN ");
 ```
-***
-### Date 
-Validations for date data (depends Moment).
 
-```typescript
-    const vdate = new V.Date();
-    const vdateNotNull = new V.DateNotNull();
-```
+### Boolean y BooleanNotNull
 
-VDate Exclusive Conditions
+Retorno:
 
-- **format**: Specifies the date format to be validated against.
-- **timeZone**: Specifies the expected time zone of the input date.
-- **maxDate**: Specifies the maximum allowed date.
-- **minDate**: Specifies the minimum allowed date.
+- VBoolean: boolean | null
+- VBooleanNotNull: boolean
 
-#### Example
-#### Basic Date Validation
+Condiciones:
 
-```typescript
-const vdate = new V.Date();
-console.log(vdate.check("2023-08-09")?.format("YYYY-MM-DD")); // Output: "2023-08-09"
-```
+- strictMode
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
 
-#### Date with Specific Format
+Comportamiento clave:
 
-```typescript
-const vdate = new V.Date({ format: "DD/MM/YYYY" });
-console.log(vdate.check("09/08/2023")?.format("DD/MM/YYYY")); // Output: "09/08/2023"
-```
+- En modo normal acepta: true, false, 1, 0, "1", "0", "true", "false".
+- En strictMode solo acepta boolean.
 
-#### Date with Time Zone
+Ejemplo:
 
-```typescript
-const vdate = new V.Date({ timeZone: "America/New_York" });
-const result = vdate.check("2023-08-09T10:00:00");
-console.log(result.tz("America/New_York").format()); // Output: "2023-08-09T10:00:00-04:00"
+```ts
+const active = V.BooleanNotNull().check("true");
+const strictActive = V.BooleanNotNull().strictMode().check(true);
 ```
 
-#### Date within Range
+### UUID y UUIDNotNull
 
-```typescript
-const vdate = new VDate({
-    minDate: moment("2023-01-01"),
-    maxDate: moment("2023-12-31")
-});
-console.log(vdate.check("2023-08-09").format("YYYY-MM-DD")); // Output: "2023-08-09"
-```
+Retorno:
+
+- VUUID: string | null
+- VUUIDNotNull: string
+
+Condiciones:
+
+- version (1 | 2 | 3 | 4 | 5)
+- allowNoHyphens
+- strictMode
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
 
-***
-### UUID 
-Validations for UUID (Universally Unique Identifier) data.
+Comportamiento clave:
 
-```typescript
-const uuidVal = new V.UUID(); // Returns string | null
-const notNullUuidVal = new V.UUIDNotNull(); // Returns string
+- Normaliza salida a minusculas y formato con guiones.
+- Si allowNoHyphens no esta activo, exige formato 8-4-4-4-12.
+
+Ejemplo:
+
+```ts
+const uuidV = V.UUIDNotNull().version(4);
+const id = uuidV.check("550E8400E29B41D4A716446655440000");
 ```
 
-UUID Exclusive Conditions
+### Date y DateNotNull
+
+Retorno:
+
+- VDate: datetime.Dayjs | null
+- VDateNotNull: datetime.Dayjs
 
-- **version**: Specifies the UUID version to validate against (1, 2, 3, 4, or 5). If not specified, accepts any version.
-- **allowNoHyphens**: When `true`, allows UUIDs without hyphens. Default is `false`.
-- **strictMode**: When `true`, ensures the input value is strictly a string (not coerced from another type).
+Condiciones:
 
-#### Example
+- format
+- timeZone
+- maxDate
+- minDate
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
 
-#### Basic UUID Validation
+Comportamiento clave:
 
-```typescript
-const uuidVal = new V.UUID();
-console.log(uuidVal.check("550e8400-e29b-41d4-a716-446655440000")); // Output: "550e8400-e29b-41d4-a716-446655440000"
-console.log(uuidVal.check(null)); // Output: null
+- Entradas soportadas: number, string, Date y datetime.Dayjs.
+- Si no defines timeZone usa UTC por defecto.
+- Si format no incluye zona horaria, se aplica la zona configurada.
+
+Ejemplo:
+
+```ts
+import { Verifiers as V, datetime } from "structure-verifier";
+
+const dateV = V.DateNotNull()
+  .format("YYYY-MM-DD")
+  .timeZone("America/Mexico_City")
+  .minDate(datetime("2024-01-01"));
+
+const d = dateV.check("2025-05-10");
 ```
 
-#### UUID with Specific Version
+### Array y ArrayNotNull
 
-```typescript
-const uuidV4Val = new V.UUID({ version: 4 });
-console.log(uuidV4Val.check("550e8400-e29b-41d4-a716-446655440000")); // Output: "550e8400-e29b-41d4-a716-446655440000"
+Firma:
+
+```ts
+const tagsV = V.Array(V.StringNotNull(), { minLength: 1 });
+const tagsRequiredV = V.ArrayNotNull(V.StringNotNull(), { minLength: 1 });
 ```
 
-#### UUID without Hyphens
+Retorno:
+
+- VArray: ReturnType<T["check"]>[] | null
+- VArrayNotNull: ReturnType<T["check"]>[]
+
+Condiciones:
 
-```typescript
-const uuidNoHyphensVal = new V.UUID({ allowNoHyphens: true });
-console.log(uuidNoHyphensVal.check("550e8400e29b41d4a716446655440000")); // Output: "550e8400-e29b-41d4-a716-446655440000"
+- minLength
+- maxLength
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
+
+Comportamiento clave:
+
+- Valida item por item con el verificador interno.
+- En errores anidados agrega rutas como [0], [1].name.
+
+### Object y ObjectNotNull
+
+Firma:
+
+```ts
+const userV = V.Object(
+  {
+    name: V.StringNotNull(),
+    age: V.Number(),
+  },
+  {
+    strictMode: true,
+    ignoreCase: false,
+    takeAllValues: false,
+  },
+);
 ```
 
-#### Strict Mode UUID
+Retorno:
 
-```typescript
-const strictUuidVal = new V.UUIDNotNull({ strictMode: true });
-try {
-    console.log(strictUuidVal.check("550e8400-e29b-41d4-a716-446655440000")); // Output: "550e8400-e29b-41d4-a716-446655440000"
-    console.log(strictUuidVal.check(123)); // Throws VerificationError
-} catch (error) {
-    console.error(error);
-}
+- VObject: objeto tipado | null
+- VObjectNotNull: objeto tipado
+
+Condiciones:
+
+- invalidPropertyMessage
+- strictMode
+- ignoreCase
+- takeAllValues
+- conds
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
+
+Comportamiento clave:
+
+- strictMode rechaza propiedades no declaradas.
+- ignoreCase permite mapear llaves sin distinguir mayusculas.
+- takeAllValues conserva propiedades extra en la salida.
+- conds ejecuta una validacion final con el objeto ya validado.
+
+### Any
+
+Retorno:
+
+- VAny: any | null
+
+Condiciones:
+
+- isRequired
+- emptyAsNull
+- defaultValue
+- badTypeMessage
+
+## Transformaciones de valores
+
+La clase base Verifier incluye transform(mapper), que permite postprocesar la salida validada sin perder la validacion previa.
+
+String y StringNotNull incluyen helpers listos:
+
+- trim
+- trimStart
+- trimEnd
+- toLowerCase
+- toUpperCase
+- removeAccents
+- padStart
+- padEnd
+
+Ejemplo:
+
+```ts
+const usernameV = V.StringNotNull({ minLength: 3 })
+  .trim()
+  .toLowerCase()
+  .removeAccents();
 ```
 
-***
-## VerificationError
+## Tipado inferido
 
-The `VerificationError` class extends the native JavaScript `Error` object to provide enhanced error handling for validation scenarios. This class is designed to collect and format multiple error messages, making it easier to understand and manage errors in your application.
+### InferType
 
-### Import
+```ts
+import { InferType, Verifiers as V } from "structure-verifier";
 
-To use the `VerificationError` class, import it as follows:
+const schema = V.ObjectNotNull({
+  id: V.UUIDNotNull(),
+  profile: V.ObjectNotNull({
+    name: V.StringNotNull(),
+    age: V.Number(),
+  }),
+});
 
-```typescript
-import { VerificationError } from "./path/to/your/VerificationError";
+type User = InferType<typeof schema>;
 ```
 
-### Constructor
+### InferFactoryType
+
+```ts
+import { InferFactoryType, Verifiers as V } from "structure-verifier";
+
+type NumberMaybe = InferFactoryType<typeof V.Number>;
+type NumberRequired = InferFactoryType<typeof V.NumberNotNull>;
+```
+
+## Manejo de errores
+
+Cuando una validacion falla se lanza VerificationError.
 
-#### `constructor(messages: messageResp[])`
+Propiedades principales:
 
-The constructor takes an array of `messageResp` objects as an argument. Each `messageResp` object represents an individual validation error and has the following structure:
+- message: todos los errores concatenados por punto y coma.
+- errors: arreglo de mensajes planos.
+- errorsObj: arreglo de objetos con key, message y metadatos.
 
-```typescript
-interface messageResp {
-    key: string;
-    message: string;
-    parent?: string;
+Ejemplo:
+
+```ts
+try {
+  V.ObjectNotNull({
+    name: V.StringNotNull({ minLength: 3 }),
+    tags: V.ArrayNotNull(V.StringNotNull(), { minLength: 1 }),
+  }).check({ name: "Al", tags: [] });
+} catch (error) {
+  if (error instanceof VerificationError) {
+    console.log(error.errors);
+    console.log(error.errorsObj);
+  }
 }
 ```
 
-The constructor will generate a formatted error message by concatenating each `messageResp` into a single string, separating them by a semicolon (`;`). Additionally, it stores the original errors in two formats:
+## datetime (dayjs)
+
+La libreria exporta dayjs como datetime con plugins activados:
 
-- **`_errors`**: An array of strings, where each string is a formatted error message.
-- **`_errorsObj`**: An array of `messageResp` objects.
+- utc
+- timezone
+- customParseFormat
 
-### Properties
+Ejemplo:
 
-#### `errors: string[]`
+```ts
+import { datetime } from "structure-verifier";
 
-This getter returns the array of formatted error messages. Each message is generated based on the `parent`, `key`, and `message` properties of the `messageResp` objects.
+const now = datetime();
+const utc = now.tz("UTC").format();
+console.log(utc);
+```
+
+## Ejemplos avanzados
+
+### Validacion de payload API
+
+```ts
+const createOrderV = V.ObjectNotNull(
+  {
+    customerId: V.UUIDNotNull({ version: 4 }),
+    items: V.ArrayNotNull(
+      V.ObjectNotNull({
+        sku: V.StringNotNull({ minLength: 1 }),
+        quantity: V.NumberNotNull({ min: 1 }),
+      }),
+      { minLength: 1 },
+    ),
+    createdAt: V.DateNotNull().timeZone("UTC"),
+  },
+  {
+    strictMode: true,
+  },
+);
+```
 
-#### `errorsObj: messageResp[]`
+### conds para reglas de negocio
+
+```ts
+const personV = V.ObjectNotNull(
+  {
+    age: V.NumberNotNull({ min: 0 }),
+    hasParentalConsent: V.Boolean(),
+  },
+  {
+    conds: (value) => {
+      if (value.age < 18 && value.hasParentalConsent !== true) {
+        throw new Error("Parental consent is required for minors");
+      }
+    },
+  },
+);
+```
 
-This getter returns the original array of `messageResp` objects, allowing access to the detailed structure of each validation error.
+## Scripts de desarrollo
 
-### Usage Example
+```bash
+npm test
+npm run dev
+```
 
-```typescript
-import { VerificationError } from "../src/error/v_error";
+## Licencia
 
-try {
-    throw new VerificationError([{ key: "email", message: "is invalid", parent: "contact" }]);
-} catch (err) {
-    if (err instanceof VerificationError) {
-        console.log(err.errors); // [ 'contact.email is invalid' ]
-        console.log(err.errorsObj); // Original messageResp objects
-    }
-}
-```
+ISC