@nomalism-com/types 0.33.88 → 0.34.2

package/src/shared/interface.ts

@@ -0,0 +1,546 @@
+import joi from 'joi';
+import { messages } from './messages';
+import type {
+  ILastTicketCalledTodayByChannel,
+  IRemainingTodayTickets,
+} from '../modules/tickets/tickets/interfaces';
+import type { IGetUserData } from '../modules/integration/googleSheets/interfaces';
+import type { IDocumentTypeUserType } from '../modules/supply/documentType/interfaces';
+import type { IScheduleType } from '../modules/supply/schedule/interface';
+import type { IWarningType } from '../modules/supply/documentHeader/interfaces';
+import type { IProjectInfoType } from '../modules/integration/projectInfo/interfaces';
+import type {
+  IChat,
+  IEmail,
+  IEncomenda,
+  IMultimedia,
+  IMultimediaSummary,
+  IPostgresBackup,
+  IPrint,
+  IProjectInfo,
+  IProposta,
+  IServiceLogs,
+  IServiceStatus,
+  IStock,
+  ITask,
+} from '../modules/view/adminPanel/interfaces';
+
+export { messages };
+
+// timestamps
+type CreatedAt = 'created_at';
+
+type UpdatedAt = 'updated_at';
+
+export interface WithCreatedAt {
+  created_at: Date;
+}
+
+export interface WithUpdatedAt {
+  updated_at: Date;
+}
+
+export interface WithOriginId {
+  origin_id: string;
+}
+
+export type WithTimestamps = WithCreatedAt & WithUpdatedAt;
+
+export type WithTimestampsOriginID = (WithCreatedAt & WithUpdatedAt) | WithOriginId;
+
+export type WithoutTimestamps<T> = Omit<T, CreatedAt | UpdatedAt>;
+
+// userstamps
+type CreatedBy = 'created_by';
+
+type UpdatedBy = 'updated_by';
+
+export interface WithCreatedBy {
+  created_by?: string | null;
+}
+
+export interface WithUpdatedBy {
+  updated_by?: string | null;
+}
+
+export type WithUserstamps = WithCreatedBy & WithUpdatedBy;
+
+export type WithoutUserstamps<T> = Omit<T, CreatedBy | UpdatedBy>;
+
+export interface IUserToken {
+  id: string;
+  location_id: string;
+}
+
+export type IEntityWithUserToken<T> = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [K in keyof T]: T[K] extends (...params: infer U) => any
+    ? (...params: [...U, IUserToken]) => ReturnType<T[K]>
+    : T[K];
+};
+
+// all stamps
+export type WithStamps = WithTimestamps & WithUserstamps;
+
+export type WithStampsResponse<T> = T & WithStamps;
+
+export type WithoutStamps<T> = Omit<T, CreatedAt | UpdatedAt | CreatedBy | UpdatedBy>;
+
+// pagination
+export interface IPaginationRequest {
+  per_page?: number;
+  current_page?: number;
+}
+
+export interface IPaginationResponse<T> {
+  per_page: number;
+  current_page: number;
+  total: number;
+  data: T[];
+}
+
+// find by id
+export interface IFindByIdRequest extends Record<string, string> {
+  id: string;
+}
+
+// find by id number
+
+export interface IFindByIdNumberRequest {
+  id: number;
+}
+
+// find minified
+export interface IFindMinifiedRequest {
+  owner_id?: string;
+  search_value?: string | null;
+}
+
+export interface IFindMinifiedResponse {
+  id: string;
+  name: string;
+  group?: string;
+  multimedia_id?: string;
+}
+
+// find by owner id
+export interface IFindByOwnerIdRequest {
+  owner_id: string;
+}
+
+export interface IFindOptionalByOwnerIdRequest {
+  owner_id?: string;
+}
+
+// update many response
+export interface IUpdateManyResponse {
+  count: number;
+}
+
+export const IDataTypeEnum: {
+  date: 'date';
+  datetime: 'datetime';
+  text: 'text';
+  decimal: 'decimal';
+  integer: 'integer';
+  select: 'select';
+  select_multi: 'select_multi';
+  select_custom: 'select_custom';
+  boolean: 'boolean';
+  url: 'url';
+  email: 'email';
+  tel: 'tel';
+  file: 'file';
+  password: 'password';
+  multiline: 'multiline';
+  json: 'json';
+  userstamp: 'userstamp';
+} = {
+  date: 'date',
+  datetime: 'datetime',
+  text: 'text',
+  decimal: 'decimal',
+  integer: 'integer',
+  select: 'select',
+  select_multi: 'select_multi',
+  select_custom: 'select_custom',
+  boolean: 'boolean',
+  url: 'url',
+  email: 'email',
+  tel: 'tel',
+  file: 'file',
+  password: 'password',
+  multiline: 'multiline',
+  json: 'json',
+  userstamp: 'userstamp',
+};
+
+export type IDatatype = (typeof IDataTypeEnum)[keyof typeof IDataTypeEnum];
+
+export const dataTypes = Object.keys(IDataTypeEnum);
+
+// route validation
+export type IRouteRequest<T> = Record<keyof WithoutStamps<T>, joi.AnySchema>;
+export type IRouteRequestWithStamps<T> = Record<keyof T, joi.AnySchema>;
+
+export type IRouteResponseWithStamp<T> = Record<keyof WithStampsResponse<T>, joi.AnySchema>;
+
+export type IRouteResponseWithoutStamps<T> = Record<keyof WithoutStamps<T>, joi.AnySchema>;
+
+export type IRouteResponsePagination<T> = Record<keyof IPaginationResponse<T>, joi.AnySchema>;
+
+// find minified query validation
+const findMinifiedQueryKeys: IRouteRequest<IFindMinifiedRequest> = {
+  search_value: joi.string().allow('', null).optional(),
+  owner_id: joi.string().uuid().optional(),
+};
+export const findMinifiedQuery = joi.object().keys(findMinifiedQueryKeys).messages(messages);
+
+// find optional by owner id query validation
+const findOptionalByOwnerIdQueryKeys: IRouteRequest<IFindOptionalByOwnerIdRequest> = {
+  owner_id: joi.string().uuid().optional(),
+};
+export const findByOptionalOwnerIdQuery = joi
+  .object()
+  .keys(findOptionalByOwnerIdQueryKeys)
+  .messages(messages);
+
+// find by owner id query validation
+export const findByOwnerIdQueryKeys: IRouteRequest<IFindByOwnerIdRequest> = {
+  owner_id: joi.string().uuid().required(),
+};
+export const findByOwnerIdQuery = joi.object().keys(findByOwnerIdQueryKeys).messages(messages);
+
+// find by id param validation
+const findByIdParamKeys: IRouteRequest<IFindByIdRequest> = {
+  id: joi.string().uuid().required(),
+};
+export const idParam = joi.object().keys(findByIdParamKeys).messages(messages);
+
+const findByIdNumberParamKeys: IRouteRequest<IFindByIdNumberRequest> = {
+  id: joi.number().positive().required(),
+};
+export const idNumberParam = joi.object().keys(findByIdNumberParamKeys).messages(messages);
+
+// find minified response validation
+const findMinifiedReponseKeys: IRouteResponseWithoutStamps<IFindMinifiedResponse> = {
+  id: joi.string().uuid().required(),
+  name: joi.string().required(),
+  group: joi.string(),
+  multimedia_id: joi.string(),
+};
+
+export const findMinifiedReponse = joi.array().items(findMinifiedReponseKeys);
+
+// all stamps response validation
+export const joiValidateStamps: IRouteResponseWithoutStamps<WithTimestampsOriginID> = {
+  created_at: joi.date().required(),
+  updated_at: joi.date().required(),
+  created_by: joi.string().allow(null),
+  updated_by: joi.string().allow(null),
+  origin_id: joi.string().allow(null),
+};
+
+export interface ITaskClusterLoading {
+  task_id: string;
+  description: string;
+}
+export interface ITaskCluster {
+  owner_id: string;
+  loading: ITaskClusterLoading[];
+}
+
+export const IUserSendEmailDocumentTemplateEnum: {
+  generic: 'generic';
+  provider_payment_order: 'provider_payment_order';
+} = {
+  generic: 'generic',
+  provider_payment_order: 'provider_payment_order',
+};
+
+export type IUserSendEmailDocumentTemplate =
+  (typeof IUserSendEmailDocumentTemplateEnum)[keyof typeof IUserSendEmailDocumentTemplateEnum];
+
+export const IUserSendEmailDocumentTemplateTypes = Object.keys(IUserSendEmailDocumentTemplateEnum);
+
+// broker messages
+export enum IBrokerTopic {
+  // events
+  create = 'create',
+  update = 'update',
+  delete = 'delete',
+  // moloni
+  moloni_create_document = 'moloni_create_document',
+  moloni_backup_pdf = 'moloni_backup_pdf',
+  // tickets
+  tickets_change = 'tickets_change',
+  // auth
+  user_send_email_password = 'user_send_email_password',
+  user_send_email_document = 'user_send_email_document',
+  // google access
+  grant_access = 'grant_access',
+  remove_access = 'remove_access',
+  google_sheet_set_permissions = 'google_sheet_set_permissions',
+  google_sheet_update = 'google_sheet_update',
+  google_sheet_import = 'google_sheet_import',
+  import_master_artigos = 'import_master_artigos',
+  // emails
+  provider_order_schedule_email = 'provider_order_schedule_email',
+  client_notice_schedule_email = 'client_notice_schedule_email',
+  retry_errored_emails = 'retry_errored_emails',
+  send_errored_emails_summary = 'send_errored_emails_summary',
+  warning_email = 'warning_email',
+  verification_email = 'verification_email',
+  dispatch_chat_message = 'dispatch_chat_message',
+  // async task
+  perform_task = 'perform_task',
+  // project info
+  create_site_proposal = 'create_site_proposal',
+  // socket
+  task_done = 'task_done',
+  push_notification = 'push_notification',
+  // logs
+  error_log = 'error_log',
+  kafka_log = 'kafka_log',
+  express_log = 'express_log',
+  cron_log = 'cron_log',
+  moloni_log = 'moloni_log',
+  server_service_log = 'server_service_log',
+  server_backup_log = 'server_backup_log',
+  server_docker_log = 'server_docker_log',
+  server_certificate_log = 'server_certificate_log',
+  server_filesystem_log = 'server_filesystem_log',
+  service_print_log = 'service_print_log',
+  service_project_info_log = 'service_project_info_log',
+  service_multimedia_log = 'service_multimedia_log',
+  service_multimedia_summary_log = 'service_multimedia_summary_log',
+  service_email_log = 'service_email_log',
+  service_chat_log = 'service_chat_log',
+  googlesheet_proposta_log = 'googlesheet_proposta_log',
+  googlesheet_task_log = 'googlesheet_task_log',
+  googlesheet_stock_log = 'googlesheet_stock_log',
+  googlesheet_encomenda_log = 'googlesheet_encomenda_log',
+}
+
+export type IBrokerTopicPayload = {
+  [IBrokerTopic.create]: Record<string, unknown>;
+  [IBrokerTopic.update]: Record<string, unknown>;
+  [IBrokerTopic.delete]: Record<string, unknown>;
+  [IBrokerTopic.task_done]: {
+    owner_id: string;
+    task_id: string;
+    description: string;
+  };
+  [IBrokerTopic.google_sheet_import]: {
+    google_sheet_import_id: string;
+    google_sheet_id: string;
+    original_document_header_id?: string;
+    user_id: string;
+    location_id: string;
+  };
+  [IBrokerTopic.moloni_create_document]: {
+    document_header_id: string;
+    user_id: string;
+    location_id: string;
+  };
+  [IBrokerTopic.moloni_backup_pdf]: {
+    document_header_id: string;
+    user_id: string;
+    location_id: string;
+  };
+  [IBrokerTopic.user_send_email_password]: {
+    token: string;
+    user: {
+      name: string | null;
+      account: string;
+      email: string;
+    };
+  };
+  [IBrokerTopic.user_send_email_document]: {
+    template: IUserSendEmailDocumentTemplate;
+    user_type: IDocumentTypeUserType;
+    user: {
+      name: string;
+      email: string;
+    };
+    owner_id: string;
+    document_header_id: string;
+    start_document_name: string;
+    documents: {
+      document_header_id: string;
+      document_name: string;
+      document_fullname: string;
+      multimedia_id: string;
+    }[];
+  };
+  [IBrokerTopic.grant_access]: {
+    email: string;
+  };
+  [IBrokerTopic.remove_access]: {
+    email: string;
+  };
+  [IBrokerTopic.tickets_change]: {
+    last_tickets_called_today_by_channel: ILastTicketCalledTodayByChannel[];
+    remaining_today_tickets_to_call: IRemainingTodayTickets[];
+  };
+  [IBrokerTopic.google_sheet_set_permissions]: {
+    file_id: string;
+    email: string;
+  };
+  [IBrokerTopic.google_sheet_update]: {
+    spreadsheetId: string;
+    document_name: string;
+    client_data?: IGetUserData;
+  };
+  [IBrokerTopic.provider_order_schedule_email]: {
+    provider_id: string;
+    ef_dh_id: string; // EF
+    ef_pdf_link: string;
+    pf_number: string;
+    provider_name: string;
+    provider_email: string;
+  };
+  [IBrokerTopic.client_notice_schedule_email]: {
+    client_id: string;
+    pc_dh_id: string; // PC
+    chat_id: string;
+    pc_number: string;
+    client_name: string;
+    client_email: string;
+  };
+  [IBrokerTopic.perform_task]: {
+    task_name: IScheduleType;
+    user_token: IUserToken;
+  };
+  [IBrokerTopic.warning_email]: {
+    email: string;
+    name: string;
+    warning: IWarningType;
+    document_header_id: string; // PC
+    document_number: number;
+    document_lines: {
+      designation: string;
+      quantity: string;
+      state: string;
+    }[];
+  };
+  [IBrokerTopic.retry_errored_emails]: Record<string, never>;
+  [IBrokerTopic.send_errored_emails_summary]: { warningErrors: string[] };
+  [IBrokerTopic.dispatch_chat_message]: {
+    to: [
+      {
+        email: string;
+        name: string;
+        phone_number: string | null;
+      },
+    ];
+    reply_url: string;
+    owner_id: string;
+    document_header_id: string | null;
+    document_name: string;
+    chat_id: string;
+    email_subject?: string;
+    created_by: string;
+  };
+  [IBrokerTopic.create_site_proposal]: {
+    document_header_id: string;
+    type: IProjectInfoType;
+    name: string;
+    email: string;
+    telephone: string;
+    description: string;
+  };
+  [IBrokerTopic.verification_email]: {
+    email: string;
+    token: string;
+  };
+  [IBrokerTopic.push_notification]: {
+    counts: Record<string, number>;
+    timestamp: string;
+  };
+  [IBrokerTopic.import_master_artigos]: {};
+  [IBrokerTopic.kafka_log]: {
+    id: string;
+    topic: string;
+    payload: unknown;
+    error?: unknown;
+    output?: unknown;
+    done: boolean;
+  };
+  [IBrokerTopic.error_log]: {
+    service: string;
+    type: 'prisma' | 'unhandled' | 'axios' | 'webapp' | 'moloni';
+    error: { name: string; message: string; stack?: string };
+    request?: { body?: unknown; query?: unknown; params?: unknown };
+  };
+  [IBrokerTopic.express_log]: {
+    id: string;
+    service: string;
+    method: string;
+    url: string;
+    user: unknown;
+    headers: unknown;
+    params: unknown;
+    query: unknown;
+    body: unknown;
+    status_code?: number;
+    error?: unknown;
+    response_size?: number;
+    response_time?: number;
+  };
+  [IBrokerTopic.cron_log]: {
+    id: string;
+    task: string;
+    error?: unknown;
+    output?: unknown;
+    done: boolean;
+  };
+  [IBrokerTopic.moloni_log]: {
+    request_method: string;
+    request_url: string;
+    request_headers: unknown;
+    request_params: unknown;
+    request_body: unknown;
+    response_body: unknown;
+  };
+  [IBrokerTopic.server_service_log]: IServiceStatus;
+  [IBrokerTopic.server_backup_log]: IPostgresBackup;
+  [IBrokerTopic.server_docker_log]: IServiceLogs;
+  [IBrokerTopic.server_certificate_log]: string;
+  [IBrokerTopic.server_filesystem_log]: string;
+  [IBrokerTopic.service_print_log]: IPrint;
+  [IBrokerTopic.service_project_info_log]: IProjectInfo;
+  [IBrokerTopic.service_multimedia_log]: IMultimedia;
+  [IBrokerTopic.service_multimedia_summary_log]: IMultimediaSummary;
+  [IBrokerTopic.service_email_log]: IEmail;
+  [IBrokerTopic.service_chat_log]: IChat;
+  [IBrokerTopic.googlesheet_proposta_log]: IProposta & { id: string };
+  [IBrokerTopic.googlesheet_task_log]: ITask;
+  [IBrokerTopic.googlesheet_stock_log]: IStock;
+  [IBrokerTopic.googlesheet_encomenda_log]: IEncomenda;
+};
+
+export interface IBrokerMessage<T extends IBrokerTopic = IBrokerTopic> {
+  topic: T;
+  payload: IBrokerTopicPayload[T];
+}
+
+// typescript utils
+export type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
+  {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+  }[Keys];
+
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
+  {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+  }[Keys];
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Impossible<K extends keyof any> = {
+  [P in K]: never;
+};
+
+export type NoExtraProperties<T, U extends T = T> = U & Impossible<Exclude<keyof U, keyof T>>;
+
+export type ExactPromise<T> = Promise<NoExtraProperties<T>>;

package/src/shared/messages.ts

@@ -0,0 +1,141 @@
+import joi from 'joi';
+
+export const messages: joi.LanguageMessages = {
+  'alternatives.all': '{{#label}} não é compatível com nenhum dos tipos pedidos',
+  'alternatives.any': '{{#label}} não é compatível com nenhum dos tipos permitidos',
+  'alternatives.match': '{{#label}} não é compatível com nenhum dos tipos permitidos',
+  'alternatives.one': '{{#label}} é compatível com mais de um dos tipos permitidos',
+  'alternatives.types': '{{#label}} deve ser um dos {{#types}}',
+
+  'any.custom': '{{#label}} falhou na validação devido a {{#error.message}}',
+  'any.default': '{{#label}} gerou um erro ao executar o método default',
+  'any.failover': '{{#label}} gerou um erro ao executar o método failover',
+  'any.invalid': '{{#label}} contém um valor inválido',
+  'any.only': '{{#label}} deve ser {if(#valids.length == 1, "", "um dos ")}{{#valids}}',
+  'any.ref': '{{#label}} {{#arg}} referência {{:#ref}} que {{#reason}}',
+  'any.required': '{{#label}} é obrigatório',
+  'any.unknown': '{{#label}} não é permitido',
+
+  'array.base': '{{#label}} deve ser um array',
+  'array.excludes': '{{#label}} contém um valor excluído',
+  'array.hasKnown': '{{#label}} não contém nenhum padrão necessário para o tipo {:#patternLabel}',
+  'array.hasUnknown': '{{#label}} não contém nenhum padrão necessário',
+  'array.includes': '{{#label}} não é compatível com nenhum dos tipos permitidos',
+  'array.includesRequiredBoth':
+    '{{#label}} não contém {{#knownMisses}} e outro(s) valor(es) {{#unknownMisses}} obrigatório(s)',
+  'array.includesRequiredKnowns': '{{#label}} não contém {{#knownMisses}}',
+  'array.includesRequiredUnknowns':
+    '{{#label}} não contém o(s) valor(es) {{#unknownMisses}} obrigatórios',
+  'array.length': '{{#label}} deve conter {{#limit}} itens',
+  'array.max': '{{#label}} deve conter no máximo {{#limit}} itens',
+  'array.min': '{{#label}} deve conter pelo menos {{#limit}} itens',
+  'array.orderedLength': '{{#label}} deve conter pelo menos {{#limit}} itens',
+  'array.sort': '{{#label}} deve ser ordenado em {#order} por {{#by}}',
+  'array.sort.mismatching': '{{#label}} não pode ser ordenado devido a tipos incompatíveis',
+  'array.sort.unsupported':
+    '{{#label}} não pode ser ordenado devido ao tipo não suportado: {#type}',
+  'array.sparse': '{{#label}} não deve ser um item não definido',
+  'array.unique': '{{#label}} contém um item duplicado',
+
+  'binary.base': '{{#label}} deve ser um buffer ou um texto',
+  'binary.length': '{{#label}} deve ter {{#limit}} bytes',
+  'binary.max': '{{#label}} deve ter no máximo {{#limit}} bytes',
+  'binary.min': '{{#label}} deve ter pelo menos {{#limit}} bytes',
+
+  'boolean.base': '{{#label}} deve ser um booleano',
+
+  'date.base': '{{#label}} deve ser uma data válida.',
+  'date.format': '{{#label}} deve estar no formato: {msg("date.format." + #format) || #format}',
+  'date.greater': '{{#label}} deve ser maior que {{:#limit}}',
+  'date.less': '{{#label}} deve ser menor que {{:#limit}}',
+  'date.max': '{{#label}} deve ser menor que ou igual a {{:#limit}}',
+  'date.min': '{{#label}} deve ser maior que ou igual a {{:#limit}}',
+
+  'date.format.iso': 'data ISO 8601',
+  'date.format.javascript': 'timestamp ou número de milisegundos',
+  'date.format.unix': 'timestamp ou número de segundos',
+
+  'function.arity': '{{#label}} deve ter {{#n}} argumentos',
+  'function.class': '{{#label}} deve ser uma classe',
+  'function.maxArity': '{{#label}} deve ter no máximo {{#n}} argumentos',
+  'function.minArity': '{{#label}} deve ter pelo menos {{#n}} argumentos',
+
+  'object.and':
+    '{{#label}} contém {{#presentWithLabels}} sem seus pares necessários {{#missingWithLabels}}',
+  'object.assert':
+    '{{#label}} não é válido devido a {if(#subject.key, `"` + #subject.key + `" falhou em ` + (#message || "passar no teste de validação"), #message || "a validação falhou")}',
+  'object.base': '{{#label}} deve ser do tipo {{#type}}',
+  'object.instance': '{{#label}} deve ser uma instância de {{:#type}}',
+  'object.length': '{{#label}} deve ter {{#limit}} entrada{if(#limit == 1, "", "s")}',
+  'object.max': '{{#label}} deve ter no máximo {{#limit}} entrada{if(#limit == 1, "", "s")}',
+  'object.min': '{{#label}} deve ter pelo menos {{#limit}} entrada{if(#limit == 1, "", "s")}',
+  'object.missing': '{{#label}} deve conter pelo menos um de {{#peersWithLabels}}',
+  'object.nand': '{{:#mainWithLabel}} não deve existir simultaneamente com {{#peersWithLabels}}',
+  'object.oxor':
+    '{{#label}} contem um conflito entre pares opcionais exlusivos {{#peersWithLabels}}',
+  'object.pattern.match': '{{#label}} entradas falharam em se adequar aos padrões pedidos',
+  'object.refType': '{{#label}} deve ser uma referência do Joi',
+  'object.regex': '{{#label}} deve ser um objeto RegExp',
+  'object.rename.multiple':
+    '{{#label}} não pode renomear {{:#from}} pois renomear multiplas entradas esta desabilitado e outra chave já foi renomeada para {{:#to}}',
+  'object.rename.override':
+    '{{#label}} não pode renomear {{:#from}} pois sobrescrever está desabilitado e o destino {{:#to}} existe',
+  'object.schema': '{{#label}} deve ser um schema Joi do tipo {{#type}}',
+  'object.unknown': '{{#label}} não é permitido',
+  'object.with': '{{:#mainWithLabel}} falta par obrigatório {{:#peerWithLabel}}',
+  'object.without': '{{:#mainWithLabel}} conflita com par proibido {{:#peerWithLabel}}',
+  'object.xor': '{{#label}} contém um conflito entre pares exclusivos {{#peersWithLabels}}',
+
+  'number.base': '{{#label}} deve ser um número',
+  'number.greater': '{{#label}} deve ser maior que {{#limit}}',
+  'number.infinity': '{{#label}} não pode ser infinito',
+  'number.integer': '{{#label}} deve ser um número inteiro',
+  'number.less': '{{#label}} deve ser menor que {{#limit}}',
+  'number.max': '{{#label}} deve ser menor que ou igual a {{#limit}}',
+  'number.min': '{{#label}} deve ser maior que ou igual a {{#limit}}',
+  'number.multiple': '{{#label}} deve ser um múltiplo de {{#multiple}}',
+  'number.negative': '{{#label}} deve ser um número negativo',
+  'number.port': '{{#label}} deve ser uma porta válida',
+  'number.positive': '{{#label}} deve ser um número positivo',
+  'number.precision': '{{#label}} não deve ter mais que {{#limit}} casas decimais',
+  'number.unsafe': '{{#label}} deve ser um número seguro',
+
+  'string.alphanum': '{{#label}} deve conter apenas números e letras',
+  'string.base': '{{#label}} deve ser um texto',
+  'string.base64': '{{#label}} deve ser um texto base64 válido',
+  'string.creditCard': '{{#label}} deve ser um número de cartão de crédito válido',
+  'string.dataUri': '{{#label}} deve ser uma URI de dados',
+  'string.domain': '{{#label}} deve ser um nome de domínio válido',
+  'string.email': '{{#label}} deve ser um e-mail válido',
+  'string.empty': '{{#label}} não deve ser vazio',
+  'string.guid': '{{#label}} deve ser um GUID válido',
+  'string.hex': '{{#label}} deve conter apenas caracteres hexadecimais',
+  'string.hexAlign': '{{#label}} a decodificação hexadecimal deve ser byte alinhada',
+  'string.hostname': '{{#label}} deve ser um nome de host válido',
+  'string.ip': '{{#label}} deve ser um endereço de ip válido com um CIDR {{#cidr}}',
+  'string.ipVersion':
+    '{{#label}} deve ser um endereço de ip válido de uma das versões: {{#version}} com um CIDR {{#cidr}}',
+  'string.isoDate': '{{#label}} deve estar no formato ISO',
+  'string.isoDuration': '{{#label}} deve ser uma duração com formato ISO 8601 válido',
+  'string.length': 'A quantidade de caracteres de {{#label}} deve ser de {{#limit}} caracteres',
+  'string.lowercase': '{{#label}} deve conter apenas caracteres minúsculos',
+  'string.max': 'A quantidade de caracteres de {{#label}} deve ser menor ou igual que {{#limit}}',
+  'string.min': 'A quantidade de caracteres de {{#label}} deve ser de pelo menos {{#limit}}',
+  'string.normalize': '{{#label}} deve ser normalizado unicode no formulário {{#form}}',
+  'string.token': '{{#label}} deve conter apenas números, letras e caracteres de sublinhado',
+  'string.pattern.base':
+    '{{#label}} com valor {:[.]} não confere com o padrão requerido: {{#regex}}',
+  'string.pattern.name': '{{#label}} com valor {:[.]} não confere com o padrão {{#name}}',
+  'string.pattern.invert.base':
+    '{{#label}} com valor {:[.]} confere com o padrão invertido: {{#regex}}',
+  'string.pattern.invert.name':
+    '{{#label}} com valor {:[.]} confere com o padrão invertido {{#name}}',
+  'string.trim': '{{#label}} não deve espaços em branco no começo ou no final',
+  'string.uri': '{{#label}} deve ser uma URL válida',
+  'string.uriCustomScheme': '{{#label}} deve ser uma url válida de acordo com o padrão {{#scheme}}',
+  'string.uriRelativeOnly': '{{#label}} deve ser uma url relativa válida',
+  'string.uppercase': '{{#label}} deve conter apenas caracteres maiúsculos',
+
+  'symbol.base': '{{#label}} deve ser um símbolo',
+  'symbol.map': '{{#label}} deve ser um dos {{#map}}',
+};