@classytic/payroll 1.0.1 → 1.0.2

package/dist/types/services/compensation.service.d.ts

@@ -0,0 +1,94 @@
+export class CompensationService {
+    constructor(EmployeeModel: any);
+    EmployeeModel: any;
+    getEmployeeCompensation(employeeId: any): Promise<any>;
+    calculateBreakdown(employeeId: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    updateBaseAmount(employeeId: any, newAmount: any, effectiveFrom: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    applyIncrement(employeeId: any, { percentage, amount, effectiveFrom }: {
+        percentage: any;
+        amount: any;
+        effectiveFrom: any;
+    }): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    addAllowance(employeeId: any, allowance: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    removeAllowance(employeeId: any, allowanceType: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    addDeduction(employeeId: any, deduction: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    removeDeduction(employeeId: any, deductionType: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    setStandardCompensation(employeeId: any, baseAmount: any): Promise<{
+        baseAmount: any;
+        allowances: any;
+        deductions: any;
+        grossAmount: any;
+        netAmount: number;
+    }>;
+    compareCompensation(employeeId1: any, employeeId2: any): Promise<{
+        employee1: {
+            baseAmount: any;
+            allowances: any;
+            deductions: any;
+            grossAmount: any;
+            netAmount: number;
+        };
+        employee2: {
+            baseAmount: any;
+            allowances: any;
+            deductions: any;
+            grossAmount: any;
+            netAmount: number;
+        };
+        difference: {
+            base: number;
+            gross: number;
+            net: number;
+        };
+        ratio: {
+            base: number;
+            gross: number;
+            net: number;
+        };
+    }>;
+    getDepartmentCompensationStats(organizationId: any, department: any): Promise<any>;
+    getOrganizationCompensationStats(organizationId: any): Promise<any>;
+}
+export function createCompensationService(EmployeeModel: any): CompensationService;

package/dist/types/services/employee.service.d.ts

@@ -0,0 +1,28 @@
+export class EmployeeService {
+    constructor(EmployeeModel: any);
+    EmployeeModel: any;
+    findById(employeeId: any): Promise<any>;
+    findByUserId(userId: any, organizationId: any): Promise<any>;
+    findActive(organizationId: any, options?: {}): Promise<any>;
+    findEmployed(organizationId: any, options?: {}): Promise<any>;
+    findByDepartment(organizationId: any, department: any): Promise<any>;
+    findEligibleForPayroll(organizationId: any, month: any, year: any): Promise<any>;
+    create(data: any): Promise<any>;
+    updateStatus(employeeId: any, status: any, context?: {}): Promise<any>;
+    terminate(employeeId: any, reason: any, context?: {}): Promise<any>;
+    updateCompensation(employeeId: any, compensation: any): Promise<any>;
+    getEmployeeStats(organizationId: any): Promise<{
+        total: any;
+        active: any;
+        employed: any;
+        canReceiveSalary: any;
+        byStatus: any;
+        byDepartment: any;
+    }>;
+    groupByStatus(employees: any): any;
+    groupByDepartment(employees: any): any;
+    isActive(employee: any): boolean;
+    isEmployed(employee: any): boolean;
+    canReceiveSalary(employee: any): boolean;
+}
+export function createEmployeeService(EmployeeModel: any): EmployeeService;

package/dist/types/services/payroll.service.d.ts

@@ -0,0 +1,30 @@
+export class PayrollService {
+    constructor(PayrollModel: any, EmployeeService: any);
+    PayrollModel: any;
+    EmployeeService: any;
+    findById(payrollId: any): Promise<any>;
+    findByEmployee(employeeId: any, organizationId: any, options?: {}): Promise<any>;
+    findForPeriod(organizationId: any, month: any, year: any): Promise<any>;
+    findPending(organizationId: any, month: any, year: any): Promise<any>;
+    create(data: any): Promise<any>;
+    generateForEmployee(employeeId: any, organizationId: any, month: any, year: any): Promise<any>;
+    generateBatch(organizationId: any, month: any, year: any): Promise<{
+        success: boolean;
+        generated: number;
+        message: string;
+        payrolls?: undefined;
+    } | {
+        success: boolean;
+        generated: any;
+        payrolls: any;
+        message?: undefined;
+    }>;
+    markAsPaid(payrollId: any, paymentDetails?: {}): Promise<any>;
+    markAsProcessed(payrollId: any): Promise<any>;
+    calculatePeriodSummary(organizationId: any, month: any, year: any): Promise<any>;
+    getEmployeePayrollHistory(employeeId: any, organizationId: any, limit?: number): Promise<any>;
+    findByEmployeeAndPeriod(employeeId: any, organizationId: any, month: any, year: any): Promise<any>;
+    groupByStatus(payrolls: any): any;
+    getOverviewStats(organizationId: any): Promise<any>;
+}
+export function createPayrollService(PayrollModel: any, EmployeeService: any): PayrollService;

package/dist/types/utils/calculation.utils.d.ts

@@ -0,0 +1,26 @@
+export function sum(items: any, key: any): any;
+export function sumBy(key: any): (items: any) => any;
+export function sumAllowances(items: any): any;
+export function sumDeductions(items: any): any;
+export function calculateGross(base: any, allowances: any): any;
+export function calculateNet(gross: any, deductions: any): number;
+export function calculateTotalCompensation(base: any, allowances: any, deductions: any): {
+    gross: any;
+    net: number;
+    deductions: any;
+};
+export function applyTaxBracket(amount: any, brackets: any): number;
+export function calculateTax(amount: any, brackets: any): {
+    gross: any;
+    tax: number;
+    net: number;
+};
+export function proRateAmount(amount: any, workedDays: any, totalDays: any): number;
+export function calculatePercentage(value: any, total: any): number;
+export function applyPercentage(amount: any, percentage: any): number;
+export function composeDeductions(...deductionFns: any[]): (amount: any) => any;
+export function composeSalaryPipeline(base: any, operations: any): any;
+export function createAllowanceCalculator(allowances: any): (base: any) => any;
+export function createDeductionCalculator(deductions: any): (gross: any) => any;
+export function pipe(...fns: any[]): (value: any) => any;
+export function compose(...fns: any[]): (value: any) => any;

package/dist/types/utils/date.utils.d.ts

@@ -0,0 +1,35 @@
+export function addDays(date: any, days: any): Date;
+export function addMonths(date: any, months: any): Date;
+export function addYears(date: any, years: any): Date;
+export function startOfMonth(date: any): Date;
+export function endOfMonth(date: any): Date;
+export function startOfYear(date: any): Date;
+export function endOfYear(date: any): Date;
+export function isWeekday(date: any): boolean;
+export function isWeekend(date: any): boolean;
+export function getPayPeriod(month: any, year: any): {
+    month: any;
+    year: any;
+    startDate: Date;
+    endDate: Date;
+};
+export function getCurrentPeriod(date?: Date): {
+    year: number;
+    month: number;
+};
+export function calculateProbationEnd(hireDate: any, probationMonths: any): Date;
+export function formatDateForDB(date: any): string;
+export function parseDBDate(dateString: any): Date;
+export function diffInDays(start: any, end: any): number;
+export function diffInMonths(start: any, end: any): number;
+export function daysBetween(start: any, end: any): number;
+export function monthsBetween(start: any, end: any): number;
+export function isDateInRange(date: any, start: any, end: any): boolean;
+export function formatPeriod({ month, year }: {
+    month: any;
+    year: any;
+}): string;
+export function parsePeriod(periodString: any): {
+    month: any;
+    year: any;
+};

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Set custom logger implementation
+ * @param {Object} customLogger - Logger instance with info, warn, error, debug methods
+ */
+export function setLogger(customLogger: any): void;
+export namespace logger {
+    function info(...args: any[]): void;
+    function warn(...args: any[]): void;
+    function error(...args: any[]): void;
+    function debug(...args: any[]): void;
+}
+export default logger;

package/dist/types/utils/query-builders.d.ts

@@ -0,0 +1,83 @@
+export function toObjectId(id: any): mongoose.Types.ObjectId;
+export class QueryBuilder {
+    constructor(initialQuery?: {});
+    query: {};
+    where(field: any, value: any): this;
+    whereIn(field: any, values: any): this;
+    whereNotIn(field: any, values: any): this;
+    whereGte(field: any, value: any): this;
+    whereLte(field: any, value: any): this;
+    whereBetween(field: any, start: any, end: any): this;
+    whereExists(field: any): this;
+    whereNotExists(field: any): this;
+    build(): {};
+}
+export function createQueryBuilder(initialQuery: any): QueryBuilder;
+export class EmployeeQueryBuilder extends QueryBuilder {
+    forOrganization(organizationId: any): this;
+    forUser(userId: any): this;
+    withStatus(...statuses: any[]): this;
+    active(): this;
+    employed(): this;
+    inDepartment(department: any): this;
+    inPosition(position: any): this;
+    withEmploymentType(type: any): this;
+    hiredAfter(date: any): this;
+    hiredBefore(date: any): this;
+}
+export class PayrollQueryBuilder extends QueryBuilder {
+    forOrganization(organizationId: any): this;
+    forEmployee(employeeId: any): this;
+    forPeriod(month: any, year: any): this;
+    withStatus(...statuses: any[]): this;
+    paid(): this;
+    pending(): this;
+    inDateRange(start: any, end: any): this;
+}
+export function employee(): EmployeeQueryBuilder;
+export function payroll(): PayrollQueryBuilder;
+export function buildEmployeeQuery({ organizationId, userId, statuses }: {
+    organizationId: any;
+    userId: any;
+    statuses: any;
+}): {};
+export function buildPayrollQuery({ employeeId, period, statuses }: {
+    employeeId: any;
+    period: any;
+    statuses: any;
+}): {};
+export function buildAggregationPipeline(...stages: any[]): any[];
+export function matchStage(query: any): {
+    $match: any;
+};
+export function groupStage(groupBy: any, aggregations: any): {
+    $group: any;
+};
+export function sortStage(sortBy: any): {
+    $sort: any;
+};
+export function limitStage(limit: any): {
+    $limit: any;
+};
+export function projectStage(fields: any): {
+    $project: any;
+};
+export function lookupStage({ from, localField, foreignField, as }: {
+    from: any;
+    localField: any;
+    foreignField: any;
+    as: any;
+}): {
+    $lookup: {
+        from: any;
+        localField: any;
+        foreignField: any;
+        as: any;
+    };
+};
+export function unwindStage(path: any, options?: {}): {
+    $unwind: {
+        path: any;
+    };
+};
+import mongoose from 'mongoose';

package/dist/types/utils/validation.utils.d.ts

@@ -0,0 +1,33 @@
+export function isActive(employee: any): boolean;
+export function isOnLeave(employee: any): boolean;
+export function isSuspended(employee: any): boolean;
+export function isTerminated(employee: any): boolean;
+export function isEmployed(employee: any): boolean;
+export function canReceiveSalary(employee: any): boolean;
+export function canUpdateEmployment(employee: any): boolean;
+export function isInProbation(employee: any, now?: Date): boolean;
+export function hasCompletedProbation(employee: any, now?: Date): boolean;
+export function hasCompensation(employee: any): boolean;
+export function isEligibleForBonus(employee: any, requiredMonths?: number): boolean;
+export function isValidCompensation(compensation: any): any;
+export function isValidBankDetails(bankDetails: any): any;
+export function hasRequiredFields(obj: any, fields: any): any;
+export function createValidator(validationFns: any): (data: any) => {
+    isValid: boolean;
+    errors: {
+        field: string;
+        message: any;
+    }[];
+};
+export function required(fieldName: any): (value: any) => string | true;
+export function min(minValue: any, fieldName: any): (value: any) => string | true;
+export function max(maxValue: any, fieldName: any): (value: any) => string | true;
+export function inRange(minValue: any, maxValue: any, fieldName: any): (value: any) => string | true;
+export function oneOf(allowedValues: any, fieldName: any): (value: any) => string | true;
+export function compose(...validators: any[]): (value: any, data: any) => any;
+export function isPositive(fieldName: any): (value: any) => string | true;
+export function isValidStatus(value: any): boolean;
+export function isValidEmploymentType(value: any): boolean;
+export function minValue(minValue: any, fieldName: any): (value: any) => string | true;
+export function maxValue(maxValue: any, fieldName: any): (value: any) => string | true;
+export function isInRange(minValue: any, maxValue: any, fieldName: any): (value: any) => string | true;

package/package.json

@@ -1,21 +1,34 @@
 {
   "name": "@classytic/payroll",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Modern HRM and payroll management library for Node.js applications",
   "type": "module",
   "main": "./src/index.js",
-  "types": "./payroll.d.ts",
+  "types": "./dist/types/index.d.ts",
   "exports": {
-    ".": "./src/index.js",
-    "./init": "./src/init.js",
-    "./service": "./src/service.js",
-    "./adapters/*": "./src/adapters/*.js",
-    "./events/*": "./src/events/*.js",
-    "./workflows/*": "./src/workflows/*.js",
-    "./schemas/*": "./src/schemas/*.js"
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./init": {
+      "types": "./dist/types/init.d.ts",
+      "import": "./src/init.js"
+    },
+    "./service": {
+      "types": "./dist/types/service.d.ts",
+      "import": "./src/service.js"
+    },
+    "./schemas/*": {
+      "types": "./dist/types/schemas/*.d.ts",
+      "import": "./src/schemas/*.js"
+    }
   },
   "files": [
     "src/**/*.js",
+    "!src/**/*.test.js",
+    "!src/**/*.spec.js",
+    "!src/**/__tests__/**",
+    "dist/types/",
     "payroll.d.ts",
     "README.md",
     "LICENSE"
@@ -42,20 +55,26 @@
   },
   "homepage": "https://github.com/classytic/payroll#readme",
   "peerDependencies": {
-    "mongoose": "^8.0.0"
+    "mongoose": "^8.0.0 || ^9.0.0"
   },
   "devDependencies": {
-    "mongoose": "^8.8.1",
+    "mongoose": "^9.0.0",
     "mongoose-aggregate-paginate-v2": "^1.1.4",
-    "mongoose-paginate-v2": "^1.9.0"
+    "mongoose-paginate-v2": "^1.9.0",
+    "@types/node": "^22.8.7",
+    "typescript": "^5.6.3"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
+    "types": "tsc --project tsconfig.types.json",
+    "build": "npm run types",
+    "prepublishOnly": "npm run build",
     "example:basic": "node test/examples/basic-usage.js",
     "example:mongoose": "node test/examples/with-mongoose.js",
     "example:workflow": "node test/examples/full-workflow.js",
-    "test": "npm run example:basic && npm run example:mongoose && npm run example:workflow"
+    "test:v9": "node test/employee-plugin-v9.test.js",
+    "test": "npm run example:basic && npm run example:mongoose && npm run example:workflow && npm run test:v9"
   }
 }

package/src/factories/payroll.factory.js

@@ -1,6 +1,8 @@
 /**
  * Payroll Factory - Beautiful Salary Calculation & Record Creation
  * Clean, testable, immutable payroll object creation
+ *
+ * Compatible with Mongoose v8 and v9
  */
 
 import {
@@ -12,7 +14,66 @@ import {
 
 import { getPayPeriod } from '../utils/date.utils.js';
 
+/**
+ * @typedef {Object} AllowanceInput
+ * @property {string} type - Type of allowance
+ * @property {string} [name] - Display name for the allowance
+ * @property {number} value - Allowance value (amount or percentage)
+ * @property {boolean} [isPercentage=false] - Whether value is a percentage
+ */
+
+/**
+ * @typedef {Object} DeductionInput
+ * @property {string} type - Type of deduction
+ * @property {string} [name] - Display name for the deduction
+ * @property {number} value - Deduction value (amount or percentage)
+ * @property {boolean} [isPercentage=false] - Whether value is a percentage
+ */
+
+/**
+ * @typedef {Object} PeriodInput
+ * @property {number} [month] - Month (1-12)
+ * @property {number} [year] - Year
+ */
+
+/**
+ * @typedef {Object} PayrollMetadata
+ * @property {string} [currency='BDT'] - Currency code
+ * @property {string} [paymentMethod] - Payment method
+ * @property {string} [notes] - Additional notes
+ */
+
+/**
+ * @typedef {Object} PayrollRecord
+ * @property {string} employeeId - Employee identifier
+ * @property {string} organizationId - Organization identifier
+ * @property {Object} period - Pay period information
+ * @property {Object} breakdown - Salary breakdown
+ * @property {number} breakdown.baseAmount - Base salary amount
+ * @property {Array} breakdown.allowances - Calculated allowances
+ * @property {Array} breakdown.deductions - Calculated deductions
+ * @property {number} breakdown.grossSalary - Gross salary
+ * @property {number} breakdown.netSalary - Net salary after deductions
+ * @property {string} status - Payroll status ('pending', 'processed', 'paid')
+ * @property {Date|null} processedAt - When payroll was processed
+ * @property {Date|null} paidAt - When payment was made
+ * @property {PayrollMetadata} metadata - Additional metadata
+ */
+
 export class PayrollFactory {
+  /**
+   * Create a new payroll record
+   *
+   * @param {Object} params - Payroll parameters
+   * @param {string} params.employeeId - Employee ID
+   * @param {string} params.organizationId - Organization ID
+   * @param {number} params.baseAmount - Base salary amount
+   * @param {AllowanceInput[]} [params.allowances=[]] - Allowances array
+   * @param {DeductionInput[]} [params.deductions=[]] - Deductions array
+   * @param {PeriodInput} [params.period={}] - Pay period
+   * @param {PayrollMetadata} [params.metadata={}] - Additional metadata
+   * @returns {PayrollRecord} Payroll record object
+   */
   static create({
     employeeId,
     organizationId,
@@ -50,6 +111,14 @@ export class PayrollFactory {
     };
   }
 
+  /**
+   * Create a pay period object
+   *
+   * @param {PeriodInput} [params={}] - Period parameters
+   * @param {number} [params.month] - Month (defaults to current month)
+   * @param {number} [params.year] - Year (defaults to current year)
+   * @returns {Object} Pay period object with startDate, endDate, etc.
+   */
   static createPeriod({ month, year } = {}) {
     const now = new Date();
     return getPayPeriod(
@@ -58,6 +127,13 @@ export class PayrollFactory {
     );
   }
 
+  /**
+   * Calculate allowances from base amount and allowance inputs
+   *
+   * @param {number} baseAmount - Base salary amount
+   * @param {AllowanceInput[]} allowances - Array of allowances
+   * @returns {Array} Calculated allowances with amounts
+   */
   static calculateAllowances(baseAmount, allowances) {
     return allowances.map((allowance) => {
       const amount = allowance.isPercentage
@@ -74,6 +150,13 @@ export class PayrollFactory {
     });
   }
 
+  /**
+   * Calculate deductions from base amount and deduction inputs
+   *
+   * @param {number} baseAmount - Base salary amount
+   * @param {DeductionInput[]} deductions - Array of deductions
+   * @returns {Array} Calculated deductions with amounts
+   */
   static calculateDeductions(baseAmount, deductions) {
     return deductions.map((deduction) => {
       const amount = deduction.isPercentage
@@ -90,6 +173,16 @@ export class PayrollFactory {
     });
   }
 
+  /**
+   * Create a bonus object
+   *
+   * @param {Object} params - Bonus parameters
+   * @param {string} params.type - Bonus type
+   * @param {number} params.amount - Bonus amount
+   * @param {string} params.reason - Reason for bonus
+   * @param {string} params.approvedBy - User who approved the bonus
+   * @returns {Object} Bonus object
+   */
   static createBonus({ type, amount, reason, approvedBy }) {
     return {
       type,
@@ -100,6 +193,16 @@ export class PayrollFactory {
     };
   }
 
+  /**
+   * Create a deduction object
+   *
+   * @param {Object} params - Deduction parameters
+   * @param {string} params.type - Deduction type
+   * @param {number} params.amount - Deduction amount
+   * @param {string} params.reason - Reason for deduction
+   * @param {string} params.appliedBy - User who applied the deduction
+   * @returns {Object} Deduction object
+   */
   static createDeduction({ type, amount, reason, appliedBy }) {
     return {
       type,
@@ -110,6 +213,16 @@ export class PayrollFactory {
     };
   }
 
+  /**
+   * Mark a payroll record as paid (immutable - returns new object)
+   *
+   * @param {PayrollRecord} payroll - Payroll record to mark as paid
+   * @param {Object} [params={}] - Payment details
+   * @param {Date} [params.paidAt] - Payment date (defaults to now)
+   * @param {string} [params.transactionId] - Transaction ID
+   * @param {string} [params.paymentMethod] - Payment method
+   * @returns {PayrollRecord} New payroll record marked as paid
+   */
   static markAsPaid(payroll, { paidAt = new Date(), transactionId, paymentMethod } = {}) {
     return {
       ...payroll,
@@ -124,6 +237,14 @@ export class PayrollFactory {
     };
   }
 
+  /**
+   * Mark a payroll record as processed (immutable - returns new object)
+   *
+   * @param {PayrollRecord} payroll - Payroll record to mark as processed
+   * @param {Object} [params={}] - Processing details
+   * @param {Date} [params.processedAt] - Processing date (defaults to now)
+   * @returns {PayrollRecord} New payroll record marked as processed
+   */
   static markAsProcessed(payroll, { processedAt = new Date() } = {}) {
     return {
       ...payroll,
@@ -133,6 +254,18 @@ export class PayrollFactory {
   }
 }
 
+/**
+ * PayrollBuilder - Fluent builder pattern for creating payroll records
+ *
+ * @example
+ * const payroll = createPayroll()
+ *   .forEmployee('emp-123')
+ *   .inOrganization('org-456')
+ *   .withBaseAmount(50000)
+ *   .addAllowance('housing', 10000)
+ *   .addDeduction('tax', 15, true)
+ *   .build();
+ */
 export class PayrollBuilder {
   constructor() {
     this.data = {
@@ -203,12 +336,34 @@ export class PayrollBuilder {
   }
 }
 
+/**
+ * Create a new PayrollBuilder instance
+ *
+ * @returns {PayrollBuilder} New builder instance
+ */
 export const createPayroll = () => new PayrollBuilder();
 
 /**
- * Batch Payroll Factory - Process multiple employees
+ * BatchPayrollFactory - Process payroll for multiple employees at once
+ *
+ * @example
+ * const payrolls = BatchPayrollFactory.createBatch(employees, {
+ *   month: 1,
+ *   year: 2025,
+ *   organizationId: 'org-123'
+ * });
  */
 export class BatchPayrollFactory {
+  /**
+   * Create payroll records for multiple employees
+   *
+   * @param {Array} employees - Array of employee objects
+   * @param {Object} params - Batch parameters
+   * @param {number} params.month - Month for payroll
+   * @param {number} params.year - Year for payroll
+   * @param {string} params.organizationId - Organization ID
+   * @returns {PayrollRecord[]} Array of payroll records
+   */
   static createBatch(employees, { month, year, organizationId }) {
     return employees.map((employee) =>
       PayrollFactory.create({
@@ -222,6 +377,17 @@ export class BatchPayrollFactory {
     );
   }
 
+  /**
+   * Calculate total payroll amounts across multiple records
+   *
+   * @param {PayrollRecord[]} payrolls - Array of payroll records
+   * @returns {Object} Totals summary
+   * @returns {number} return.count - Total number of payrolls
+   * @returns {number} return.totalGross - Sum of gross salaries
+   * @returns {number} return.totalNet - Sum of net salaries
+   * @returns {number} return.totalAllowances - Sum of all allowances
+   * @returns {number} return.totalDeductions - Sum of all deductions
+   */
   static calculateTotalPayroll(payrolls) {
     return payrolls.reduce(
       (totals, payroll) => ({