@jmlq/auth 0.0.1-alpha.1

package/dist/src/domain/object-values/permission.d.ts

@@ -0,0 +1,15 @@
+export declare class Permission {
+    private readonly value;
+    constructor(permission: string);
+    getValue(): string;
+    equals(other: Permission): boolean;
+    toString(): string;
+    static create(permission: string): Permission;
+    /** ¿Es comodín total? */
+    isWildcard(): boolean;
+    /**
+     * ¿Hace match con el target? Soporta prefijos tipo "read:*".
+     * Si el target es inválido (no string o vacío tras trim), devuelve false.
+     */
+    matches(targetPermission: string): boolean;
+}

package/dist/src/domain/object-values/permission.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Permission = void 0;
+const errors_1 = require("../errors");
+class Permission {
+    constructor(permission) {
+        if (permission == null) {
+            throw new errors_1.InvalidPermissionError("Permission cannot be null or undefined");
+        }
+        if (typeof permission !== "string") {
+            throw new errors_1.InvalidPermissionError("Permission must be a string");
+        }
+        const normalized = permission.toLowerCase().trim();
+        if (!normalized) {
+            throw new errors_1.InvalidPermissionError("Permission cannot be empty");
+        }
+        this.value = normalized;
+    }
+    getValue() {
+        return this.value;
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    toString() {
+        return this.value;
+    }
+    static create(permission) {
+        return new Permission(permission);
+    }
+    /** ¿Es comodín total? */
+    isWildcard() {
+        return this.value === "*";
+    }
+    /**
+     * ¿Hace match con el target? Soporta prefijos tipo "read:*".
+     * Si el target es inválido (no string o vacío tras trim), devuelve false.
+     */
+    matches(targetPermission) {
+        if (typeof targetPermission !== "string")
+            return false;
+        const target = targetPermission.toLowerCase().trim();
+        if (!target)
+            return false;
+        if (this.isWildcard())
+            return true;
+        if (this.value === target)
+            return true;
+        // patrón "algo:*" → prefijo
+        if (this.value.endsWith(":*")) {
+            const prefix = this.value.slice(0, -1); // elimina '*'
+            return target.startsWith(prefix);
+        }
+        return false;
+    }
+}
+exports.Permission = Permission;

package/dist/src/domain/object-values/role.d.ts

@@ -0,0 +1,25 @@
+import { Permission } from "./permission";
+export declare class Role {
+    private readonly value;
+    private readonly permissions;
+    private readonly validRoles;
+    constructor(role: string, permissions?: Permission[], validRoles?: string[]);
+    getValuePublic(): {
+        role: string;
+    };
+    getValue(): {
+        role: string;
+        permissions: string[];
+    };
+    getPermissions(): Permission[];
+    hasPermission(permission: Permission | string): boolean;
+    hasAnyPermission(permissions: (Permission | string)[]): boolean;
+    hasAllPermissions(permissions: (Permission | string)[]): boolean;
+    equals(other: Role): boolean;
+    hasRole(roleName: string): boolean;
+    toString(): string;
+    static withValidRoles(role: string, permissions: Permission[] | undefined, validRoles: string[]): Role;
+    static create(role: string, permissions?: Permission[]): Role;
+    withPermissions(newPermissions: Permission[]): Role;
+    canPerform(action: string, resource?: string): boolean;
+}

package/dist/src/domain/object-values/role.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = void 0;
+const errors_1 = require("../errors");
+const permission_1 = require("./permission");
+class Role {
+    constructor(role, permissions = [], validRoles) {
+        if (role == null) {
+            throw new errors_1.InvalidRoleError("Role cannot be null or undefined");
+        }
+        if (typeof role !== "string") {
+            throw new errors_1.InvalidRoleError("Role must be a string");
+        }
+        const normalizedRole = role.toLowerCase().trim();
+        if (!normalizedRole) {
+            throw new errors_1.InvalidRoleError("Role cannot be empty");
+        }
+        if (validRoles && validRoles.length > 0) {
+            const normalizedValid = validRoles.map((r) => {
+                if (r == null || typeof r !== "string") {
+                    throw new errors_1.InvalidRoleError("Valid roles must be strings");
+                }
+                return r.toLowerCase().trim();
+            });
+            this.validRoles = new Set(normalizedValid);
+            if (!this.validRoles.has(normalizedRole)) {
+                throw new errors_1.InvalidRoleError(`Invalid role: ${role}. Valid roles are: ${validRoles.join(", ")}`);
+            }
+        }
+        else {
+            this.validRoles = new Set();
+        }
+        // Valida permissions defensivamente
+        for (const p of permissions) {
+            if (!(p instanceof permission_1.Permission)) {
+                throw new errors_1.InvalidPermissionError("Permissions must be Permission instances");
+            }
+        }
+        this.value = normalizedRole;
+        this.permissions = new Set(permissions.map((p) => p.getValue()));
+    }
+    getValuePublic() {
+        return {
+            role: this.value,
+        };
+    }
+    getValue() {
+        return {
+            role: this.value,
+            permissions: Array.from(this.permissions), // Para validaciones server-side
+        };
+    }
+    getPermissions() {
+        return Array.from(this.permissions).map((p) => permission_1.Permission.create(p));
+    }
+    hasPermission(permission) {
+        const permissionValue = typeof permission === "string"
+            ? permission.toLowerCase().trim()
+            : permission.getValue();
+        // Verificar permiso directo
+        if (this.permissions.has(permissionValue)) {
+            return true;
+        }
+        // Verificar con patrones (comodines)
+        for (const p of this.permissions) {
+            const perm = permission_1.Permission.create(p);
+            if (perm.matches(permissionValue)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasAnyPermission(permissions) {
+        return permissions.some((p) => this.hasPermission(p));
+    }
+    hasAllPermissions(permissions) {
+        return permissions.every((p) => this.hasPermission(p));
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    hasRole(roleName) {
+        return this.value === roleName.toLowerCase().trim();
+    }
+    toString() {
+        return this.value;
+    }
+    // Método estático para crear roles con validación predefinida
+    static withValidRoles(role, permissions = [], validRoles) {
+        return new Role(role, permissions, validRoles);
+    }
+    // Método estático para crear roles sin validación (más flexible)
+    static create(role, permissions = []) {
+        return new Role(role, permissions);
+    }
+    // Método para crear un nuevo rol con permisos adicionales
+    withPermissions(newPermissions) {
+        const allPermissions = [...this.getPermissions(), ...newPermissions];
+        const validRolesArray = this.validRoles.size > 0 ? Array.from(this.validRoles) : undefined;
+        return new Role(this.value, allPermissions, validRolesArray);
+    }
+    // Método para verificar si puede realizar una acción específica
+    canPerform(action, resource) {
+        const fullPermission = resource ? `${action}:${resource}` : action;
+        return this.hasPermission(fullPermission);
+    }
+}
+exports.Role = Role;

package/dist/src/domain/ports/auth/password-hasher.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Interface for password hashing and comparison.
+ */
+export interface IPasswordHasher {
+    hash(plainPassword: string): Promise<string>;
+    compare(plainPassword: string, hashedPassword: string): Promise<boolean>;
+}

package/dist/src/domain/ports/auth/password-hasher.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/auth/password-policy-config.port.js

@@ -0,0 +1,10 @@
+"use strict";
+// // Impone reglas para las contraseñas
+// export interface IPasswordPolicyConfig {
+//   minLength: number;
+//   maxLength: number;
+//   requireUppercase: boolean;
+//   requireLowercase: boolean;
+//   requireNumbers: boolean;
+//   requireSpecialChars: boolean;
+// }

package/dist/src/domain/ports/auth/password-policy.port.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface for password policy validation.
+ */
+export interface IPasswordPolicy {
+    validateStrength(password: string): {
+        isValid: boolean;
+        errors: string[];
+    };
+    getRequirements(): string[];
+}

package/dist/src/domain/ports/auth/password-policy.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/config/auth-config.port.d.ts

@@ -0,0 +1,19 @@
+import { AnyAlgorithm } from "src/shared";
+export interface IAuthConfig {
+    jwt: {
+        accessTokenSecret: string;
+        refreshTokenSecret: string;
+        accessTokenExpirationMs: number;
+        refreshTokenExpirationMs: number;
+        accessTokenExpiration?: string;
+        refreshTokenExpiration?: string;
+    };
+    bcrypt: {
+        saltRounds: number;
+    };
+    info: {
+        audience?: string;
+        issuer?: string;
+    };
+    algorithm: AnyAlgorithm;
+}

package/dist/src/domain/ports/config/auth-config.port.js

@@ -0,0 +1,3 @@
+"use strict";
+// Configuración central del módulo de autenticación
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./auth/password-hasher";
+export * from "./auth/password-policy.port";
+export * from "./config/auth-config.port";
+export * from "./jwt/factory/signature-strategy-factory.port";
+export * from "./jwt/payload/jwt-payload.port";
+export * from "./jwt/strategy/signature-strategy.port";
+export * from "./repository";
+export * from "./token/token-session.port";
+export * from "./token/token.service.port";

package/dist/src/domain/ports/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth/password-hasher"), exports);
+__exportStar(require("./auth/password-policy.port"), exports);
+__exportStar(require("./config/auth-config.port"), exports);
+__exportStar(require("./jwt/factory/signature-strategy-factory.port"), exports);
+__exportStar(require("./jwt/payload/jwt-payload.port"), exports);
+__exportStar(require("./jwt/strategy/signature-strategy.port"), exports);
+__exportStar(require("./repository"), exports);
+__exportStar(require("./token/token-session.port"), exports);
+__exportStar(require("./token/token.service.port"), exports);

package/dist/src/domain/ports/jwt/factory/signature-strategy-factory.port.d.ts

@@ -0,0 +1,14 @@
+import { ISignatureStrategy } from "../..";
+import { AlgorithmName } from "../../../../shared";
+export interface ISignatureStrategyFactory {
+    /**
+     * Devuelve una estrategia capaz de firmar/verificar con el algoritmo dado.
+     * Debe lanzar si el algoritmo no es soportado.
+     */
+    create(alg: AlgorithmName): ISignatureStrategy;
+    /**
+     * (Opcional, útil para validaciones/feature flags)
+     * Lista de algoritmos soportados por la implementación.
+     */
+    supported(): ReadonlyArray<AlgorithmName>;
+}

package/dist/src/domain/ports/jwt/factory/signature-strategy-factory.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/jwt/payload/jwt-payload.port.d.ts

@@ -0,0 +1,12 @@
+export interface IJWTPayload {
+    sub: string;
+    roles: Array<{
+        role: string;
+    }>;
+    customClaims: Record<string, any>;
+    jti: string;
+    iss?: string;
+    aud?: string;
+    iat: number;
+    exp: number;
+}

package/dist/src/domain/ports/jwt/payload/jwt-payload.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/jwt/signature-strategy-factory.port.d.ts

@@ -0,0 +1,14 @@
+import { ISignatureStrategy } from "..";
+import { AlgorithmName } from "../../../shared";
+export interface ISignatureStrategyFactory {
+    /**
+     * Devuelve una estrategia capaz de firmar/verificar con el algoritmo dado.
+     * Debe lanzar si el algoritmo no es soportado.
+     */
+    create(alg: AlgorithmName): ISignatureStrategy;
+    /**
+     * (Opcional, útil para validaciones/feature flags)
+     * Lista de algoritmos soportados por la implementación.
+     */
+    supported(): ReadonlyArray<AlgorithmName>;
+}

package/dist/src/domain/ports/jwt/signature-strategy-factory.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/jwt/signature-strategy.d.ts

@@ -0,0 +1,30 @@
+/**
+ *Esta interfaz implementa el patrón Strategy para el manejo de firmas digitales en JWT.
+ *Define un contrato común para todas las estrategias de firma digital, permitiendo que diferentes
+ *algoritmos de firma (HMAC, RSA, ECDSA) sean intercambiables de manera transparente.
+ */
+export interface SignatureStrategy {
+    /**
+     *Firma digitalmente los datos usando la clave proporcionada
+     *Retorna la firma digital como string codificado
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param key La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)
+     * @returns La firma digital como string codificado
+     */
+    sign(data: string, key: string): string;
+    /**
+     *Verifica si una firma es válida para los datos dados
+     *Retorna true si la firma es válida, false si no
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param key La clave para verificar (secreta para HMAC, pública para RSA/ECDSA)
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data: string, signature: string, key: string): boolean;
+    /**
+     *Identifica qué algoritmo soporta esta estrategia específica
+     *El nombre del algoritmo (ej: 'HS256', 'RS256', 'ES256')
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm(): string;
+}

package/dist/src/domain/ports/jwt/signature-strategy.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// data: Los datos a firmar (normalmente el header + payload del JWT)
+// key: La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)

package/dist/src/domain/ports/jwt/signature-strategy.port.d.ts

@@ -0,0 +1,31 @@
+import { AlgorithmName } from "../../../shared";
+/**
+ *Esta interfaz implementa el patrón Strategy para el manejo de firmas digitales en JWT.
+ *Define un contrato común para todas las estrategias de firma digital, permitiendo que diferentes
+ *algoritmos de firma (HMAC, RSA, ECDSA) sean intercambiables de manera transparente.
+ */
+export interface ISignatureStrategy {
+    /**
+     *Firma digitalmente los datos usando la clave proporcionada
+     *Retorna la firma digital como string codificado
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param key La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)
+     * @returns La firma digital como string codificado
+     */
+    sign(data: string, key: string): string;
+    /**
+     *Verifica si una firma es válida para los datos dados
+     *Retorna true si la firma es válida, false si no
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param key La clave para verificar (secreta para HMAC, pública para RSA/ECDSA)
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data: string, signature: string, key: string): boolean;
+    /**
+     *Identifica qué algoritmo soporta esta estrategia específica
+     *El nombre del algoritmo (ej: 'HS256', 'RS256', 'ES256')
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm(): AlgorithmName;
+}

package/dist/src/domain/ports/jwt/signature-strategy.port.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// data: Los datos a firmar (normalmente el header + payload del JWT)
+// key: La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)

package/dist/src/domain/ports/jwt/strategy/signature-strategy.port.d.ts

@@ -0,0 +1,31 @@
+import { AlgorithmName } from "../../../../shared";
+/**
+ *Esta interfaz implementa el patrón Strategy para el manejo de firmas digitales en JWT.
+ *Define un contrato común para todas las estrategias de firma digital, permitiendo que diferentes
+ *algoritmos de firma (HMAC, RSA, ECDSA) sean intercambiables de manera transparente.
+ */
+export interface ISignatureStrategy {
+    /**
+     *Firma digitalmente los datos usando la clave proporcionada
+     *Retorna la firma digital como string codificado
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param key La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)
+     * @returns La firma digital como string codificado
+     */
+    sign(data: string, key: string): string;
+    /**
+     *Verifica si una firma es válida para los datos dados
+     *Retorna true si la firma es válida, false si no
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param key La clave para verificar (secreta para HMAC, pública para RSA/ECDSA)
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data: string, signature: string, key: string): boolean;
+    /**
+     *Identifica qué algoritmo soporta esta estrategia específica
+     *El nombre del algoritmo (ej: 'HS256', 'RS256', 'ES256')
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm(): AlgorithmName;
+}

package/dist/src/domain/ports/jwt/strategy/signature-strategy.port.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// data: Los datos a firmar (normalmente el header + payload del JWT)
+// key: La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)

package/dist/src/domain/ports/repository/credential.repository.d.ts

@@ -0,0 +1,10 @@
+import { Credential } from "../../entities";
+import { Id } from "../../object-values";
+export interface ICredentialRepository {
+    save(credential: Credential): Promise<void>;
+    findByUserId(userId: Id): Promise<Credential | null>;
+    findByRefreshToken(refreshToken: string): Promise<Credential | null>;
+    update(credential: Credential): Promise<void>;
+    delete(userId: Id): Promise<void>;
+    deleteByRefreshToken(refreshToken: string): Promise<void>;
+}

package/dist/src/domain/ports/repository/credential.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/repository/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./credential.repository";
+export * from "./user.repository";

package/dist/src/domain/ports/repository/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./credential.repository"), exports);
+__exportStar(require("./user.repository"), exports);

package/dist/src/domain/ports/repository/user.repository.d.ts

@@ -0,0 +1,13 @@
+import { User } from "../../entities";
+import { Email, Id } from "../../object-values";
+/**
+ * UserRepository defines the contract for user data persistence operations.
+ */
+export interface IUserRepository {
+    save(user: User): Promise<void>;
+    findById(id: Id): Promise<User | null>;
+    findByEmail(email: Email): Promise<User | null>;
+    update(user: User): Promise<void>;
+    delete(id: Id): Promise<void>;
+    exists(email: Email): Promise<boolean>;
+}

package/dist/src/domain/ports/repository/user.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/token/token-session.port.d.ts

@@ -0,0 +1,7 @@
+import { Credential, User } from "src/domain/entities";
+export interface ITokenSession {
+    createSession(user: User): Promise<Credential>;
+    refreshSession(refreshToken: string): Promise<Credential>;
+    validateSession(accessToken: string): Promise<User | null>;
+    revokeSession(refreshToken: string): Promise<void>;
+}

package/dist/src/domain/ports/token/token-session.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/ports/token/token.service.port.d.ts

@@ -0,0 +1,9 @@
+import { IJWTPayload } from "..";
+import { IGenerateAccessTokenProps, IGenerateRefreshTokenProps } from "../../props";
+export interface ITokenService {
+    generateAccessToken(props: IGenerateAccessTokenProps): Promise<string>;
+    generateRefreshToken(props: IGenerateRefreshTokenProps): Promise<string>;
+    verifyAccessToken(token: string): Promise<IJWTPayload>;
+    verifyRefreshToken(token: string): Promise<IJWTPayload>;
+    getTokenExpiration(token: string): Promise<Date>;
+}

package/dist/src/domain/ports/token/token.service.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/props/create-payload-props.port.js

@@ -0,0 +1,8 @@
+"use strict";
+// export interface ICreatePayloadProps {
+//   user: User;
+//   expiresIn: string | undefined;
+//   defaultExpirationMs: number;
+//   customClaims?: Record<string, any>;
+//   config: JwtTokenServiceConfig;
+// }

package/dist/src/domain/props/entities/credential.props.d.ts

@@ -0,0 +1,8 @@
+import { Id } from "../../object-values";
+export interface ICredentialProps {
+    userId: Id;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: Date;
+    createdAt: Date;
+}

package/dist/src/domain/props/entities/credential.props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/props/entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./credential.props";
+export * from "./user.props";

package/dist/src/domain/props/entities/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./credential.props"), exports);
+__exportStar(require("./user.props"), exports);

package/dist/src/domain/props/entities/user.props.d.ts

@@ -0,0 +1,10 @@
+import { Email, HashedPassword, Id, Role } from "../../object-values";
+export interface IUserProps {
+    id: Id;
+    email: Email;
+    roles: Role[];
+    password: HashedPassword;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/src/domain/props/entities/user.props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/domain/props/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./entities";
+export * from "./jwt";