@atlantjs/arch 13.2.0 → 14.0.0

package/objects/@common/edges/url.edge.js

@@ -16,5 +16,254 @@ class UrlEdge extends string_edge_sketch_1.StringEdgeSketch {
             throw new Error(`${this._url} should be a valid URL.`);
         }
     }
+    // ==================== Getters ====================
+    /**
+     * Retorna a URL completa como string.
+     * @returns String com a URL completa
+     * @example
+     * new UrlEdge("https://example.com/path?q=1").toString()
+     * // "https://example.com/path?q=1"
+     */
+    toString() {
+        return this._url;
+    }
+    /**
+     * Retorna o protocolo da URL (sem "://").
+     * @returns String com o protocolo
+     * @example
+     * new UrlEdge("https://example.com").getProtocol() // "https:"
+     * new UrlEdge("http://example.com").getProtocol() // "http:"
+     */
+    getProtocol() {
+        return new URL(this._url).protocol;
+    }
+    /**
+     * Retorna o hostname da URL (sem porta).
+     * @returns String com o hostname
+     * @example
+     * new UrlEdge("https://example.com:8080/path").getHostname() // "example.com"
+     */
+    getHostname() {
+        return new URL(this._url).hostname;
+    }
+    /**
+     * Retorna o host da URL (hostname + porta, se existir).
+     * @returns String com o host
+     * @example
+     * new UrlEdge("https://example.com:8080/path").getHost() // "example.com:8080"
+     * new UrlEdge("https://example.com/path").getHost() // "example.com"
+     */
+    getHost() {
+        return new URL(this._url).host;
+    }
+    /**
+     * Retorna a porta da URL, se definida.
+     * @returns String com a porta ou string vazia se não definida
+     * @example
+     * new UrlEdge("https://example.com:8080/path").getPort() // "8080"
+     * new UrlEdge("https://example.com/path").getPort() // ""
+     */
+    getPort() {
+        return new URL(this._url).port;
+    }
+    /**
+     * Retorna o pathname da URL.
+     * @returns String com o caminho da URL
+     * @example
+     * new UrlEdge("https://example.com/foo/bar").getPathname() // "/foo/bar"
+     * new UrlEdge("https://example.com").getPathname() // "/"
+     */
+    getPathname() {
+        return new URL(this._url).pathname;
+    }
+    /**
+     * Retorna a query string da URL (incluindo "?").
+     * @returns String com a query string ou string vazia se não existir
+     * @example
+     * new UrlEdge("https://example.com/path?q=1&page=2").getSearch() // "?q=1&page=2"
+     * new UrlEdge("https://example.com/path").getSearch() // ""
+     */
+    getSearch() {
+        return new URL(this._url).search;
+    }
+    /**
+     * Retorna o valor de um parâmetro específico da query string.
+     * @param key - Nome do parâmetro a buscar
+     * @returns Valor do parâmetro ou null se não existir
+     * @example
+     * new UrlEdge("https://example.com?q=hello&page=2").getSearchParam("q") // "hello"
+     * new UrlEdge("https://example.com?q=hello").getSearchParam("page") // null
+     */
+    getSearchParam(key) {
+        return new URL(this._url).searchParams.get(key);
+    }
+    /**
+     * Retorna todos os parâmetros da query string como objeto.
+     * @returns Objeto com chave/valor de todos os parâmetros
+     * @example
+     * new UrlEdge("https://example.com?q=hello&page=2").getSearchParams()
+     * // { q: "hello", page: "2" }
+     */
+    getSearchParams() {
+        const params = {};
+        new URL(this._url).searchParams.forEach((value, key) => {
+            params[key] = value;
+        });
+        return params;
+    }
+    /**
+     * Retorna o hash/fragmento da URL (incluindo "#").
+     * @returns String com o hash ou string vazia se não existir
+     * @example
+     * new UrlEdge("https://example.com/page#section-1").getHash() // "#section-1"
+     * new UrlEdge("https://example.com/page").getHash() // ""
+     */
+    getHash() {
+        return new URL(this._url).hash;
+    }
+    /**
+     * Retorna a origem da URL (protocolo + host).
+     * @returns String com a origem
+     * @example
+     * new UrlEdge("https://example.com:8080/path?q=1").getOrigin() // "https://example.com:8080"
+     */
+    getOrigin() {
+        return new URL(this._url).origin;
+    }
+    // ==================== Verificações ====================
+    /**
+     * Verifica se a URL usa o protocolo HTTPS.
+     * @returns true se o protocolo é HTTPS, false caso contrário
+     * @example
+     * new UrlEdge("https://example.com").isHttps() // true
+     * new UrlEdge("http://example.com").isHttps() // false
+     */
+    isHttps() {
+        return new URL(this._url).protocol === "https:";
+    }
+    /**
+     * Verifica se a URL usa o protocolo HTTP.
+     * @returns true se o protocolo é HTTP, false caso contrário
+     * @example
+     * new UrlEdge("http://example.com").isHttp() // true
+     * new UrlEdge("https://example.com").isHttp() // false
+     */
+    isHttp() {
+        return new URL(this._url).protocol === "http:";
+    }
+    /**
+     * Verifica se a URL possui query string.
+     * @returns true se a URL tem parâmetros de query, false caso contrário
+     * @example
+     * new UrlEdge("https://example.com?q=1").hasSearchParams() // true
+     * new UrlEdge("https://example.com").hasSearchParams() // false
+     */
+    hasSearchParams() {
+        return new URL(this._url).searchParams.size > 0;
+    }
+    /**
+     * Verifica se a URL possui um parâmetro específico na query string.
+     * @param key - Nome do parâmetro a verificar
+     * @returns true se o parâmetro existe, false caso contrário
+     * @example
+     * new UrlEdge("https://example.com?q=1").hasSearchParam("q") // true
+     * new UrlEdge("https://example.com?q=1").hasSearchParam("page") // false
+     */
+    hasSearchParam(key) {
+        return new URL(this._url).searchParams.has(key);
+    }
+    /**
+     * Verifica se a URL possui hash/fragmento.
+     * @returns true se a URL tem hash, false caso contrário
+     * @example
+     * new UrlEdge("https://example.com#section").hasHash() // true
+     * new UrlEdge("https://example.com").hasHash() // false
+     */
+    hasHash() {
+        return new URL(this._url).hash.length > 0;
+    }
+    /**
+     * Verifica se esta URL é igual a outra.
+     * @param other - UrlEdge ou string para comparação
+     * @returns true se as URLs são iguais, false caso contrário
+     * @example
+     * const url = new UrlEdge("https://example.com");
+     * url.isEqual(new UrlEdge("https://example.com")) // true
+     * url.isEqual("https://other.com") // false
+     */
+    isEqual(other) {
+        const comparand = other instanceof UrlEdge ? other.toString() : other;
+        return this._url === comparand;
+    }
+    // ==================== Transformação ====================
+    /**
+     * Retorna uma nova URL com um parâmetro de query adicionado ou atualizado.
+     * @param key - Nome do parâmetro
+     * @param value - Valor do parâmetro
+     * @returns Nova instância de UrlEdge com o parâmetro adicionado
+     * @example
+     * new UrlEdge("https://example.com?q=1").withSearchParam("page", "2")
+     * // UrlEdge("https://example.com?q=1&page=2")
+     */
+    withSearchParam(key, value) {
+        const parsed = new URL(this._url);
+        parsed.searchParams.set(key, value);
+        return new UrlEdge(parsed.toString());
+    }
+    /**
+     * Retorna uma nova URL sem um parâmetro de query específico.
+     * @param key - Nome do parâmetro a remover
+     * @returns Nova instância de UrlEdge sem o parâmetro
+     * @example
+     * new UrlEdge("https://example.com?q=1&page=2").withoutSearchParam("page")
+     * // UrlEdge("https://example.com?q=1")
+     */
+    withoutSearchParam(key) {
+        const parsed = new URL(this._url);
+        parsed.searchParams.delete(key);
+        return new UrlEdge(parsed.toString());
+    }
+    /**
+     * Retorna uma nova URL sem a query string.
+     * @returns Nova instância de UrlEdge sem query string
+     * @example
+     * new UrlEdge("https://example.com/path?q=1&page=2").withoutSearch()
+     * // UrlEdge("https://example.com/path")
+     */
+    withoutSearch() {
+        const parsed = new URL(this._url);
+        parsed.search = "";
+        return new UrlEdge(parsed.toString());
+    }
+    /**
+     * Retorna uma nova URL sem o hash/fragmento.
+     * @returns Nova instância de UrlEdge sem hash
+     * @example
+     * new UrlEdge("https://example.com/page#section").withoutHash()
+     * // UrlEdge("https://example.com/page")
+     */
+    withoutHash() {
+        const parsed = new URL(this._url);
+        parsed.hash = "";
+        return new UrlEdge(parsed.toString());
+    }
+    // ==================== Métodos Estáticos ====================
+    /**
+     * Verifica se uma string é uma URL válida sem lançar exceção.
+     * @param value - String a ser verificada
+     * @returns true se a string é uma URL válida, false caso contrário
+     * @example
+     * UrlEdge.isValid("https://example.com") // true
+     * UrlEdge.isValid("not-a-url") // false
+     */
+    static isValid(value) {
+        try {
+            new URL(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
 }
 exports.UrlEdge = UrlEdge;

package/objects/@common/edges/username.edge.d.ts

@@ -1,3 +1,12 @@
 import { StringEdgeSketch } from "../../primitives/string.edge.sketch";
 export declare class UsernameEdge extends StringEdgeSketch {
+    private static readonly pattern;
+    constructor(username: string);
+    protected validateUsername(): void;
+    toString(): string;
+    toNormalized(): string;
+    isEqual(other: string | UsernameEdge, ignoreCase?: boolean): boolean;
+    hasOnlyAlphanumeric(): boolean;
+    startsWithLetter(): boolean;
+    static isValid(value: string): boolean;
 }

package/objects/@common/edges/username.edge.js

@@ -3,5 +3,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UsernameEdge = void 0;
 const string_edge_sketch_1 = require("../../primitives/string.edge.sketch");
 class UsernameEdge extends string_edge_sketch_1.StringEdgeSketch {
+    constructor(username) {
+        super(username);
+        this.validateUsername();
+    }
+    validateUsername() {
+        if (!UsernameEdge.pattern.test(this.toString())) {
+            throw new TypeError(`${this.constructor.name} should be valid (3-30, letters/numbers/._-, no separator at start/end).`);
+        }
+    }
+    // ==================== Getters ====================
+    toString() {
+        return super.toString();
+    }
+    toNormalized() {
+        return this.toString().toLowerCase();
+    }
+    // ==================== Verificações ====================
+    isEqual(other, ignoreCase = true) {
+        const comparand = other instanceof UsernameEdge ? other.toString() : other.trim();
+        return ignoreCase
+            ? this.toString().toLowerCase() === comparand.toLowerCase()
+            : this.toString() === comparand;
+    }
+    hasOnlyAlphanumeric() {
+        return /^[a-zA-Z0-9]+$/.test(this.toString());
+    }
+    startsWithLetter() {
+        return /^[a-zA-Z]/.test(this.toString());
+    }
+    // ==================== Métodos Estáticos ====================
+    static isValid(value) {
+        return UsernameEdge.pattern.test(value.trim());
+    }
 }
 exports.UsernameEdge = UsernameEdge;
+UsernameEdge.pattern = /^(?=.{3,30}$)[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$/;

package/objects/@common/edges/uuid.sketch.edge.d.ts

@@ -2,6 +2,102 @@ export declare abstract class UuidSketchEdge {
     private readonly value;
     private static readonly pattern;
     constructor(value?: string);
-    equals(uuid: UuidSketchEdge): boolean;
+    /**
+     * Retorna o UUID como string.
+     * @returns String no formato UUID v4
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toString()
+     * // "550e8400-e29b-41d4-a716-446655440000"
+     */
     toString(): string;
+    /**
+     * Retorna o UUID sem hífens.
+     * @returns String de 32 caracteres hexadecimais sem separadores
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toRaw()
+     * // "550e8400e29b41d4a716446655440000"
+     */
+    toRaw(): string;
+    /**
+     * Retorna os segmentos do UUID separados em um array.
+     * @returns Array com 5 segmentos do UUID
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toSegments()
+     * // ["550e8400", "e29b", "41d4", "a716", "446655440000"]
+     */
+    toSegments(): string[];
+    /**
+     * Verifica se este UUID é igual a outro.
+     * @param other - UuidSketchEdge para comparação
+     * @returns true se os UUIDs são iguais, false caso contrário
+     * @example
+     * const id = new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000");
+     * id.isEqual(id) // true
+     */
+    isEqual(other: UuidSketchEdge): boolean;
+    /**
+     * Verifica se este UUID é diferente de outro.
+     * @param other - UuidSketchEdge para comparação
+     * @returns true se os UUIDs são diferentes, false caso contrário
+     * @example
+     * const a = new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000");
+     * const b = new MyUuidEdge("661f9511-f3ac-52e5-b827-557766551111");
+     * a.isDifferent(b) // true
+     */
+    isDifferent(other: UuidSketchEdge): boolean;
+    /**
+     * @deprecated Use `isEqual` instead.
+     * Verifica se este UUID é igual a outro.
+     * @param other - UuidSketchEdge para comparação
+     * @returns true se os UUIDs são iguais, false caso contrário
+     */
+    equals(other: UuidSketchEdge): boolean;
+    /**
+     * Verifica se o UUID está em letras maiúsculas.
+     * @returns true se todos os caracteres alfabéticos são maiúsculos
+     * @example
+     * new MyUuidEdge("550E8400-E29B-41D4-A716-446655440000").isUpperCase() // true
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").isUpperCase() // false
+     */
+    isUpperCase(): boolean;
+    /**
+     * Verifica se o UUID está em letras minúsculas.
+     * @returns true se todos os caracteres alfabéticos são minúsculos
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").isLowerCase() // true
+     * new MyUuidEdge("550E8400-E29B-41D4-A716-446655440000").isLowerCase() // false
+     */
+    isLowerCase(): boolean;
+    /**
+     * Retorna o UUID em letras maiúsculas como string.
+     * @returns UUID em maiúsculas
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toUpperCase()
+     * // "550E8400-E29B-41D4-A716-446655440000"
+     */
+    toUpperCase(): string;
+    /**
+     * Retorna o UUID em letras minúsculas como string.
+     * @returns UUID em minúsculas
+     * @example
+     * new MyUuidEdge("550E8400-E29B-41D4-A716-446655440000").toLowerCase()
+     * // "550e8400-e29b-41d4-a716-446655440000"
+     */
+    toLowerCase(): string;
+    /**
+     * Verifica se uma string é um UUID válido sem lançar exceção.
+     * @param value - String a ser verificada
+     * @returns true se a string é um UUID válido, false caso contrário
+     * @example
+     * UuidSketchEdge.isValid("550e8400-e29b-41d4-a716-446655440000") // true
+     * UuidSketchEdge.isValid("invalid-uuid") // false
+     */
+    static isValid(value: string): boolean;
+    /**
+     * Gera uma nova string UUID v4 sem instanciar a classe.
+     * @returns String no formato UUID v4
+     * @example
+     * UuidSketchEdge.generate() // "a3f8c210-4d92-11ec-81d3-0242ac130003"
+     */
+    static generate(): string;
 }

package/objects/@common/edges/uuid.sketch.edge.js

@@ -7,18 +7,139 @@ exports.UuidSketchEdge = void 0;
 const react_native_uuid_1 = __importDefault(require("react-native-uuid"));
 const index_1 = require("../../../index");
 class UuidSketchEdge {
-    constructor(value = react_native_uuid_1.default.v4()) {
+    constructor(value = String(react_native_uuid_1.default.v4())) {
         this.value = value;
-        if (!UuidSketchEdge.pattern.test(value)) {
+        if (!UuidSketchEdge.pattern.test(this.value)) {
             throw new TypeError("The provided UUID is invalid. Please ensure it is in the correct format");
         }
     }
-    equals(uuid) {
-        return index_1._.isEqual(this.toString(), uuid.toString());
-    }
+    // ==================== Getters ====================
+    /**
+     * Retorna o UUID como string.
+     * @returns String no formato UUID v4
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toString()
+     * // "550e8400-e29b-41d4-a716-446655440000"
+     */
     toString() {
         return this.value;
     }
+    /**
+     * Retorna o UUID sem hífens.
+     * @returns String de 32 caracteres hexadecimais sem separadores
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toRaw()
+     * // "550e8400e29b41d4a716446655440000"
+     */
+    toRaw() {
+        return this.value.replace(/-/g, "");
+    }
+    /**
+     * Retorna os segmentos do UUID separados em um array.
+     * @returns Array com 5 segmentos do UUID
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toSegments()
+     * // ["550e8400", "e29b", "41d4", "a716", "446655440000"]
+     */
+    toSegments() {
+        return this.value.split("-");
+    }
+    // ==================== Comparações ====================
+    /**
+     * Verifica se este UUID é igual a outro.
+     * @param other - UuidSketchEdge para comparação
+     * @returns true se os UUIDs são iguais, false caso contrário
+     * @example
+     * const id = new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000");
+     * id.isEqual(id) // true
+     */
+    isEqual(other) {
+        return index_1._.isEqual(this.value, other.toString());
+    }
+    /**
+     * Verifica se este UUID é diferente de outro.
+     * @param other - UuidSketchEdge para comparação
+     * @returns true se os UUIDs são diferentes, false caso contrário
+     * @example
+     * const a = new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000");
+     * const b = new MyUuidEdge("661f9511-f3ac-52e5-b827-557766551111");
+     * a.isDifferent(b) // true
+     */
+    isDifferent(other) {
+        return !this.isEqual(other);
+    }
+    /**
+     * @deprecated Use `isEqual` instead.
+     * Verifica se este UUID é igual a outro.
+     * @param other - UuidSketchEdge para comparação
+     * @returns true se os UUIDs são iguais, false caso contrário
+     */
+    equals(other) {
+        return this.isEqual(other);
+    }
+    // ==================== Verificações ====================
+    /**
+     * Verifica se o UUID está em letras maiúsculas.
+     * @returns true se todos os caracteres alfabéticos são maiúsculos
+     * @example
+     * new MyUuidEdge("550E8400-E29B-41D4-A716-446655440000").isUpperCase() // true
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").isUpperCase() // false
+     */
+    isUpperCase() {
+        return this.value === this.value.toUpperCase();
+    }
+    /**
+     * Verifica se o UUID está em letras minúsculas.
+     * @returns true se todos os caracteres alfabéticos são minúsculos
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").isLowerCase() // true
+     * new MyUuidEdge("550E8400-E29B-41D4-A716-446655440000").isLowerCase() // false
+     */
+    isLowerCase() {
+        return this.value === this.value.toLowerCase();
+    }
+    // ==================== Transformação ====================
+    /**
+     * Retorna o UUID em letras maiúsculas como string.
+     * @returns UUID em maiúsculas
+     * @example
+     * new MyUuidEdge("550e8400-e29b-41d4-a716-446655440000").toUpperCase()
+     * // "550E8400-E29B-41D4-A716-446655440000"
+     */
+    toUpperCase() {
+        return this.value.toUpperCase();
+    }
+    /**
+     * Retorna o UUID em letras minúsculas como string.
+     * @returns UUID em minúsculas
+     * @example
+     * new MyUuidEdge("550E8400-E29B-41D4-A716-446655440000").toLowerCase()
+     * // "550e8400-e29b-41d4-a716-446655440000"
+     */
+    toLowerCase() {
+        return this.value.toLowerCase();
+    }
+    // ==================== Métodos Estáticos ====================
+    /**
+     * Verifica se uma string é um UUID válido sem lançar exceção.
+     * @param value - String a ser verificada
+     * @returns true se a string é um UUID válido, false caso contrário
+     * @example
+     * UuidSketchEdge.isValid("550e8400-e29b-41d4-a716-446655440000") // true
+     * UuidSketchEdge.isValid("invalid-uuid") // false
+     */
+    static isValid(value) {
+        return UuidSketchEdge.pattern.test(value);
+    }
+    /**
+     * Gera uma nova string UUID v4 sem instanciar a classe.
+     * @returns String no formato UUID v4
+     * @example
+     * UuidSketchEdge.generate() // "a3f8c210-4d92-11ec-81d3-0242ac130003"
+     */
+    static generate() {
+        return String(react_native_uuid_1.default.v4());
+    }
 }
 exports.UuidSketchEdge = UuidSketchEdge;
-UuidSketchEdge.pattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+UuidSketchEdge.pattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;

package/objects/amount/amount-value.edge.d.ts

@@ -0,0 +1,42 @@
+import { NumberEdgeSketch } from "../primitives/number.edge.sketch";
+export declare class AmountValueEdge extends NumberEdgeSketch {
+    constructor(value: number);
+    /**
+     * Retorna o valor em centavos.
+     * Ex.: 10.25 -> 1025
+     */
+    toCents(): number;
+    /**
+     * Formata o valor monetário.
+     */
+    toCurrency(locale?: string, currency?: string): string;
+    /**
+     * Indica se possui mais de 2 casas decimais.
+     */
+    hasMoreThanTwoDecimals(): boolean;
+    /**
+     * Retorna novo AmountValueEdge somando com outro valor.
+     */
+    plus(value: number | AmountValueEdge): AmountValueEdge;
+    /**
+     * Retorna novo AmountValueEdge subtraindo outro valor.
+     */
+    minus(value: number | AmountValueEdge): AmountValueEdge;
+    /**
+     * Cria AmountValueEdge a partir de centavos.
+     */
+    static fromCents(cents: number): AmountValueEdge;
+    /**
+     * Cria AmountValueEdge zerado.
+     */
+    static zero(): AmountValueEdge;
+    /**
+     * Verifica se um número pode ser usado como amount.
+     */
+    static isValid(value: number): boolean;
+    /**
+     * Bug fix: NumberEdgeSketch valida NaN, mas permite Infinity.
+     * Para amount monetário, restringimos para número finito.
+     */
+    private validateAmount;
+}

package/objects/amount/amount-value.edge.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmountValueEdge = void 0;
+const number_edge_sketch_1 = require("../primitives/number.edge.sketch");
+class AmountValueEdge extends number_edge_sketch_1.NumberEdgeSketch {
+    constructor(value) {
+        super(value);
+        this.validateAmount();
+    }
+    /**
+     * Retorna o valor em centavos.
+     * Ex.: 10.25 -> 1025
+     */
+    toCents() {
+        return Math.round(this.toNumber() * 100);
+    }
+    /**
+     * Formata o valor monetário.
+     */
+    toCurrency(locale = "pt-BR", currency = "BRL") {
+        return new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency,
+        }).format(this.toNumber());
+    }
+    /**
+     * Indica se possui mais de 2 casas decimais.
+     */
+    hasMoreThanTwoDecimals() {
+        return !Number.isInteger(this.toNumber() * 100);
+    }
+    /**
+     * Retorna novo AmountValueEdge somando com outro valor.
+     */
+    plus(value) {
+        const operand = value instanceof AmountValueEdge ? value.toNumber() : value;
+        const resultInCents = this.toCents() + Math.round(operand * 100);
+        return AmountValueEdge.fromCents(resultInCents);
+    }
+    /**
+     * Retorna novo AmountValueEdge subtraindo outro valor.
+     */
+    minus(value) {
+        const operand = value instanceof AmountValueEdge ? value.toNumber() : value;
+        const resultInCents = this.toCents() - Math.round(operand * 100);
+        return AmountValueEdge.fromCents(resultInCents);
+    }
+    /**
+     * Cria AmountValueEdge a partir de centavos.
+     */
+    static fromCents(cents) {
+        return new AmountValueEdge(cents / 100);
+    }
+    /**
+     * Cria AmountValueEdge zerado.
+     */
+    static zero() {
+        return new AmountValueEdge(0);
+    }
+    /**
+     * Verifica se um número pode ser usado como amount.
+     */
+    static isValid(value) {
+        return Number.isFinite(value);
+    }
+    /**
+     * Bug fix: NumberEdgeSketch valida NaN, mas permite Infinity.
+     * Para amount monetário, restringimos para número finito.
+     */
+    validateAmount() {
+        if (!Number.isFinite(this.toNumber())) {
+            throw new TypeError(`${this.constructor.name} should be a finite number.`);
+        }
+    }
+}
+exports.AmountValueEdge = AmountValueEdge;