@arkyn/server 3.0.1-beta.99 → 3.0.2

package/dist/utilities/schemaValidator.d.ts

@@ -0,0 +1,75 @@
+import type { ZodType, z } from "zod";
+/**
+ * Wraps a Zod schema with convenience validation methods suited for server-side use:
+ * - `isValid` — boolean check, no throws
+ * - `safeValidate` — raw Zod result, no throws
+ * - `validate` — throws `ServerError` on failure (for trusted/internal data)
+ * - `formValidate` / `formAsyncValidate` — throws `UnprocessableEntity` on failure (for user-submitted forms)
+ *
+ * @example
+ * ```typescript
+ * const validator = new SchemaValidator(z.object({ email: z.string().email() }));
+ *
+ * // Inside a Remix action:
+ * const body = validator.formValidate(await decodeRequestBody(request));
+ * ```
+ */
+declare class SchemaValidator<T extends ZodType> {
+    readonly schema: T;
+    /**
+     * @param schema - The Zod schema used for all validation methods on this instance.
+     */
+    constructor(schema: T);
+    /**
+     * Returns `true` if the data satisfies the schema, `false` otherwise. Never throws.
+     *
+     * @param data - The value to check.
+     */
+    isValid(data: any): boolean;
+    /**
+     * Validates data and returns the raw Zod `safeParseResult` without throwing.
+     * Useful when you need access to the full error details.
+     *
+     * @param data - The value to validate.
+     */
+    safeValidate(data: any): z.ZodSafeParseResult<z.infer<T>>;
+    /**
+     * Validates data and returns the typed result, throwing `ServerError` on failure.
+     * Use for validating internal/trusted data (e.g. env vars, config objects).
+     *
+     * @param data - The value to validate.
+     * @throws `ServerError` with a formatted field-by-field error message.
+     */
+    validate(data: any): z.infer<T>;
+    /**
+     * Validates form data and returns the typed result, throwing `UnprocessableEntity` on failure.
+     * The error includes `fieldErrors`, `fields`, and `data.scrollTo` (first failing field name).
+     *
+     * @param data - The raw form data to validate.
+     * @param message - Optional human-readable error message for the 422 response.
+     * @throws `UnprocessableEntity` with structured field errors for client-side form handling.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(registerSchema);
+     * const body = validator.formValidate(await decodeRequestBody(request));
+     * ```
+     */
+    formValidate(data: any, message?: string): z.infer<T>;
+    /**
+     * Async version of `formValidate` for schemas with async refinements (e.g. uniqueness checks).
+     *
+     * @param data - The raw form data to validate.
+     * @param message - Optional human-readable error message for the 422 response.
+     * @throws `UnprocessableEntity` with structured field errors for client-side form handling.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(registerSchema);
+     * const body = await validator.formAsyncValidate(await decodeRequestBody(request));
+     * ```
+     */
+    formAsyncValidate(data: any, message?: string): Promise<z.infer<T>>;
+}
+export { SchemaValidator };
+//# sourceMappingURL=schemaValidator.d.ts.map

package/dist/utilities/schemaValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValidator.d.ts","sourceRoot":"","sources":["../../src/utilities/schemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBtC;;;;;;;;;;;;;;GAcG;AACH,cAAM,eAAe,CAAC,CAAC,SAAS,OAAO;IAI1B,QAAQ,CAAC,MAAM,EAAE,CAAC;IAH9B;;OAEG;gBACkB,MAAM,EAAE,CAAC;IAE9B;;;;OAIG;IAEH,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAI3B;;;;;OAKG;IAEH,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAIzD;;;;;;OAMG;IAEH,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAQ/B;;;;;;;;;;;;;OAaG;IAEH,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAiBrD;;;;;;;;;;;;OAYG;IAEG,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAgBzE;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/validations/validateCep.d.ts

@@ -1,24 +1,19 @@
-type ValidateCepFunction = (rawCep: string) => boolean;
 /**
- * Removes all non-digit characters from the CEP.
- * @param cep - Raw CEP string.
- * @returns Only numeric characters.
- */
-/**
- * Validates a Brazilian CEP (Código de Endereçamento Postal).
+ * Validates a Brazilian CEP (postal code).
  *
- * A valid CEP has 8 numeric digits.
+ * A valid CEP must contain exactly 8 numeric digits,
+ * optionally formatted as "12345-678".
  *
- * @param rawCep - CEP string, may include formatting (e.g., "12345-678").
+ * @param rawCep - CEP value, with or without formatting.
  * @returns `true` if the CEP is valid, otherwise `false`.
  *
  * @example
- * ```ts
+ * ```typescript
  * validateCep("12345-678"); // true
  * validateCep("12345678");  // true
  * validateCep("ABCDE-123"); // false
  * ```
  */
-declare const validateCep: ValidateCepFunction;
+declare function validateCep(rawCep: string): boolean;
 export { validateCep };
 //# sourceMappingURL=validateCep.d.ts.map

package/dist/validations/validateCep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateCep.d.ts","sourceRoot":"","sources":["../../src/validations/validateCep.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAEvD;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAYlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"validateCep.d.ts","sourceRoot":"","sources":["../../src/validations/validateCep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAU5C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCnpj.d.ts

@@ -1,4 +1,3 @@
-type ValidateCnpjFunction = (rawCnpj: string) => boolean;
 /**
  * Validates a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) number.
  *
@@ -12,11 +11,11 @@ type ValidateCnpjFunction = (rawCnpj: string) => boolean;
  * @returns `true` if valid, otherwise `false`.
  *
  * @example
- * ```ts
+ * ```typescript
  * validateCnpj("12.345.678/0001-95"); // false
  * validateCnpj("11.444.777/0001-61"); // true
  * ```
  */
-declare const validateCnpj: ValidateCnpjFunction;
+declare function validateCnpj(rawCnpj: string): boolean;
 export { validateCnpj };
 //# sourceMappingURL=validateCnpj.d.ts.map

package/dist/validations/validateCnpj.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateCnpj.d.ts","sourceRoot":"","sources":["../../src/validations/validateCnpj.ts"],"names":[],"mappings":"AAEA,KAAK,oBAAoB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;AAyBzD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAgBnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"validateCnpj.d.ts","sourceRoot":"","sources":["../../src/validations/validateCnpj.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAqB9C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateCpf.d.ts

@@ -1,16 +1,8 @@
-type ValidateCpfFunction = (rawCpf: string) => boolean;
 /**
- * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
+ * Validates a Brazilian CPF number. Strips formatting, checks length, rejects
+ * repeated-digit sequences, and verifies both check digits with the CPF algorithm.
  *
- * The CPF is a unique identifier assigned to Brazilian citizens and residents.
- * This function checks if the provided CPF is valid by performing the following steps:
- * - Removes any non-digit characters from the input.
- * - Verifies if the CPF has the correct length (11 digits).
- * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
- * - Calculates the first and second verification digits using the CPF algorithm.
- * - Compares the calculated verification digits with the ones provided in the CPF.
- *
- * @param rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @param rawCpf - CPF string, with or without formatting (dots and dashes).
  * @returns `true` if the CPF is valid, otherwise `false`.
  *
  * @example
@@ -19,6 +11,6 @@ type ValidateCpfFunction = (rawCpf: string) => boolean;
  * validateCpf("111.444.777-35"); // true
  * ```
  */
-declare const validateCpf: ValidateCpfFunction;
+declare function validateCpf(rawCpf: string): boolean;
 export { validateCpf };
 //# sourceMappingURL=validateCpf.d.ts.map

package/dist/validations/validateCpf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAyBvD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAWlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;GAYG;AAEH,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAiB5C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateDate.d.ts

@@ -1,34 +1,23 @@
-type ValidateDateConfig = {
-    inputFormat?: "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
-    minYear?: number;
-    maxYear?: number;
-};
-type ValidateDateFunction = (rawDate: string, config?: ValidateDateConfig) => boolean;
 /**
- * Validates a date string based on the provided format and configuration.
- *
- * @param rawDate - The date string to validate.
- * @param config - Optional configuration object to customize validation.
- * @param config.inputFormat - The expected format of the input date.
- *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
- *                            Defaults to "DD/MM/YYYY".
- * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
- * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ * Validates a date string against a format and optional year bounds.
  *
- * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
- *
- * @throws {Error} If an invalid date format is provided in the configuration.
+ * @param date - The date string to validate.
+ * @param config.inputFormat - Parsing format: `"brazilianDate"` (DD/MM/YYYY, default), `"isoDate"` (MM-DD-YYYY), or `"timestamp"` (YYYY-MM-DD).
+ * @param config.minYear - Minimum allowed year. Defaults to 1900.
+ * @param config.maxYear - Maximum allowed year. Defaults to 3000.
+ * @returns `true` if the date is valid according to the format and bounds, otherwise `false`.
  *
  * @example
  * ```typescript
  * validateDate("31/12/2023"); // true
- * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
- * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
- * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
- * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
+ * validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2023"); // false (not a leap year)
  * ```
  */
-declare const validateDate: ValidateDateFunction;
+declare function validateDate(date: string, config?: {
+    inputFormat?: "brazilianDate" | "isoDate" | "timestamp";
+    minYear?: number;
+    maxYear?: number;
+}): boolean;
 export { validateDate };
 //# sourceMappingURL=validateDate.d.ts.map

package/dist/validations/validateDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,oBAAoB,GAAG,CAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,kBAAkB,KACxB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBA8CnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,iBAAS,YAAY,CACpB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE;IACR,WAAW,CAAC,EAAE,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,GACC,OAAO,CAiCT;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateEmail.d.ts

@@ -1,4 +1,3 @@
-type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
 /**
  * Validates if an email address is valid in all possible ways, including DNS validation.
  *
@@ -7,8 +6,8 @@ type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
  * - Validating advanced RFC 5322 compliance rules
  * - Verifying that the domain has valid MX or A records in DNS
  *
- * @param rawEmail - The email address string to validate
- * @returns A promise that resolves to `true` if the email is valid (including DNS), otherwise `false`
+ * @param rawEmail - The email address to validate.
+ * @returns `true` if the email passes format checks and its domain resolves in DNS, otherwise `false`.
  *
  * @example
  * ```typescript
@@ -17,6 +16,6 @@ type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
  * await validateEmail("invalid-email"); // false (invalid format)
  * ```
  */
-declare const validateEmail: ValidateEmailFunction;
+declare function validateEmail(rawEmail: string): Promise<boolean>;
 export { validateEmail };
 //# sourceMappingURL=validateEmail.d.ts.map

package/dist/validations/validateEmail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateEmail.d.ts","sourceRoot":"","sources":["../../src/validations/validateEmail.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAmGpE;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAYpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validateEmail.d.ts","sourceRoot":"","sources":["../../src/validations/validateEmail.ts"],"names":[],"mappings":"AAwFA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAe,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAW/D;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePassword.d.ts

@@ -1,4 +1,3 @@
-type ValidatePasswordFunction = (rawPassword: string) => boolean;
 /**
  * Validates a password based on the following rules:
  * - At least 8 characters
@@ -7,8 +6,8 @@ type ValidatePasswordFunction = (rawPassword: string) => boolean;
  * - At least 1 number
  * - At least 1 special character
  *
- * @param rawPassword - The raw password string.
- * @returns `true` if password is valid, otherwise `false`.
+ * @param rawPassword - The password string to validate.
+ * @returns `true` if the password meets all rules, otherwise `false`.
  *
  * @example
  * ```ts
@@ -16,6 +15,6 @@ type ValidatePasswordFunction = (rawPassword: string) => boolean;
  * validatePassword("senha123");  // false (no uppercase, no special char)
  * ```
  */
-declare const validatePassword: ValidatePasswordFunction;
+declare function validatePassword(rawPassword: string): boolean;
 export { validatePassword };
 //# sourceMappingURL=validatePassword.d.ts.map

package/dist/validations/validatePassword.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePassword.d.ts","sourceRoot":"","sources":["../../src/validations/validatePassword.ts"],"names":[],"mappings":"AAAA,KAAK,wBAAwB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAkBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"validatePassword.d.ts","sourceRoot":"","sources":["../../src/validations/validatePassword.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,iBAAS,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAkBtD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/validations/validatePhone.d.ts

@@ -1,29 +1,16 @@
-type ValidatePhoneFunction = (rawPhone: string) => boolean;
 /**
- * Validates a phone number against a list of country-specific formats.
+ * Validates an international phone number using `libphonenumber-js`, then confirms
+ * the parsed country code is present in the supported countries list.
  *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @param rawPhone - The phone number to validate as a string.
- * @returns `true` if the phone number matches any country's format, otherwise `false`.
+ * @param rawPhone - Phone number in E.164 format (e.g. `"+5532912345678"`).
+ * @returns `true` if the number is valid and the country is supported, otherwise `false`.
  *
  * @example
  * ```typescript
- * import { validatePhone } from "./validatePhone";
- *
- * validatePhone("+55 32912345678"); // true for a valid Brazilian phone number
- * validatePhone("+55 3212345678"); // true for a valid Brazilian phone number
- * validatePhone("+1-684 1234567"); // true for a valid American Samoa phone number
- * validatePhone("+5532912345678"); // false for an invalid Brazilian phone number
- * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
+ * validatePhone("+5532912345678"); // true (Brazil)
+ * validatePhone("+55329123456178"); // false (invalid)
  * ```
  */
-declare const validatePhone: ValidatePhoneFunction;
+declare function validatePhone(rawPhone: string): boolean;
 export { validatePhone };
 //# sourceMappingURL=validatePhone.d.ts.map

package/dist/validations/validatePhone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AAEH,iBAAS,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYhD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validateRg.d.ts

@@ -1,4 +1,3 @@
-type ValidateRgFunction = (rawRg: string) => boolean;
 /**
  * Validates a Brazilian RG (Registro Geral) in a generic way.
  *
@@ -17,6 +16,6 @@ type ValidateRgFunction = (rawRg: string) => boolean;
  * validateRg("12345678X"); // true
  * ```
  */
-declare const validateRg: ValidateRgFunction;
+declare function validateRg(rawRg: string): boolean;
 export { validateRg };
 //# sourceMappingURL=validateRg.d.ts.map

package/dist/validations/validateRg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateRg.d.ts","sourceRoot":"","sources":["../../src/validations/validateRg.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAajB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"validateRg.d.ts","sourceRoot":"","sources":["../../src/validations/validateRg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAa1C;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}