@gipisistemas/ngx-core 1.0.1

package/tokens/allowed-public-routes.token.d.ts

@@ -0,0 +1,26 @@
+import { FactoryProvider, InjectionToken } from '@angular/core';
+/**
+ * Token de injeção para definir rotas públicas permitidas mesmo quando o usuário está autenticado.
+ *
+ * - Esse token é utilizado pelo `publicGuard` na lib para permitir que algumas rotas sejam acessadas
+ *   mesmo que o usuário já tenha um token válido no localStorage.
+ * - Por padrão, se não for fornecido, retorna uma lista vazia `[]`, o que significa que todas as rotas públicas
+ *   serão bloqueadas para usuários autenticados.
+ */
+export declare const ALLOWED_PUBLIC_ROUTES: InjectionToken<string[]>;
+/**
+ * Provedor para definir as rotas públicas permitidas.
+ *
+ * - Deve ser usado no bootstrap da aplicação para configurar quais rotas podem ser acessadas
+ *   mesmo que o usuário já esteja autenticado.
+ *
+ * @example
+ * ```typescript
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideALlowedPublicRoutes(['/oauth/change-password'])
+ *   ]
+ * };
+ * ```
+ */
+export declare function provideALlowedPublicRoutes(routes: string[]): FactoryProvider;

package/tokens/app-messages.token.d.ts

@@ -0,0 +1,13 @@
+import { FactoryProvider, InjectionToken } from '@angular/core';
+export interface iAppMessages {
+    SUCCESS: string;
+    RETURN_CONFIRMATION: string;
+    DELETE_CONFIRMATION: string;
+    DELETE_ALL_CONFIRMATION: string;
+    BUTTON_OK_CONFIRMATION: string;
+    BUTTON_CANCEL_CONFIRMATION: string;
+    NOT_PERMISSION: string;
+}
+export declare const DEFAULT_MESSAGES: iAppMessages;
+export declare const APP_MESSAGES: InjectionToken<iAppMessages>;
+export declare function provideAppMessages(messages: iAppMessages): FactoryProvider;

package/tokens/base-auth-service.token.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken, Type, type Provider } from '@angular/core';
+import { BaseUserModel } from '../base/models/base-user.model';
+import { BaseAuthService } from '../base/services/base-auth.service';
+export declare const BASE_AUTH_SERVICE_TOKEN: InjectionToken<BaseAuthService<BaseUserModel>>;
+export declare function provideBaseAuthService(useClass: Type<unknown>): Provider;

package/tokens/echarts-core.token.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken, type Provider } from '@angular/core';
+import { iEchartsConfig } from '../components/echarts/shared/echarts-config.interface';
+export declare const ECHARTS_CONFIG_TOKEN: InjectionToken<iEchartsConfig>;
+export declare function provideEchartsCore(config: iEchartsConfig): Provider;

package/tokens/index.d.ts

@@ -0,0 +1,6 @@
+export * from './allowed-public-routes.token';
+export * from './app-messages.token';
+export * from './base-auth-service.token';
+export * from './echarts-core.token';
+export * from './ngx-currency-options.token';
+export * from './paginator-intl.token';

package/tokens/ngx-currency-options.token.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { NgxCurrencyConfig } from 'ngx-currency';
+export declare const CURRENCY_OPTIONS_DEFAULT: NgxCurrencyConfig;
+export declare const CURRENCY_OPTIONS_TOKEN: InjectionToken<NgxCurrencyConfig>;
+export declare function provideNgxCurrencyOptions(config?: NgxCurrencyConfig): Provider;

package/tokens/paginator-intl.token.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken, type Provider } from '@angular/core';
+import { MatPaginatorIntl } from '@angular/material/paginator';
+export declare const PAGINATOR_INTL_PT_BR: () => MatPaginatorIntl;
+export declare const PAGINATIOR_INTL_TOKEN: InjectionToken<MatPaginatorIntl>;
+export declare function providePaginatorIntl(config?: MatPaginatorIntl): Provider;

package/types/booleanish.type.d.ts

@@ -0,0 +1 @@
+export declare type Booleanish = boolean | 'true' | 'false';

package/types/implicit-template.type.d.ts

@@ -0,0 +1,4 @@
+import { TemplateRef } from '@angular/core';
+export type tImplicitTemplateRef<T> = TemplateRef<{
+    $implicit: T;
+}> | null;

package/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './booleanish.type';
+export * from './implicit-template.type';
+export * from './mixable-object.type';
+export * from './nullable.type';
+export * from './numberish.type';
+export * from './page-event.type';
+export * from './uuid.type';
+export * from './void-listener.type';

package/types/mixable-object.type.d.ts

@@ -0,0 +1 @@
+export type MixableObject<T = void> = Record<string, T | T | null | undefined | string | number | boolean>;

package/types/nullable.type.d.ts

@@ -0,0 +1 @@
+export declare type Nullable<T = void> = T | null | undefined;

package/types/numberish.type.d.ts

@@ -0,0 +1 @@
+export declare type Numberish = number | string;

package/types/page-event.type.d.ts

@@ -0,0 +1,6 @@
+import { PageEvent } from '@angular/material/paginator';
+import { BaseSortModel } from '../base/models/base-sort.model';
+export type tPageEvent = (PageEvent & {
+    pageSizeOptions?: number[];
+    sort?: BaseSortModel;
+}) | null;

package/types/uuid.type.d.ts

@@ -0,0 +1 @@
+export declare type GIPIUuid = number | string | null | undefined;

package/types/void-listener.type.d.ts

@@ -0,0 +1 @@
+export declare type VoidListener = VoidFunction | null | undefined;

package/utils/array.util.d.ts

@@ -0,0 +1,13 @@
+export declare class ArrayUtil {
+    /**
+     * Verifica se um valor é considerado vazio.
+     *
+     * Um valor é considerado vazio se for:
+     *    -        `null` ou `undefined`
+     *    -        Um array vazio `[]`
+     *
+     * @param inp O valor a ser verificado.
+     * @returns `true` se o valor for vazio, caso contrário, `false`.
+     */
+    static isEmpty(inp: unknown): inp is null | undefined;
+}

package/utils/css.util.d.ts

@@ -0,0 +1,12 @@
+export declare class CssUtil {
+    static readonly BREAKPOINT_MOBILE_PX = 639.98;
+    static readonly BREAKPOINT_MOBILE = "(max-width: 639.98px)";
+    static readonly BREAKPOINT_TABLET = "(min-width: 640px) and (max-width: 1279.98px)";
+    static readonly BREAKPOINT_DESKTOP = "(min-width: 1280px)";
+    static readonly BREAKPOINTS: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    static coerceCssPixelValue(value: any): string;
+}

package/utils/currency.util.d.ts

@@ -0,0 +1,83 @@
+export declare class CurrencyUtil {
+    /**
+     * Verifica se um valor é considerado vazio.
+     *
+     * Um valor é considerado vazio se for:
+     *    -        `null` ou `undefined`
+     *    -        Uma string vazia `""`
+     *    -        Um número `NaN`
+     *    -        Um array vazio `[]`
+     *    -        Um objeto sem propriedades `{}`
+     *    -        Um valor de data inválido
+     *
+     * @param inp O valor a ser verificado.
+     * @returns `true` se o valor for vazio, caso contrário, `false`.
+     */
+    static isEmpty(inp: unknown): inp is null | undefined;
+    /**
+     * Formata um número como moeda ou porcentagem, de acordo com as configurações especificadas.
+     *
+     * @param inp O número a ser formatado.
+     * @param digitsInfo Define o formato dos dígitos (ex.: `1.2-2` para mínimo de 1 dígito inteiro e 2 casas decimais).
+     * @param isPercent Define se o número deve ser formatado como porcentagem:
+     *    -        `true`: Formata como porcentagem (ex. '50%' em vez de '0.5').
+     *    -        `false` (padrão): Formata como moeda em reais (ex. 'R$ 10,00').
+     *
+     * @returns O número formatado como string.
+     */
+    /**
+     * Formata um número como moeda (em reais) ou porcentagem, conforme as opções fornecidas.
+     *
+     * @param inp Número a ser formatado.
+     * @param options Configurações de formatação:
+     *   - `digitsInfo` (opcional): Define o formato dos dígitos, como `1.2-2` (mínimo 1 inteiro, 2 casas decimais).
+     *   - `isPercent` (opcional): Se `true`, formata como porcentagem (ex: `0.5` → `50%`); caso contrário, como moeda (`R$`).
+     *
+     * @returns Uma string com o número formatado como moeda ou porcentagem.
+     */
+    static format(inp: number, options?: {
+        digitsInfo?: string;
+        isPercent?: boolean;
+    }): string;
+    /**
+     *
+     * Converte um número para seu valor por extenso em português (pt-BR).
+     *
+     * @github https://github.com/lusofonia/extenso.js
+     *
+     * @param inp O número que será convertido em texto.
+     * @param mode Define o formato da conversão:
+     *    -        'number': quarenta e dois
+     *    -        'currency': quarenta e dois reais
+     *    -        'percent': quarenta e dois por cento
+     * @returns O número convertido em texto por extenso.
+     */
+    static convertInExtenzeText(inp: number, mode?: 'number' | 'currency' | 'percent'): string;
+    /**
+     * Arredonda e formata um valor de acordo com uma regra específica e tipo de saída.
+     *
+     * Regras de arredondamento:
+     * - `'none'`  : não altera o valor.
+     * - `'end0'`  : arredonda para cima até o próximo múltiplo de 0,10.
+     * - `'end9'`  : arredonda para cima até o próximo valor terminando em 0,09.
+     * - `'end90'` : arredonda para cima até o próximo valor terminando em 0,90.
+     * - `'end99'` : arredonda para cima até o próximo valor terminando em 0,99.
+     *
+     * Tipos de formatação:
+     * - `'currency'` : retorna uma string em formato moeda BRL (ex: "R$ 1,50").
+     * - `'percent'`  : retorna uma string percentual sem multiplicar por 100 (ex: "0,12%").
+     * - `'value'`    : retorna apenas o número arredondado (ex: 1.5).
+     *
+     * @param value Valor original
+     * @param rule Regra de arredondamento
+     * @param type Tipo de formatação (default: 'value')
+     * @returns Valor arredondado e formatado conforme o tipo
+     *
+     * @example
+     * roundValue(0.09, 'end0', 'currency')  // "R$ 0,10"
+     * roundValue(1.58, 'end9', 'currency')  // "R$ 1,59"
+     * roundValue(0.1234, 'none', 'percent') // "0,12%"
+     * roundValue(1.234, 'end0', 'value')    // 1.3
+     */
+    static roundValue(value: number, rule?: 'none' | 'end0' | 'end9' | 'end90' | 'end99', type?: 'currency' | 'percent' | 'value'): string | number;
+}

package/utils/date.util.d.ts

@@ -0,0 +1,166 @@
+import { MatDateFormats } from '@angular/material/core';
+import * as moment from 'moment-timezone';
+import { Nullable } from '../types/nullable.type';
+export type tMonthsEnglish = 'JANUARY' | 'FEBRUARY' | 'MARCH' | 'APRIL' | 'MAY' | 'JUNE' | 'JULY' | 'AUGUST' | 'SEPTEMBER' | 'OCTOBER' | 'NOVEMBER' | 'DECEMBER';
+export type tWeekdaysEnglish = 'SUNDAY' | 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY';
+export declare class DateUtil {
+    static DATE_FORMATS: MatDateFormats;
+    /** Mapeamento de traduções para meses e dias da semana */
+    private static readonly _TRANSLATIONS;
+    static FORMAT_DATE: string;
+    static FORMAT_DATE_TIME: string;
+    static FORMAT_LONG_DATE: string;
+    static FORMAT_LONG_DATE_TIME: string;
+    static MONTHS: string[];
+    static MONTHS_LONG: string[];
+    static MONTHS_ENGLISH: tMonthsEnglish[];
+    static WEEKDAYS: string[];
+    static WEEKDAYS_LONG: string[];
+    static WEEKDAYS_ENGLISH: tWeekdaysEnglish[];
+    static TIMEZONE: string;
+    /**
+     * Verifica se um valor é uma data válida.
+     *
+     * Um valor é considerado uma data válida se:
+     *  - O tipo interno do objeto for `[object Date]`
+     *  - O Moment.js reconhecer o valor como uma data válida
+     *
+     * @param inp O valor a ser verificado.
+     * @returns `true` se o valor for uma data válida, caso contrário, `false`.
+     */
+    static isDate(inp: Nullable<unknown>): boolean;
+    /**
+     * Verifica se um valor é considerado vazio.
+     *
+     * Um valor é considerado vazio se for:
+     *    -        `null` ou `undefined`
+     *    -        Uma string vazia `""`
+     *    -        Um número `NaN`
+     *    -        Um array vazio `[]`
+     *    -        Um objeto sem propriedades `{}`
+     *    -        Um valor de data inválido
+     *
+     * @param inp O valor a ser verificado.
+     * @returns `true` se o valor for vazio, caso contrário, `false`.
+     */
+    static isEmpty(inp: unknown): inp is null | undefined;
+    /**
+     * Traduz o nome de um mês do inglês para o português.
+     * @param month Nome do mês em inglês (ex: "JANUARY").
+     * @returns Nome do mês traduzido ou o próprio valor se não encontrado.
+     */
+    static translateMonth(month: tMonthsEnglish): string;
+    /**
+     * Traduz o nome de um dia da semana do inglês para o português.
+     * @param weekday Nome do dia da semana em inglês (ex: "SUNDAY").
+     * @returns Nome do dia traduzido ou o próprio valor se não encontrado.
+     */
+    static translateWeekday(weekday: string): string;
+    /**
+     * Retorna a data e hora atual.
+     * @returns A data e hora atual no fuso horário de `this.TIMEZONE`.
+     */
+    static now(): Date;
+    /**
+     * Formata uma data, de acordo com o formato especificado.
+     *
+     * @param inp A data a ser formatada.
+     * @param format O formato da data (padrão é `'DD/MM/YYYY'`).
+     * @returns A data formatada como string.
+     */
+    static format(inp: Date, format?: string): string;
+    /**
+     * Verifica se a primeira data é posterior à segunda data.
+     *
+     * @param inp1 A primeira data a ser comparada.
+     * @param inp2 A segunda data a ser comparada.
+     * @param granularity A unidade de tempo para a comparação ('date', 'minute', 'hour', etc.).
+     * @returns `true` se a primeira data for posterior à segunda, caso contrário, `false`.
+     */
+    static isAfter(inp1: Date, inp2: Date, granularity?: moment.unitOfTime.StartOf): boolean;
+    /**
+     * Verifica se a primeira data é anterior à segunda data.
+     *
+     * @param inp1 A primeira data a ser comparada.
+     * @param inp2 A segunda data a ser comparada.
+     * @param granularity A unidade de tempo para a comparação ('date', 'minute', 'hour', etc.).
+     * @returns `true` se a primeira data for anterior à segunda, caso contrário, `false`.
+     */
+    static isBefore(inp1: Date, inp2: Date, granularity?: moment.unitOfTime.StartOf): boolean;
+    /**
+     * Verifica se duas datas são iguais.
+     *
+     * @param inp1 A primeira data a ser comparada.
+     * @param inp2 A segunda data a ser comparada.
+     * @param granularity A unidade de tempo para a comparação ('date', 'minute', 'hour', etc.).
+     * @returns `true` se as duas datas forem iguais, caso contrário, `false`.
+     */
+    static isEqual(inp1: Date, inp2: Date, granularity?: moment.unitOfTime.StartOf): boolean;
+    /**
+     * Verifica se a primeira data é igual ou posterior à segunda data.
+     *
+     * @param inp1 A primeira data a ser comparada.
+     * @param inp2 A segunda data a ser comparada.
+     * @param granularity A unidade de tempo para a comparação ('date', 'minute', 'hour', etc.).
+     * @returns `true` se a primeira data for igual ou posterior à segunda, caso contrário, `false`.
+     */
+    static isEqualOrAfter(inp1: Date, inp2: Date, granularity?: moment.unitOfTime.StartOf): boolean;
+    /**
+     * Verifica se a primeira data é igual ou anterior à segunda data.
+     *
+     * @param inp1 A primeira data a ser comparada.
+     * @param inp2 A segunda data a ser comparada.
+     * @param granularity A unidade de tempo para a comparação ('date', 'minute', 'hour', etc.).
+     * @returns `true` se a primeira data for igual ou anterior à segunda, caso contrário, `false`.
+     */
+    static isEqualOrBefore(inp1: Date, inp2: Date, granularity?: moment.unitOfTime.StartOf): boolean;
+    /**
+     * Verifica se uma data está entre duas outras datas.
+     *
+     * @param inp A data a ser verificada.
+     * @param startDate A data de início do intervalo.
+     * @param endDate A data de fim do intervalo.
+     * @param granularity A unidade de tempo para a comparação ('date', 'minute', 'hour', etc.).
+     * @returns `true` se a data estiver entre as duas outras, caso contrário, `false`.
+     */
+    static isBetween(inp: Date, startDate: Date, endDate: Date, granularity?: moment.unitOfTime.StartOf): boolean;
+    /**
+     * Verifica se uma data é válida.
+     *
+     * @param inp A data a ser verificada.
+     * @returns `true` se a data for válida, caso contrário, `false`.
+     */
+    static isValid(inp: Date): boolean;
+    /**
+     * Adiciona uma quantidade de tempo a uma data.
+     *
+     * @param inp A data original.
+     * @param amount A quantidade de tempo a ser adicionada (pode ser um número).
+     * @param unit A unidade de tempo (ex: 'day', 'month', 'year').
+     * @returns A nova data após a adição.
+     */
+    static add(inp: Date, amount: moment.DurationInputArg1, unit?: moment.DurationInputArg2): Date;
+    /**
+     * Subtrai uma quantidade de tempo de uma data.
+     *
+     * @param inp A data original.
+     * @param amount A quantidade de tempo a ser subtraída.
+     * @param unit A unidade de tempo (ex: 'day', 'month', 'year').
+     * @returns A nova data após a subtração.
+     */
+    static subtract(inp: Date, amount: moment.DurationInputArg1, unit?: moment.DurationInputArg2): Date;
+    /**
+     * Clona uma data.
+     *
+     * @param inp A data a ser clonada.
+     * @returns Uma nova instância de data, clonada da original.
+     */
+    static clone(inp: Date): Date;
+    /**
+     * Remove a parte de tempo de uma data, deixando apenas a parte da data (dia, mês, ano).
+     *
+     * @param inp A data a ser modificada.
+     * @returns A data com a parte do tempo zerado (ex: `'01/01/2000T00:00:00-03:00'`).
+     */
+    static removeTime(inp: Date): Date;
+}

package/utils/document.util.d.ts

@@ -0,0 +1,126 @@
+import { tUFState } from './states.util';
+export declare class DocumentUtil {
+    private static _isLastChar;
+    /**
+     * Verifica se um valor é considerado vazio.
+     * @param inp O valor a ser verificado.
+     * @returns O valor sem formatação.
+     * @example
+     * DocumentUtil.isEmpty('123-123'); // Retorna `123123`.
+     */
+    static clearFormat(value: string): string;
+    /**
+     * Formata um CPF.
+     * @param cpf O CPF a ser formatado.
+     * @param pad Se `true`, o CPF será preenchido com zeros à esquerda.
+     * @returns O CPF formatado.
+     * @example
+     * DocumentUtil.formatCpf('12345678909'); // Retorna `123.456.789-09`.
+     * DocumentUtil.formatCpf('123456789', true); // Retorna `001.234.567-89`.
+     */
+    static formatCpf(cpf: string, pad?: boolean): string;
+    /**
+     * Verifica se um CPF é válido.
+     * @param cpf O CPF a ser verificado.
+     * @returns `true` se o CPF for válido, caso contrário, `false`.
+     * @example
+     * DocumentUtil.isValidCpf('123.456.789-09'); // Retorna `true`.
+     * DocumentUtil.isValidCpf('12345678909'); // Retorna `true`.
+     * DocumentUtil.isValidCpf('1234567890'); // Retorna `false`.
+     * DocumentUtil.isValidCpf('123456789090'); // Retorna `false`.
+     */
+    static isValidCpf(cpf: string): boolean;
+    /**
+     * Formata um CNPJ.
+     * @param cnpj O CNPJ a ser formatado.
+     * @param pad Se `true`, o CNPJ será preenchido com zeros à esquerda.
+     * @returns O CNPJ formatado.
+     * @example
+     * DocumentUtil.formatCnpj('00123123000112'); // Retorna `00.123.123/0001-12`.
+     * DocumentUtil.formatCnpj('123123000112', true); // Retorna `00.123.123/0001-12`.
+     */
+    static formatCnpj(cnpj: string, pad?: boolean): string;
+    /**
+     * Verifica se um CNPJ é válido.
+     * @param cnpj O CNPJ a ser verificado.
+     * @returns `true` se o CNPJ for válido, caso contrário, `false`.
+     * @example
+     * DocumentUtil.isValidCnpj('12.345.678/0001-09'); // Retorna `true`.
+     * DocumentUtil.isValidCnpj('12345678000109'); // Retorna `true`.
+     * DocumentUtil.isValidCnpj('1234567800010'); // Retorna `false`.
+     * DocumentUtil.isValidCnpj('123456780001090'); // Retorna `false`.
+     */
+    static isValidCnpj(cnpj: string): boolean;
+    /**
+     * Formata um CEP.
+     * @param cep O CEP a ser formatado.
+     * @returns O CEP formatado.
+     * @example
+     * DocumentUtil.formatCep('12345678'); // Retorna `12345-678`.
+     * DocumentUtil.formatCep('12345-678'); // Retorna `12345-678`.
+     */
+    static formatCep(cep: string): string;
+    /**
+     * Verifica se um CEP é válido.
+     * @param cep O CEP a ser verificado.
+     * @returns `true` se o CEP for válido, caso contrário, `false`.
+     * @example
+     * DocumentUtil.isValidCep('12345-678'); // Retorna `true`.
+     * DocumentUtil.isValidCep('12345678'); // Retorna `true`.
+     * DocumentUtil.isValidCep('1234567'); // Retorna `false`.
+     * DocumentUtil.isValidCep('123456789'); // Retorna `false`.
+     */
+    static isValidCep(cep: string): boolean;
+    /**
+     * Formata a inscrição estadual (IE) conforme o estado (UF) informado.
+     *
+     * Aplica a máscara correta de acordo com o estado e o número da inscrição estadual fornecido,
+     * removendo quaisquer caracteres não numéricos e inserindo os separadores (como ponto, hífen, etc.)
+     * conforme o padrão oficial da IE para aquele estado.
+     *
+     * Se o valor da IE for "ISENTO" (ignorando espaços e case), ele será retornado como está.
+     *
+     * @param uf - A sigla do estado (UF) para o qual a IE deve ser formatada (ex: 'SP', 'MG').
+     * @param stateRegistration - O valor da inscrição estadual (IE), podendo conter ou não máscara.
+     * @returns A inscrição estadual formatada com a máscara apropriada ou o valor original em caso de isenção ou erro.
+     * @example
+     * DocumentUtil.formatIE('SP', '123456789012'); // Retorna '123.456.789.012'
+     * DocumentUtil.formatIE('MG', '1234567890123'); // Retorna '123.456.789/0123'
+     */
+    static formatIE(uf: tUFState, stateRegistration: string): string;
+    /**
+     * Retorna a máscara apropriada para a inscrição estadual (IE) com base na sigla do estado (UF)
+     * e no número de dígitos da inscrição (útil para estados com variação de formato).
+     *
+     * A máscara é composta por asteriscos (*) e separadores (ponto, hífen, barra), que definem a posição
+     * de cada caractere numérico na formatação final.
+     *
+     * @param uf - A sigla do estado (UF) para o qual a máscara da IE deve ser retornada.
+     * @param digits - A string contendo apenas os dígitos da inscrição estadual, sem formatação.
+     * @returns A máscara de formatação adequada para o estado informado.
+     *
+     * @example
+     * DocumentUtil._getIeMask('SP', '123456789012'); // Retorna '***.***.***.***'
+     */
+    private static _getIeMask;
+    /**
+     * Verifica se um número de inscrição estadual é válido para o estado especificado.
+     * @param state O estado para o qual a inscrição estadual será validada.
+     * @param stateRegistration O número de inscrição estadual a ser verificado.
+     * @param options Opções adicionais para a validação, como `adjustSize` e `displayCorrectDigit`.
+     * - `adjustSize`: Se `true`, ajusta o size da inscrição estadual.
+     * - `displayCorrectDigit`: Se `true`, exibe o dígito verificador correto.
+     * @returns `true` se a inscrição estadual for válida, caso contrário, `false`.
+     * @example
+     * DocumentUtil.isValidIE('GO', '113687214'); // Retorna `{ isValid: true, message: '' }`.
+     * DocumentUtil.isValidIE('AC', '0185402241495'); // Retorna `{ isValid: false, message: 'Inscrição estadual inválida para AC. Motivo: Dígito verificador inválido.' }`.
+     */
+    static isValidIE(uf: tUFState, stateRegistration: string, options?: {
+        adjustSize?: boolean;
+        displayCorrectDigit?: boolean;
+    }): {
+        isValid: boolean;
+        message?: string;
+        correctDigit?: string;
+    };
+}

package/utils/email.util.d.ts

@@ -0,0 +1,19 @@
+export declare class EmailUtil {
+    /**
+     * Valida se um endereço de e-mail é sintaticamente correto e termina com um TLD conhecido.
+     *
+     * A validação ocorre em duas etapas:
+     * 1. Verifica se o e-mail possui uma estrutura válida usando uma expressão regular.
+     * 2. Verifica se o domínio termina com um dos TLDs permitidos (.com, .br, .org, etc).
+     *
+     * @param email - O e-mail a ser validado.
+     * @returns `true` se o e-mail for válido, `false` caso contrário.
+     * @example
+     * EmailValidator.isValid("usuario@gmail.com");      // true
+     * EmailValidator.isValid("nome@empresa.com.br");    // true
+     * EmailValidator.isValid("invalido@localhost");     // false
+     * EmailValidator.isValid("sem-arroba.com");         // false
+     * EmailValidator.isValid("teste@dominio.invalido"); // false
+     */
+    static isValid(email: string): boolean;
+}

package/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './array.util';
+export * from './css.util';
+export * from './currency.util';
+export * from './date.util';
+export * from './document.util';
+export * from './email.util';
+export * from './number-to-words.util';
+export * from './number.util';
+export * from './object.util';
+export * from './phone.util';
+export * from './states.util';
+export * from './storage.util';
+export * from './string.util';
+export * from './uuid.util';

package/utils/number-to-words.util.d.ts

@@ -0,0 +1,17 @@
+export declare class NumberToWordsUtil {
+    private static readonly _UNITS;
+    private static readonly _TENS;
+    private static readonly _HUNDREDS;
+    private static readonly _THOUSANDS;
+    private static readonly _CURRENCY;
+    private static readonly _PERCENT;
+    private static _handleDecimalNumber;
+    private static _readDigitsIndividually;
+    private static _handleTens;
+    private static _handleHundreds;
+    private static _handleLargeNumbers;
+    private static _handleDecimalPercentage;
+    static convertNumber(num: number): string;
+    static convertCurrency(num: number): string;
+    static convertPercentage(num: number): string;
+}

package/utils/number.util.d.ts

@@ -0,0 +1,40 @@
+export declare class NumberUtil {
+    /**
+     * Verifica se um valor é considerado vazio.
+     *
+     * Um valor é considerado vazio se for:
+     *    -        `null` ou `undefined`
+     *    -        Uma string vazia `""`
+     *    -        Um número `NaN`
+     *    -        Um array vazio `[]`
+     *    -        Um objeto sem propriedades `{}`
+     *    -        Um valor de data inválido
+     *
+     * @param inp O valor a ser verificado.
+     * @returns `true` se o valor for vazio, caso contrário, `false`.
+     */
+    static isEmpty(inp: unknown): inp is null | undefined;
+    /**
+     * Obtém somente os números de uma string.
+     * @param input O valor a ser que será extraido.
+     * @returns somente os números da string.
+     */
+    static onlyNumbers(inp: string): string;
+    /**
+     * Formata um número como moeda, aplicando separadores de milhares e casas decimais.
+     *
+     * @param inp O número a ser formatado.
+     * @param decimalPoint Número de casas decimais (padrão: `2`).
+     * @param decimalSep Caracter utilizado como separador decimal (padrão: `,`).
+     * @param thousandsSep Caracter utilizado como separador de milhares (padrão: `.`).
+     * @returns O número formatado como moeda, representado em uma string.
+     */
+    static formatMoney(inp: number, decimalPoint?: number, decimalSep?: string, thousandsSep?: string): string;
+    /**
+     * Converte uma string ou número para um número.
+     * @param value O valor a ser convertido.
+     * @returns O número convertido.
+     * @throws Se o valor não puder ser convertido para um número.
+     */
+    static strToNumber(value: number | string): number;
+}