@classytic/payroll 1.0.2 → 2.0.0

package/dist/payroll.js

@@ -0,0 +1,2103 @@
+import mongoose2, { Types } from 'mongoose';
+
+// src/payroll.ts
+
+// src/utils/logger.ts
+var createConsoleLogger = () => ({
+  info: (message, meta) => {
+    if (meta) {
+      console.log(`[Payroll] INFO: ${message}`, meta);
+    } else {
+      console.log(`[Payroll] INFO: ${message}`);
+    }
+  },
+  error: (message, meta) => {
+    if (meta) {
+      console.error(`[Payroll] ERROR: ${message}`, meta);
+    } else {
+      console.error(`[Payroll] ERROR: ${message}`);
+    }
+  },
+  warn: (message, meta) => {
+    if (meta) {
+      console.warn(`[Payroll] WARN: ${message}`, meta);
+    } else {
+      console.warn(`[Payroll] WARN: ${message}`);
+    }
+  },
+  debug: (message, meta) => {
+    if (process.env.NODE_ENV !== "production") {
+      if (meta) {
+        console.log(`[Payroll] DEBUG: ${message}`, meta);
+      } else {
+        console.log(`[Payroll] DEBUG: ${message}`);
+      }
+    }
+  }
+});
+var currentLogger = createConsoleLogger();
+function getLogger() {
+  return currentLogger;
+}
+function setLogger(logger) {
+  currentLogger = logger;
+}
+
+// src/config.ts
+var HRM_CONFIG = {
+  dataRetention: {
+    payrollRecordsTTL: 63072e3,
+    // 2 years in seconds
+    exportWarningDays: 30,
+    archiveBeforeDeletion: true
+  },
+  payroll: {
+    defaultCurrency: "BDT",
+    allowProRating: true,
+    attendanceIntegration: true,
+    autoDeductions: true,
+    overtimeEnabled: false,
+    overtimeMultiplier: 1.5
+  },
+  salary: {
+    minimumWage: 0,
+    maximumAllowances: 10,
+    maximumDeductions: 10,
+    defaultFrequency: "monthly"
+  },
+  employment: {
+    defaultProbationMonths: 3,
+    maxProbationMonths: 6,
+    allowReHiring: true,
+    trackEmploymentHistory: true
+  },
+  validation: {
+    requireBankDetails: false,
+    requireEmployeeId: true,
+    uniqueEmployeeIdPerOrg: true,
+    allowMultiTenantEmployees: true
+  }
+};
+var TAX_BRACKETS = {
+  BDT: [
+    { min: 0, max: 3e5, rate: 0 },
+    { min: 3e5, max: 4e5, rate: 0.05 },
+    { min: 4e5, max: 5e5, rate: 0.1 },
+    { min: 5e5, max: 6e5, rate: 0.15 },
+    { min: 6e5, max: 3e6, rate: 0.2 },
+    { min: 3e6, max: Infinity, rate: 0.25 }
+  ],
+  USD: [
+    { min: 0, max: 1e4, rate: 0.1 },
+    { min: 1e4, max: 4e4, rate: 0.12 },
+    { min: 4e4, max: 85e3, rate: 0.22 },
+    { min: 85e3, max: 165e3, rate: 0.24 },
+    { min: 165e3, max: 215e3, rate: 0.32 },
+    { min: 215e3, max: 54e4, rate: 0.35 },
+    { min: 54e4, max: Infinity, rate: 0.37 }
+  ]
+};
+var ORG_ROLES = {
+  OWNER: {
+    key: "owner",
+    label: "Owner",
+    description: "Full organization access (set by Organization model)"
+  },
+  MANAGER: {
+    key: "manager",
+    label: "Manager",
+    description: "Management and administrative features"
+  },
+  TRAINER: {
+    key: "trainer",
+    label: "Trainer",
+    description: "Training and coaching features"
+  },
+  STAFF: {
+    key: "staff",
+    label: "Staff",
+    description: "General staff access to basic features"
+  },
+  INTERN: {
+    key: "intern",
+    label: "Intern",
+    description: "Limited access for interns"
+  },
+  CONSULTANT: {
+    key: "consultant",
+    label: "Consultant",
+    description: "Project-based consultant access"
+  }
+};
+Object.values(ORG_ROLES).map((role) => role.key);
+function mergeConfig(customConfig) {
+  if (!customConfig) return HRM_CONFIG;
+  return {
+    dataRetention: { ...HRM_CONFIG.dataRetention, ...customConfig.dataRetention },
+    payroll: { ...HRM_CONFIG.payroll, ...customConfig.payroll },
+    salary: { ...HRM_CONFIG.salary, ...customConfig.salary },
+    employment: { ...HRM_CONFIG.employment, ...customConfig.employment },
+    validation: { ...HRM_CONFIG.validation, ...customConfig.validation }
+  };
+}
+
+// src/core/container.ts
+var Container = class _Container {
+  static instance = null;
+  _models = null;
+  _config = HRM_CONFIG;
+  _singleTenant = null;
+  _logger;
+  _initialized = false;
+  constructor() {
+    this._logger = getLogger();
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!_Container.instance) {
+      _Container.instance = new _Container();
+    }
+    return _Container.instance;
+  }
+  /**
+   * Reset instance (for testing)
+   */
+  static resetInstance() {
+    _Container.instance = null;
+  }
+  /**
+   * Initialize container with configuration
+   */
+  initialize(config) {
+    if (this._initialized) {
+      this._logger.warn("Container already initialized, re-initializing");
+    }
+    this._models = config.models;
+    this._config = mergeConfig(config.config);
+    this._singleTenant = config.singleTenant ?? null;
+    if (config.logger) {
+      this._logger = config.logger;
+    }
+    this._initialized = true;
+    this._logger.info("Container initialized", {
+      hasEmployeeModel: !!this._models.EmployeeModel,
+      hasPayrollRecordModel: !!this._models.PayrollRecordModel,
+      hasTransactionModel: !!this._models.TransactionModel,
+      hasAttendanceModel: !!this._models.AttendanceModel,
+      isSingleTenant: !!this._singleTenant
+    });
+  }
+  /**
+   * Check if container is initialized
+   */
+  isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Ensure container is initialized
+   */
+  ensureInitialized() {
+    if (!this._initialized || !this._models) {
+      throw new Error(
+        "Payroll not initialized. Call Payroll.initialize() first."
+      );
+    }
+  }
+  /**
+   * Get models container
+   */
+  getModels() {
+    this.ensureInitialized();
+    return this._models;
+  }
+  /**
+   * Get Employee model
+   */
+  getEmployeeModel() {
+    this.ensureInitialized();
+    return this._models.EmployeeModel;
+  }
+  /**
+   * Get PayrollRecord model
+   */
+  getPayrollRecordModel() {
+    this.ensureInitialized();
+    return this._models.PayrollRecordModel;
+  }
+  /**
+   * Get Transaction model
+   */
+  getTransactionModel() {
+    this.ensureInitialized();
+    return this._models.TransactionModel;
+  }
+  /**
+   * Get Attendance model (optional)
+   */
+  getAttendanceModel() {
+    this.ensureInitialized();
+    return this._models.AttendanceModel ?? null;
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return this._config;
+  }
+  /**
+   * Get specific config section
+   */
+  getConfigSection(section) {
+    return this._config[section];
+  }
+  /**
+   * Check if single-tenant mode
+   */
+  isSingleTenant() {
+    return !!this._singleTenant;
+  }
+  /**
+   * Get single-tenant config
+   */
+  getSingleTenantConfig() {
+    return this._singleTenant;
+  }
+  /**
+   * Get organization ID (for single-tenant mode)
+   */
+  getOrganizationId() {
+    if (!this._singleTenant || !this._singleTenant.organizationId) return null;
+    return typeof this._singleTenant.organizationId === "string" ? this._singleTenant.organizationId : this._singleTenant.organizationId.toString();
+  }
+  /**
+   * Get logger
+   */
+  getLogger() {
+    return this._logger;
+  }
+  /**
+   * Set logger
+   */
+  setLogger(logger) {
+    this._logger = logger;
+  }
+  /**
+   * Has attendance integration
+   */
+  hasAttendanceIntegration() {
+    return !!this._models?.AttendanceModel && this._config.payroll.attendanceIntegration;
+  }
+  /**
+   * Create operation context with defaults
+   */
+  createOperationContext(overrides) {
+    const context = {};
+    if (this._singleTenant?.autoInject && !overrides?.organizationId) {
+      context.organizationId = this.getOrganizationId();
+    }
+    return { ...context, ...overrides };
+  }
+};
+function initializeContainer(config) {
+  Container.getInstance().initialize(config);
+}
+
+// src/core/events.ts
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Register a one-time event handler
+   */
+  once(event, handler) {
+    const wrappedHandler = async (payload) => {
+      this.off(event, wrappedHandler);
+      await handler(payload);
+    };
+    return this.on(event, wrappedHandler);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  async emit(event, payload) {
+    const eventHandlers = this.handlers.get(event);
+    if (!eventHandlers || eventHandlers.size === 0) {
+      return;
+    }
+    const handlers = Array.from(eventHandlers);
+    await Promise.all(
+      handlers.map(async (handler) => {
+        try {
+          await handler(payload);
+        } catch (error) {
+          console.error(`Event handler error for ${event}:`, error);
+        }
+      })
+    );
+  }
+  /**
+   * Emit event synchronously (fire-and-forget)
+   */
+  emitSync(event, payload) {
+    void this.emit(event, payload);
+  }
+  /**
+   * Remove all handlers for an event
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+  /**
+   * Get listener count for an event
+   */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  /**
+   * Get all registered events
+   */
+  eventNames() {
+    return Array.from(this.handlers.keys());
+  }
+};
+function createEventBus() {
+  return new EventBus();
+}
+
+// src/core/plugin.ts
+var PluginManager = class {
+  constructor(context) {
+    this.context = context;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  hooks = /* @__PURE__ */ new Map();
+  /**
+   * Register a plugin
+   */
+  async register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    if (plugin.hooks) {
+      for (const [hookName, handler] of Object.entries(plugin.hooks)) {
+        if (handler) {
+          this.addHook(hookName, handler);
+        }
+      }
+    }
+    if (plugin.init) {
+      await plugin.init(this.context);
+    }
+    this.plugins.set(plugin.name, plugin);
+    this.context.logger.debug(`Plugin "${plugin.name}" registered`);
+  }
+  /**
+   * Unregister a plugin
+   */
+  async unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      return;
+    }
+    if (plugin.destroy) {
+      await plugin.destroy();
+    }
+    this.plugins.delete(name);
+    this.context.logger.debug(`Plugin "${name}" unregistered`);
+  }
+  /**
+   * Add a hook handler
+   */
+  addHook(hookName, handler) {
+    if (!this.hooks.has(hookName)) {
+      this.hooks.set(hookName, []);
+    }
+    this.hooks.get(hookName).push(handler);
+  }
+  /**
+   * Execute hooks for a given event
+   */
+  async executeHooks(hookName, ...args) {
+    const handlers = this.hooks.get(hookName);
+    if (!handlers || handlers.length === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      try {
+        await handler(...args);
+      } catch (error) {
+        this.context.logger.error(`Hook "${hookName}" error:`, { error });
+        const errorHandlers = this.hooks.get("onError");
+        if (errorHandlers) {
+          for (const errorHandler of errorHandlers) {
+            try {
+              await errorHandler(error, hookName);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get registered plugin names
+   */
+  getPluginNames() {
+    return Array.from(this.plugins.keys());
+  }
+  /**
+   * Check if plugin is registered
+   */
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+};
+
+// src/utils/date.ts
+function addMonths(date, months) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + months);
+  return result;
+}
+function startOfMonth(date) {
+  const result = new Date(date);
+  result.setDate(1);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfMonth(date) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + 1, 0);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+function diffInDays(start, end) {
+  return Math.ceil(
+    (new Date(end).getTime() - new Date(start).getTime()) / (1e3 * 60 * 60 * 24)
+  );
+}
+function isWeekday(date) {
+  const day = new Date(date).getDay();
+  return day >= 1 && day <= 5;
+}
+function getPayPeriod(month, year) {
+  const startDate = new Date(year, month - 1, 1);
+  return {
+    month,
+    year,
+    startDate: startOfMonth(startDate),
+    endDate: endOfMonth(startDate)
+  };
+}
+function getWorkingDaysInMonth(year, month) {
+  const start = new Date(year, month - 1, 1);
+  const end = endOfMonth(start);
+  let count = 0;
+  const current = new Date(start);
+  while (current <= end) {
+    if (isWeekday(current)) {
+      count++;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  return count;
+}
+function calculateProbationEnd(hireDate, probationMonths) {
+  if (!probationMonths || probationMonths <= 0) return null;
+  return addMonths(hireDate, probationMonths);
+}
+
+// src/factories/employee.factory.ts
+var EmployeeFactory = class {
+  /**
+   * Create employee data object
+   */
+  static create(params) {
+    const { userId, organizationId, employment, compensation, bankDetails } = params;
+    const hireDate = employment.hireDate || /* @__PURE__ */ new Date();
+    return {
+      userId,
+      organizationId,
+      employeeId: employment.employeeId || `EMP-${Date.now()}-${Math.random().toString(36).substr(2, 6).toUpperCase()}`,
+      employmentType: employment.type || "full_time",
+      status: "active",
+      department: employment.department,
+      position: employment.position,
+      hireDate,
+      probationEndDate: calculateProbationEnd(
+        hireDate,
+        employment.probationMonths ?? HRM_CONFIG.employment.defaultProbationMonths
+      ),
+      compensation: this.createCompensation(compensation),
+      workSchedule: employment.workSchedule || this.defaultWorkSchedule(),
+      bankDetails: bankDetails || {},
+      payrollStats: {
+        totalPaid: 0,
+        paymentsThisYear: 0,
+        averageMonthly: 0
+      }
+    };
+  }
+  /**
+   * Create compensation object
+   */
+  static createCompensation(params) {
+    return {
+      baseAmount: params.baseAmount,
+      frequency: params.frequency || "monthly",
+      currency: params.currency || HRM_CONFIG.payroll.defaultCurrency,
+      allowances: (params.allowances || []).map((a) => ({
+        type: a.type || "other",
+        name: a.name || a.type || "other",
+        amount: a.amount || 0,
+        taxable: a.taxable,
+        recurring: a.recurring,
+        effectiveFrom: a.effectiveFrom,
+        effectiveTo: a.effectiveTo
+      })),
+      deductions: (params.deductions || []).map((d) => ({
+        type: d.type || "other",
+        name: d.name || d.type || "other",
+        amount: d.amount || 0,
+        auto: d.auto,
+        recurring: d.recurring,
+        description: d.description,
+        effectiveFrom: d.effectiveFrom,
+        effectiveTo: d.effectiveTo
+      })),
+      grossSalary: 0,
+      netSalary: 0,
+      effectiveFrom: /* @__PURE__ */ new Date(),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create allowance object
+   */
+  static createAllowance(params) {
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount: params.amount,
+      isPercentage: params.isPercentage ?? false,
+      taxable: params.taxable ?? true,
+      recurring: params.recurring ?? true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create deduction object
+   */
+  static createDeduction(params) {
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount: params.amount,
+      isPercentage: params.isPercentage ?? false,
+      auto: params.auto ?? false,
+      recurring: params.recurring ?? true,
+      description: params.description,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Default work schedule
+   */
+  static defaultWorkSchedule() {
+    return {
+      hoursPerWeek: 40,
+      hoursPerDay: 8,
+      workingDays: [1, 2, 3, 4, 5],
+      // Mon-Fri
+      shiftStart: "09:00",
+      shiftEnd: "17:00"
+    };
+  }
+  /**
+   * Create termination data
+   */
+  static createTermination(params) {
+    return {
+      terminatedAt: params.date || /* @__PURE__ */ new Date(),
+      terminationReason: params.reason,
+      terminationNotes: params.notes,
+      terminatedBy: {
+        userId: params.context?.userId,
+        name: params.context?.userName,
+        role: params.context?.userRole
+      }
+    };
+  }
+};
+var HRM_TRANSACTION_CATEGORIES = {
+  SALARY: "salary",
+  BONUS: "bonus",
+  COMMISSION: "commission",
+  OVERTIME: "overtime",
+  SEVERANCE: "severance"
+};
+function toObjectId(id) {
+  if (id instanceof Types.ObjectId) return id;
+  return new Types.ObjectId(id);
+}
+var QueryBuilder = class {
+  query;
+  constructor(initialQuery = {}) {
+    this.query = { ...initialQuery };
+  }
+  /**
+   * Add where condition
+   */
+  where(field, value) {
+    this.query[field] = value;
+    return this;
+  }
+  /**
+   * Add $in condition
+   */
+  whereIn(field, values) {
+    this.query[field] = { $in: values };
+    return this;
+  }
+  /**
+   * Add $nin condition
+   */
+  whereNotIn(field, values) {
+    this.query[field] = { $nin: values };
+    return this;
+  }
+  /**
+   * Add $gte condition
+   */
+  whereGte(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $gte: value };
+    return this;
+  }
+  /**
+   * Add $lte condition
+   */
+  whereLte(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $lte: value };
+    return this;
+  }
+  /**
+   * Add $gt condition
+   */
+  whereGt(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $gt: value };
+    return this;
+  }
+  /**
+   * Add $lt condition
+   */
+  whereLt(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $lt: value };
+    return this;
+  }
+  /**
+   * Add between condition
+   */
+  whereBetween(field, start, end) {
+    this.query[field] = { $gte: start, $lte: end };
+    return this;
+  }
+  /**
+   * Add $exists condition
+   */
+  whereExists(field) {
+    this.query[field] = { $exists: true };
+    return this;
+  }
+  /**
+   * Add $exists: false condition
+   */
+  whereNotExists(field) {
+    this.query[field] = { $exists: false };
+    return this;
+  }
+  /**
+   * Add $ne condition
+   */
+  whereNot(field, value) {
+    this.query[field] = { $ne: value };
+    return this;
+  }
+  /**
+   * Add regex condition
+   */
+  whereRegex(field, pattern, flags = "i") {
+    this.query[field] = { $regex: pattern, $options: flags };
+    return this;
+  }
+  /**
+   * Merge another query
+   */
+  merge(otherQuery) {
+    this.query = { ...this.query, ...otherQuery };
+    return this;
+  }
+  /**
+   * Build and return the query
+   */
+  build() {
+    return { ...this.query };
+  }
+};
+var EmployeeQueryBuilder = class extends QueryBuilder {
+  /**
+   * Filter by organization
+   */
+  forOrganization(organizationId) {
+    return this.where("organizationId", toObjectId(organizationId));
+  }
+  /**
+   * Filter by user
+   */
+  forUser(userId) {
+    return this.where("userId", toObjectId(userId));
+  }
+  /**
+   * Filter by status(es)
+   */
+  withStatus(...statuses) {
+    if (statuses.length === 1) {
+      return this.where("status", statuses[0]);
+    }
+    return this.whereIn("status", statuses);
+  }
+  /**
+   * Filter active employees
+   */
+  active() {
+    return this.withStatus("active");
+  }
+  /**
+   * Filter employed employees (not terminated)
+   */
+  employed() {
+    return this.whereIn("status", ["active", "on_leave", "suspended"]);
+  }
+  /**
+   * Filter terminated employees
+   */
+  terminated() {
+    return this.withStatus("terminated");
+  }
+  /**
+   * Filter by department
+   */
+  inDepartment(department) {
+    return this.where("department", department);
+  }
+  /**
+   * Filter by position
+   */
+  inPosition(position) {
+    return this.where("position", position);
+  }
+  /**
+   * Filter by employment type
+   */
+  withEmploymentType(type) {
+    return this.where("employmentType", type);
+  }
+  /**
+   * Filter by hire date (after)
+   */
+  hiredAfter(date) {
+    return this.whereGte("hireDate", date);
+  }
+  /**
+   * Filter by hire date (before)
+   */
+  hiredBefore(date) {
+    return this.whereLte("hireDate", date);
+  }
+  /**
+   * Filter by minimum salary
+   */
+  withMinSalary(amount) {
+    return this.whereGte("compensation.netSalary", amount);
+  }
+  /**
+   * Filter by maximum salary
+   */
+  withMaxSalary(amount) {
+    return this.whereLte("compensation.netSalary", amount);
+  }
+  /**
+   * Filter by salary range
+   */
+  withSalaryRange(min, max) {
+    return this.whereBetween("compensation.netSalary", min, max);
+  }
+};
+var PayrollQueryBuilder = class extends QueryBuilder {
+  /**
+   * Filter by organization
+   */
+  forOrganization(organizationId) {
+    return this.where("organizationId", toObjectId(organizationId));
+  }
+  /**
+   * Filter by employee
+   */
+  forEmployee(employeeId) {
+    return this.where("employeeId", toObjectId(employeeId));
+  }
+  /**
+   * Filter by period
+   */
+  forPeriod(month, year) {
+    if (month !== void 0) {
+      this.where("period.month", month);
+    }
+    if (year !== void 0) {
+      this.where("period.year", year);
+    }
+    return this;
+  }
+  /**
+   * Filter by status(es)
+   */
+  withStatus(...statuses) {
+    if (statuses.length === 1) {
+      return this.where("status", statuses[0]);
+    }
+    return this.whereIn("status", statuses);
+  }
+  /**
+   * Filter paid records
+   */
+  paid() {
+    return this.withStatus("paid");
+  }
+  /**
+   * Filter pending records
+   */
+  pending() {
+    return this.whereIn("status", ["pending", "processing"]);
+  }
+  /**
+   * Filter by date range
+   */
+  inDateRange(start, end) {
+    return this.whereBetween("period.payDate", start, end);
+  }
+  /**
+   * Filter exported records
+   */
+  exported() {
+    return this.where("exported", true);
+  }
+  /**
+   * Filter not exported records
+   */
+  notExported() {
+    return this.where("exported", false);
+  }
+};
+function employee() {
+  return new EmployeeQueryBuilder();
+}
+function payroll() {
+  return new PayrollQueryBuilder();
+}
+
+// src/utils/calculation.ts
+function sumBy(items, getter) {
+  return items.reduce((total, item) => total + getter(item), 0);
+}
+function sumAllowances(allowances) {
+  return sumBy(allowances, (a) => a.amount);
+}
+function sumDeductions(deductions) {
+  return sumBy(deductions, (d) => d.amount);
+}
+function calculateGross(baseAmount, allowances) {
+  return baseAmount + sumAllowances(allowances);
+}
+function calculateNet(gross, deductions) {
+  return Math.max(0, gross - sumDeductions(deductions));
+}
+function applyTaxBrackets(amount, brackets) {
+  let tax = 0;
+  for (const bracket of brackets) {
+    if (amount > bracket.min) {
+      const taxableAmount = Math.min(amount, bracket.max) - bracket.min;
+      tax += taxableAmount * bracket.rate;
+    }
+  }
+  return Math.round(tax);
+}
+
+// src/errors/index.ts
+var PayrollError = class _PayrollError extends Error {
+  code;
+  status;
+  context;
+  timestamp;
+  constructor(message, code = "PAYROLL_ERROR", status = 500, context) {
+    super(message);
+    this.name = "PayrollError";
+    this.code = code;
+    this.status = status;
+    this.context = context;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _PayrollError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      status: this.status,
+      context: this.context,
+      timestamp: this.timestamp.toISOString()
+    };
+  }
+};
+var NotInitializedError = class extends PayrollError {
+  constructor(message = "Payroll not initialized. Call Payroll.initialize() first.") {
+    super(message, "NOT_INITIALIZED", 500);
+    this.name = "NotInitializedError";
+  }
+};
+var EmployeeNotFoundError = class extends PayrollError {
+  constructor(employeeId, context) {
+    super(
+      employeeId ? `Employee not found: ${employeeId}` : "Employee not found",
+      "EMPLOYEE_NOT_FOUND",
+      404,
+      context
+    );
+    this.name = "EmployeeNotFoundError";
+  }
+};
+var DuplicatePayrollError = class extends PayrollError {
+  constructor(employeeId, month, year, context) {
+    super(
+      `Payroll already processed for employee ${employeeId} in ${month}/${year}`,
+      "DUPLICATE_PAYROLL",
+      409,
+      { employeeId, month, year, ...context }
+    );
+    this.name = "DuplicatePayrollError";
+  }
+};
+var ValidationError = class extends PayrollError {
+  errors;
+  constructor(errors, context) {
+    const errorArray = Array.isArray(errors) ? errors : [errors];
+    super(errorArray.join(", "), "VALIDATION_ERROR", 400, context);
+    this.name = "ValidationError";
+    this.errors = errorArray;
+  }
+};
+var EmployeeTerminatedError = class extends PayrollError {
+  constructor(employeeId, context) {
+    super(
+      employeeId ? `Cannot perform operation on terminated employee: ${employeeId}` : "Cannot perform operation on terminated employee",
+      "EMPLOYEE_TERMINATED",
+      400,
+      context
+    );
+    this.name = "EmployeeTerminatedError";
+  }
+};
+var NotEligibleError = class extends PayrollError {
+  constructor(message, context) {
+    super(message, "NOT_ELIGIBLE", 400, context);
+    this.name = "NotEligibleError";
+  }
+};
+
+// src/payroll.ts
+function hasPluginMethod(obj, method) {
+  return typeof obj === "object" && obj !== null && typeof obj[method] === "function";
+}
+function assertPluginMethod(obj, method, context) {
+  if (!hasPluginMethod(obj, method)) {
+    throw new Error(
+      `Method '${method}' not found on employee. Did you forget to apply employeePlugin to your Employee schema? Context: ${context}`
+    );
+  }
+}
+function isEffectiveForPeriod(item, periodStart, periodEnd) {
+  const effectiveFrom = item.effectiveFrom ? new Date(item.effectiveFrom) : /* @__PURE__ */ new Date(0);
+  const effectiveTo = item.effectiveTo ? new Date(item.effectiveTo) : /* @__PURE__ */ new Date("2099-12-31");
+  return effectiveFrom <= periodEnd && effectiveTo >= periodStart;
+}
+var Payroll = class _Payroll {
+  _container;
+  _events;
+  _plugins = null;
+  _initialized = false;
+  constructor() {
+    this._container = Container.getInstance();
+    this._events = createEventBus();
+  }
+  // ========================================
+  // Initialization
+  // ========================================
+  /**
+   * Initialize Payroll with models and configuration
+   */
+  initialize(config) {
+    const { EmployeeModel, PayrollRecordModel, TransactionModel, AttendanceModel, singleTenant, logger: customLogger, config: customConfig } = config;
+    if (!EmployeeModel || !PayrollRecordModel || !TransactionModel) {
+      throw new Error("EmployeeModel, PayrollRecordModel, and TransactionModel are required");
+    }
+    if (customLogger) {
+      setLogger(customLogger);
+    }
+    initializeContainer({
+      models: {
+        EmployeeModel,
+        PayrollRecordModel,
+        TransactionModel,
+        AttendanceModel: AttendanceModel ?? null
+      },
+      config: customConfig,
+      singleTenant: singleTenant ?? null,
+      logger: customLogger
+    });
+    const pluginContext = {
+      payroll: this,
+      events: this._events,
+      logger: getLogger(),
+      getConfig: (key) => {
+        const config2 = this._container.getConfig();
+        return config2[key];
+      },
+      addHook: (event, handler) => this._events.on(event, handler)
+    };
+    this._plugins = new PluginManager(pluginContext);
+    this._initialized = true;
+    getLogger().info("Payroll initialized", {
+      hasAttendanceIntegration: !!AttendanceModel,
+      isSingleTenant: !!singleTenant
+    });
+    return this;
+  }
+  /**
+   * Check if initialized
+   */
+  isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Ensure initialized
+   */
+  ensureInitialized() {
+    if (!this._initialized) {
+      throw new NotInitializedError();
+    }
+  }
+  /**
+   * Get models
+   */
+  get models() {
+    this.ensureInitialized();
+    return this._container.getModels();
+  }
+  /**
+   * Get config
+   */
+  get config() {
+    return this._container.getConfig();
+  }
+  // ========================================
+  // Plugin System
+  // ========================================
+  /**
+   * Register a plugin
+   */
+  async use(plugin) {
+    this.ensureInitialized();
+    await this._plugins.register(plugin);
+    return this;
+  }
+  /**
+   * Subscribe to events
+   */
+  on(event, handler) {
+    return this._events.on(event, handler);
+  }
+  // ========================================
+  // Employment Lifecycle
+  // ========================================
+  /**
+   * Hire a new employee
+   */
+  async hire(params) {
+    this.ensureInitialized();
+    const { userId, employment, compensation, bankDetails, context } = params;
+    const session = context?.session;
+    const organizationId = params.organizationId ?? this._container.getOrganizationId();
+    if (!organizationId) {
+      throw new Error("organizationId is required (or configure single-tenant mode)");
+    }
+    const existingQuery = employee().forUser(userId).forOrganization(organizationId).employed().build();
+    let existing = this.models.EmployeeModel.findOne(existingQuery);
+    if (session) existing = existing.session(session);
+    if (await existing) {
+      throw new Error("User is already an active employee in this organization");
+    }
+    const employeeData = EmployeeFactory.create({
+      userId,
+      organizationId,
+      employment,
+      compensation: {
+        ...compensation,
+        currency: compensation.currency || this.config.payroll.defaultCurrency
+      },
+      bankDetails
+    });
+    const [employee2] = await this.models.EmployeeModel.create([employeeData], { session });
+    this._events.emitSync("employee:hired", {
+      employee: {
+        id: employee2._id,
+        employeeId: employee2.employeeId,
+        position: employee2.position,
+        department: employee2.department
+      },
+      organizationId: employee2.organizationId,
+      context
+    });
+    getLogger().info("Employee hired", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      position: employment.position
+    });
+    return employee2;
+  }
+  /**
+   * Update employment details
+   * NOTE: Status changes to 'terminated' must use terminate() method
+   */
+  async updateEmployment(params) {
+    this.ensureInitialized();
+    const { employeeId, updates, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    if (employee2.status === "terminated") {
+      throw new EmployeeTerminatedError(employee2.employeeId);
+    }
+    if (updates.status === "terminated") {
+      throw new ValidationError(
+        "Cannot set status to terminated directly. Use the terminate() method instead to ensure proper history tracking.",
+        { field: "status" }
+      );
+    }
+    const allowedUpdates = ["department", "position", "employmentType", "status", "workSchedule"];
+    for (const [key, value] of Object.entries(updates)) {
+      if (allowedUpdates.includes(key)) {
+        employee2[key] = value;
+      }
+    }
+    await employee2.save({ session });
+    getLogger().info("Employee updated", {
+      employeeId: employee2.employeeId,
+      updates: Object.keys(updates)
+    });
+    return employee2;
+  }
+  /**
+   * Terminate employee
+   */
+  async terminate(params) {
+    this.ensureInitialized();
+    const { employeeId, terminationDate = /* @__PURE__ */ new Date(), reason = "resignation", notes, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    assertPluginMethod(employee2, "terminate", "terminate()");
+    employee2.terminate(reason, terminationDate);
+    if (notes) {
+      employee2.notes = (employee2.notes || "") + `
+Termination: ${notes}`;
+    }
+    await employee2.save({ session });
+    this._events.emitSync("employee:terminated", {
+      employee: {
+        id: employee2._id,
+        employeeId: employee2.employeeId
+      },
+      terminationDate,
+      reason,
+      organizationId: employee2.organizationId,
+      context
+    });
+    getLogger().info("Employee terminated", {
+      employeeId: employee2.employeeId,
+      reason
+    });
+    return employee2;
+  }
+  /**
+   * Re-hire terminated employee
+   */
+  async reHire(params) {
+    this.ensureInitialized();
+    const { employeeId, hireDate = /* @__PURE__ */ new Date(), position, department, compensation, context } = params;
+    const session = context?.session;
+    if (!this.config.employment.allowReHiring) {
+      throw new Error("Re-hiring is not enabled");
+    }
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    assertPluginMethod(employee2, "reHire", "reHire()");
+    employee2.reHire(hireDate, position, department);
+    if (compensation) {
+      employee2.compensation = { ...employee2.compensation, ...compensation };
+    }
+    await employee2.save({ session });
+    this._events.emitSync("employee:rehired", {
+      employee: {
+        id: employee2._id,
+        employeeId: employee2.employeeId,
+        position: employee2.position
+      },
+      organizationId: employee2.organizationId,
+      context
+    });
+    getLogger().info("Employee re-hired", {
+      employeeId: employee2.employeeId
+    });
+    return employee2;
+  }
+  /**
+   * Get employee by ID
+   */
+  async getEmployee(params) {
+    this.ensureInitialized();
+    const { employeeId, populateUser = true, session } = params;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    if (populateUser) query = query.populate("userId", "name email phone");
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    return employee2;
+  }
+  /**
+   * List employees
+   */
+  async listEmployees(params) {
+    this.ensureInitialized();
+    const { organizationId, filters = {}, pagination = {} } = params;
+    let queryBuilder = employee().forOrganization(organizationId);
+    if (filters.status) queryBuilder = queryBuilder.withStatus(filters.status);
+    if (filters.department) queryBuilder = queryBuilder.inDepartment(filters.department);
+    if (filters.employmentType) queryBuilder = queryBuilder.withEmploymentType(filters.employmentType);
+    if (filters.minSalary) queryBuilder = queryBuilder.withMinSalary(filters.minSalary);
+    if (filters.maxSalary) queryBuilder = queryBuilder.withMaxSalary(filters.maxSalary);
+    const query = queryBuilder.build();
+    const page = pagination.page || 1;
+    const limit = pagination.limit || 20;
+    const sort = pagination.sort || { createdAt: -1 };
+    const [docs, totalDocs] = await Promise.all([
+      this.models.EmployeeModel.find(query).populate("userId", "name email phone").sort(sort).skip((page - 1) * limit).limit(limit),
+      this.models.EmployeeModel.countDocuments(query)
+    ]);
+    return { docs, totalDocs, page, limit };
+  }
+  // ========================================
+  // Compensation Management
+  // ========================================
+  /**
+   * Update employee salary
+   */
+  async updateSalary(params) {
+    this.ensureInitialized();
+    const { employeeId, compensation, effectiveFrom = /* @__PURE__ */ new Date(), context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    if (employee2.status === "terminated") {
+      throw new EmployeeTerminatedError(employee2.employeeId);
+    }
+    const oldSalary = employee2.compensation.netSalary;
+    if (compensation.baseAmount !== void 0) {
+      employee2.compensation.baseAmount = compensation.baseAmount;
+    }
+    if (compensation.frequency) {
+      employee2.compensation.frequency = compensation.frequency;
+    }
+    if (compensation.currency) {
+      employee2.compensation.currency = compensation.currency;
+    }
+    employee2.compensation.effectiveFrom = effectiveFrom;
+    if (hasPluginMethod(employee2, "updateSalaryCalculations")) {
+      employee2.updateSalaryCalculations();
+    }
+    await employee2.save({ session });
+    this._events.emitSync("salary:updated", {
+      employee: { id: employee2._id, employeeId: employee2.employeeId },
+      previousSalary: oldSalary || 0,
+      newSalary: employee2.compensation.netSalary || 0,
+      effectiveFrom,
+      organizationId: employee2.organizationId,
+      context
+    });
+    getLogger().info("Salary updated", {
+      employeeId: employee2.employeeId,
+      oldSalary,
+      newSalary: employee2.compensation.netSalary
+    });
+    return employee2;
+  }
+  /**
+   * Add allowance to employee
+   */
+  async addAllowance(params) {
+    this.ensureInitialized();
+    const { employeeId, type, amount, taxable = true, recurring = true, effectiveFrom = /* @__PURE__ */ new Date(), effectiveTo, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    if (employee2.status === "terminated") {
+      throw new EmployeeTerminatedError(employee2.employeeId);
+    }
+    if (!employee2.compensation.allowances) {
+      employee2.compensation.allowances = [];
+    }
+    employee2.compensation.allowances.push({
+      type,
+      name: type,
+      amount,
+      taxable,
+      recurring,
+      effectiveFrom,
+      effectiveTo
+    });
+    if (hasPluginMethod(employee2, "updateSalaryCalculations")) {
+      employee2.updateSalaryCalculations();
+    }
+    await employee2.save({ session });
+    getLogger().info("Allowance added", {
+      employeeId: employee2.employeeId,
+      type,
+      amount
+    });
+    return employee2;
+  }
+  /**
+   * Remove allowance from employee
+   */
+  async removeAllowance(params) {
+    this.ensureInitialized();
+    const { employeeId, type, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    const before = employee2.compensation.allowances?.length || 0;
+    if (hasPluginMethod(employee2, "removeAllowance")) {
+      employee2.removeAllowance(type);
+    } else {
+      if (employee2.compensation.allowances) {
+        employee2.compensation.allowances = employee2.compensation.allowances.filter(
+          (a) => a.type !== type
+        );
+      }
+    }
+    const after = employee2.compensation.allowances?.length || 0;
+    if (before === after) {
+      throw new Error(`Allowance type '${type}' not found`);
+    }
+    await employee2.save({ session });
+    getLogger().info("Allowance removed", {
+      employeeId: employee2.employeeId,
+      type
+    });
+    return employee2;
+  }
+  /**
+   * Add deduction to employee
+   */
+  async addDeduction(params) {
+    this.ensureInitialized();
+    const { employeeId, type, amount, auto = false, recurring = true, description, effectiveFrom = /* @__PURE__ */ new Date(), effectiveTo, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    if (employee2.status === "terminated") {
+      throw new EmployeeTerminatedError(employee2.employeeId);
+    }
+    if (!employee2.compensation.deductions) {
+      employee2.compensation.deductions = [];
+    }
+    employee2.compensation.deductions.push({
+      type,
+      name: type,
+      amount,
+      auto,
+      recurring,
+      description,
+      effectiveFrom,
+      effectiveTo
+    });
+    if (hasPluginMethod(employee2, "updateSalaryCalculations")) {
+      employee2.updateSalaryCalculations();
+    }
+    await employee2.save({ session });
+    getLogger().info("Deduction added", {
+      employeeId: employee2.employeeId,
+      type,
+      amount,
+      auto
+    });
+    return employee2;
+  }
+  /**
+   * Remove deduction from employee
+   */
+  async removeDeduction(params) {
+    this.ensureInitialized();
+    const { employeeId, type, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    const before = employee2.compensation.deductions?.length || 0;
+    if (hasPluginMethod(employee2, "removeDeduction")) {
+      employee2.removeDeduction(type);
+    } else {
+      if (employee2.compensation.deductions) {
+        employee2.compensation.deductions = employee2.compensation.deductions.filter(
+          (d) => d.type !== type
+        );
+      }
+    }
+    const after = employee2.compensation.deductions?.length || 0;
+    if (before === after) {
+      throw new Error(`Deduction type '${type}' not found`);
+    }
+    await employee2.save({ session });
+    getLogger().info("Deduction removed", {
+      employeeId: employee2.employeeId,
+      type
+    });
+    return employee2;
+  }
+  /**
+   * Update bank details
+   */
+  async updateBankDetails(params) {
+    this.ensureInitialized();
+    const { employeeId, bankDetails, context } = params;
+    const session = context?.session;
+    let query = this.models.EmployeeModel.findById(toObjectId(employeeId));
+    if (session) query = query.session(session);
+    const employee2 = await query;
+    if (!employee2) {
+      throw new EmployeeNotFoundError(employeeId.toString());
+    }
+    employee2.bankDetails = { ...employee2.bankDetails, ...bankDetails };
+    await employee2.save({ session });
+    getLogger().info("Bank details updated", {
+      employeeId: employee2.employeeId
+    });
+    return employee2;
+  }
+  // ========================================
+  // Payroll Processing
+  // ========================================
+  /**
+   * Process salary for single employee
+   * 
+   * ATOMICITY: This method creates its own transaction if none provided.
+   * All database operations (PayrollRecord, Transaction, Employee stats) 
+   * are atomic - either all succeed or all fail.
+   */
+  async processSalary(params) {
+    this.ensureInitialized();
+    const { employeeId, month, year, paymentDate = /* @__PURE__ */ new Date(), paymentMethod = "bank", context } = params;
+    const providedSession = context?.session;
+    const session = providedSession || await mongoose2.startSession();
+    const shouldManageTransaction = !providedSession && session != null;
+    try {
+      if (shouldManageTransaction) {
+        await session.startTransaction();
+      }
+      let query = this.models.EmployeeModel.findById(toObjectId(employeeId)).populate("userId", "name email");
+      if (session) query = query.session(session);
+      const employee2 = await query;
+      if (!employee2) {
+        throw new EmployeeNotFoundError(employeeId.toString());
+      }
+      const canReceive = hasPluginMethod(employee2, "canReceiveSalary") ? employee2.canReceiveSalary() : employee2.status === "active" && (employee2.compensation?.baseAmount || 0) > 0;
+      if (!canReceive) {
+        throw new NotEligibleError("Employee is not eligible to receive salary");
+      }
+      const existingQuery = payroll().forEmployee(employeeId).forPeriod(month, year).whereIn("status", ["paid", "processing"]).build();
+      let existingRecordQuery = this.models.PayrollRecordModel.findOne(existingQuery);
+      if (session) existingRecordQuery = existingRecordQuery.session(session);
+      const existingRecord = await existingRecordQuery;
+      if (existingRecord) {
+        throw new DuplicatePayrollError(employee2.employeeId, month, year);
+      }
+      const period = { ...getPayPeriod(month, year), payDate: paymentDate };
+      const breakdown = await this.calculateSalaryBreakdown(employee2, period, session);
+      const userIdValue = employee2.userId ? typeof employee2.userId === "object" && "_id" in employee2.userId ? employee2.userId._id : employee2.userId : void 0;
+      const [payrollRecord] = await this.models.PayrollRecordModel.create([{
+        organizationId: employee2.organizationId,
+        employeeId: employee2._id,
+        userId: userIdValue,
+        period,
+        breakdown,
+        status: "processing",
+        paymentMethod,
+        processedAt: /* @__PURE__ */ new Date(),
+        processedBy: context?.userId ? toObjectId(context.userId) : void 0
+      }], session ? { session } : {});
+      const [transaction] = await this.models.TransactionModel.create([{
+        organizationId: employee2.organizationId,
+        type: "expense",
+        category: HRM_TRANSACTION_CATEGORIES.SALARY,
+        amount: breakdown.netSalary,
+        method: paymentMethod,
+        status: "completed",
+        date: paymentDate,
+        referenceId: employee2._id,
+        referenceModel: "Employee",
+        handledBy: context?.userId ? toObjectId(context.userId) : void 0,
+        notes: `Salary payment - ${employee2.userId?.name || employee2.employeeId} (${month}/${year})`,
+        metadata: {
+          employeeId: employee2.employeeId,
+          payrollRecordId: payrollRecord._id,
+          period: { month, year },
+          breakdown: {
+            base: breakdown.baseAmount,
+            allowances: sumAllowances(breakdown.allowances),
+            deductions: sumDeductions(breakdown.deductions),
+            tax: breakdown.taxAmount || 0,
+            gross: breakdown.grossSalary,
+            net: breakdown.netSalary
+          }
+        }
+      }], session ? { session } : {});
+      payrollRecord.transactionId = transaction._id;
+      payrollRecord.status = "paid";
+      payrollRecord.paidAt = paymentDate;
+      await payrollRecord.save(session ? { session } : {});
+      await this.updatePayrollStats(employee2, breakdown.netSalary, paymentDate, session);
+      if (shouldManageTransaction) {
+        await session.commitTransaction();
+      }
+      this._events.emitSync("salary:processed", {
+        employee: {
+          id: employee2._id,
+          employeeId: employee2.employeeId,
+          name: employee2.userId?.name
+        },
+        payroll: {
+          id: payrollRecord._id,
+          period: { month, year },
+          grossAmount: breakdown.grossSalary,
+          netAmount: breakdown.netSalary
+        },
+        transactionId: transaction._id,
+        organizationId: employee2.organizationId,
+        context
+      });
+      getLogger().info("Salary processed", {
+        employeeId: employee2.employeeId,
+        month,
+        year,
+        amount: breakdown.netSalary
+      });
+      return { payrollRecord, transaction, employee: employee2 };
+    } catch (error) {
+      if (shouldManageTransaction && session?.inTransaction()) {
+        await session.abortTransaction();
+      }
+      throw error;
+    } finally {
+      if (shouldManageTransaction && session) {
+        await session.endSession();
+      }
+    }
+  }
+  /**
+   * Process bulk payroll
+   * 
+   * ATOMICITY STRATEGY: Each employee is processed in its own transaction.
+   * This allows partial success - some employees can succeed while others fail.
+   * Failed employees don't affect successful ones.
+   */
+  async processBulkPayroll(params) {
+    this.ensureInitialized();
+    const { organizationId, month, year, employeeIds = [], paymentDate = /* @__PURE__ */ new Date(), paymentMethod = "bank", context } = params;
+    const query = { organizationId: toObjectId(organizationId), status: "active" };
+    if (employeeIds.length > 0) {
+      query._id = { $in: employeeIds.map(toObjectId) };
+    }
+    const employees = await this.models.EmployeeModel.find(query);
+    const results = {
+      successful: [],
+      failed: [],
+      total: employees.length
+    };
+    for (const employee2 of employees) {
+      try {
+        const result = await this.processSalary({
+          employeeId: employee2._id,
+          month,
+          year,
+          paymentDate,
+          paymentMethod,
+          context: { ...context, session: void 0 }
+          // Don't pass session - let processSalary create its own
+        });
+        results.successful.push({
+          employeeId: employee2.employeeId,
+          amount: result.payrollRecord.breakdown.netSalary,
+          transactionId: result.transaction._id
+        });
+      } catch (error) {
+        results.failed.push({
+          employeeId: employee2.employeeId,
+          error: error.message
+        });
+        getLogger().error("Failed to process salary", {
+          employeeId: employee2.employeeId,
+          error: error.message
+        });
+      }
+    }
+    this._events.emitSync("payroll:completed", {
+      organizationId: toObjectId(organizationId),
+      period: { month, year },
+      summary: {
+        total: results.total,
+        successful: results.successful.length,
+        failed: results.failed.length,
+        totalAmount: results.successful.reduce((sum, r) => sum + r.amount, 0)
+      },
+      context
+    });
+    getLogger().info("Bulk payroll processed", {
+      organizationId: organizationId.toString(),
+      month,
+      year,
+      total: results.total,
+      successful: results.successful.length,
+      failed: results.failed.length
+    });
+    return results;
+  }
+  /**
+   * Get payroll history
+   */
+  async payrollHistory(params) {
+    this.ensureInitialized();
+    const { employeeId, organizationId, month, year, status, pagination = {} } = params;
+    let queryBuilder = payroll();
+    if (employeeId) queryBuilder = queryBuilder.forEmployee(employeeId);
+    if (organizationId) queryBuilder = queryBuilder.forOrganization(organizationId);
+    if (month || year) queryBuilder = queryBuilder.forPeriod(month, year);
+    if (status) queryBuilder = queryBuilder.withStatus(status);
+    const query = queryBuilder.build();
+    const page = pagination.page || 1;
+    const limit = pagination.limit || 20;
+    const sort = pagination.sort || { "period.year": -1, "period.month": -1 };
+    return this.models.PayrollRecordModel.find(query).populate("employeeId", "employeeId position department").populate("userId", "name email").populate("transactionId", "amount method status date").sort(sort).skip((page - 1) * limit).limit(limit);
+  }
+  /**
+   * Get payroll summary
+   */
+  async payrollSummary(params) {
+    this.ensureInitialized();
+    const { organizationId, month, year } = params;
+    const query = { organizationId: toObjectId(organizationId) };
+    if (month) query["period.month"] = month;
+    if (year) query["period.year"] = year;
+    const [summary] = await this.models.PayrollRecordModel.aggregate([
+      { $match: query },
+      {
+        $group: {
+          _id: null,
+          totalGross: { $sum: "$breakdown.grossSalary" },
+          totalNet: { $sum: "$breakdown.netSalary" },
+          totalDeductions: { $sum: { $sum: "$breakdown.deductions.amount" } },
+          totalTax: { $sum: { $ifNull: ["$breakdown.taxAmount", 0] } },
+          employeeCount: { $sum: 1 },
+          paidCount: { $sum: { $cond: [{ $eq: ["$status", "paid"] }, 1, 0] } },
+          pendingCount: { $sum: { $cond: [{ $eq: ["$status", "pending"] }, 1, 0] } }
+        }
+      }
+    ]);
+    return summary || {
+      totalGross: 0,
+      totalNet: 0,
+      totalDeductions: 0,
+      totalTax: 0,
+      employeeCount: 0,
+      paidCount: 0,
+      pendingCount: 0
+    };
+  }
+  /**
+   * Export payroll data
+   */
+  async exportPayroll(params) {
+    this.ensureInitialized();
+    const { organizationId, startDate, endDate } = params;
+    const query = {
+      organizationId: toObjectId(organizationId),
+      "period.payDate": { $gte: startDate, $lte: endDate }
+    };
+    const records = await this.models.PayrollRecordModel.find(query).populate("employeeId", "employeeId position department").populate("userId", "name email").populate("transactionId", "amount method status date").sort({ "period.year": -1, "period.month": -1 });
+    await this.models.PayrollRecordModel.updateMany(query, {
+      exported: true,
+      exportedAt: /* @__PURE__ */ new Date()
+    });
+    this._events.emitSync("payroll:exported", {
+      organizationId: toObjectId(organizationId),
+      dateRange: { start: startDate, end: endDate },
+      recordCount: records.length,
+      format: "json"
+    });
+    getLogger().info("Payroll data exported", {
+      organizationId: organizationId.toString(),
+      count: records.length
+    });
+    return records;
+  }
+  // ========================================
+  // Helper Methods
+  // ========================================
+  /**
+   * Calculate salary breakdown with proper handling for:
+   * - Effective dates on allowances/deductions
+   * - Pro-rating for mid-period hires AND terminations
+   * - Tax calculation
+   * - Working days vs calendar days for attendance
+   */
+  async calculateSalaryBreakdown(employee2, period, session) {
+    const comp = employee2.compensation;
+    let baseAmount = comp.baseAmount;
+    const workingDaysInMonth = getWorkingDaysInMonth(period.year, period.month);
+    const proRating = this.calculateProRatingAdvanced(
+      employee2.hireDate,
+      employee2.terminationDate || null,
+      period.startDate,
+      period.endDate,
+      workingDaysInMonth
+    );
+    if (proRating.isProRated && this.config.payroll.allowProRating) {
+      baseAmount = Math.round(baseAmount * proRating.ratio);
+    }
+    const effectiveAllowances = (comp.allowances || []).filter((a) => isEffectiveForPeriod(a, period.startDate, period.endDate)).filter((a) => a.recurring !== false);
+    const effectiveDeductions = (comp.deductions || []).filter((d) => isEffectiveForPeriod(d, period.startDate, period.endDate)).filter((d) => d.auto || d.recurring);
+    const allowances = effectiveAllowances.map((a) => ({
+      type: a.type,
+      amount: proRating.isProRated && this.config.payroll.allowProRating ? Math.round(a.amount * proRating.ratio) : a.amount,
+      taxable: a.taxable ?? true
+    }));
+    const deductions = effectiveDeductions.map((d) => ({
+      type: d.type,
+      amount: proRating.isProRated && this.config.payroll.allowProRating ? Math.round(d.amount * proRating.ratio) : d.amount,
+      description: d.description
+    }));
+    let attendanceDeduction = 0;
+    if (this.models.AttendanceModel && this.config.payroll.attendanceIntegration) {
+      attendanceDeduction = await this.calculateAttendanceDeduction(
+        employee2._id,
+        employee2.organizationId,
+        period,
+        baseAmount / proRating.workingDays,
+        // Daily rate based on working days
+        proRating.workingDays,
+        session
+      );
+    }
+    if (attendanceDeduction > 0) {
+      deductions.push({
+        type: "absence",
+        amount: attendanceDeduction,
+        description: "Unpaid leave deduction"
+      });
+    }
+    const grossSalary = calculateGross(baseAmount, allowances);
+    const taxableAllowances = allowances.filter((a) => a.taxable);
+    const taxableAmount = baseAmount + sumAllowances(taxableAllowances);
+    let taxAmount = 0;
+    const currency = comp.currency || this.config.payroll.defaultCurrency;
+    const taxBrackets = TAX_BRACKETS[currency] || [];
+    if (taxBrackets.length > 0 && this.config.payroll.autoDeductions) {
+      const annualTaxable = taxableAmount * 12;
+      const annualTax = applyTaxBrackets(annualTaxable, taxBrackets);
+      taxAmount = Math.round(annualTax / 12);
+    }
+    if (taxAmount > 0) {
+      deductions.push({
+        type: "tax",
+        amount: taxAmount,
+        description: "Income tax"
+      });
+    }
+    const netSalary = calculateNet(grossSalary, deductions);
+    return {
+      baseAmount,
+      allowances,
+      deductions,
+      grossSalary,
+      netSalary,
+      taxableAmount,
+      taxAmount,
+      workingDays: proRating.workingDays,
+      actualDays: proRating.actualDays,
+      proRatedAmount: proRating.isProRated ? baseAmount : 0,
+      attendanceDeduction
+    };
+  }
+  /**
+   * Advanced pro-rating calculation that handles:
+   * - Mid-period hires
+   * - Mid-period terminations
+   * - Working days (not calendar days)
+   */
+  calculateProRatingAdvanced(hireDate, terminationDate, periodStart, periodEnd, workingDaysInMonth) {
+    const hire = new Date(hireDate);
+    const termination = terminationDate ? new Date(terminationDate) : null;
+    const effectiveStart = hire > periodStart ? hire : periodStart;
+    const effectiveEnd = termination && termination < periodEnd ? termination : periodEnd;
+    if (effectiveStart > periodEnd || termination && termination < periodStart) {
+      return {
+        isProRated: true,
+        ratio: 0,
+        workingDays: workingDaysInMonth,
+        actualDays: 0
+      };
+    }
+    const totalDays = diffInDays(periodStart, periodEnd) + 1;
+    const actualDays = diffInDays(effectiveStart, effectiveEnd) + 1;
+    const ratio = actualDays / totalDays;
+    const actualWorkingDays = Math.round(workingDaysInMonth * ratio);
+    const isProRated = hire > periodStart || termination !== null && termination < periodEnd;
+    return {
+      isProRated,
+      ratio,
+      workingDays: workingDaysInMonth,
+      actualDays: actualWorkingDays
+    };
+  }
+  /**
+   * Calculate attendance deduction using working days (not calendar days)
+   */
+  async calculateAttendanceDeduction(employeeId, organizationId, period, dailyRate, expectedWorkingDays, session) {
+    try {
+      if (!this.models.AttendanceModel) return 0;
+      let query = this.models.AttendanceModel.findOne({
+        tenantId: organizationId,
+        targetId: employeeId,
+        targetModel: "Employee",
+        year: period.year,
+        month: period.month
+      });
+      if (session) query = query.session(session);
+      const attendance = await query;
+      if (!attendance) return 0;
+      const workedDays = attendance.totalWorkDays || 0;
+      const absentDays = Math.max(0, expectedWorkingDays - workedDays);
+      return Math.round(absentDays * dailyRate);
+    } catch (error) {
+      getLogger().warn("Failed to calculate attendance deduction", {
+        employeeId: employeeId.toString(),
+        error: error.message
+      });
+      return 0;
+    }
+  }
+  async updatePayrollStats(employee2, amount, paymentDate, session) {
+    if (!employee2.payrollStats) {
+      employee2.payrollStats = {
+        totalPaid: 0,
+        paymentsThisYear: 0,
+        averageMonthly: 0
+      };
+    }
+    employee2.payrollStats.totalPaid = (employee2.payrollStats.totalPaid || 0) + amount;
+    employee2.payrollStats.lastPaymentDate = paymentDate;
+    employee2.payrollStats.paymentsThisYear = (employee2.payrollStats.paymentsThisYear || 0) + 1;
+    employee2.payrollStats.averageMonthly = Math.round(
+      employee2.payrollStats.totalPaid / employee2.payrollStats.paymentsThisYear
+    );
+    employee2.payrollStats.nextPaymentDate = addMonths(paymentDate, 1);
+    await employee2.save(session ? { session } : {});
+  }
+  // ========================================
+  // Static Factory
+  // ========================================
+  /**
+   * Create a new Payroll instance
+   */
+  static create() {
+    return new _Payroll();
+  }
+};
+var PayrollBuilder = class {
+  _models = null;
+  _config;
+  _singleTenant = null;
+  _logger;
+  /**
+   * Set models
+   */
+  withModels(models) {
+    this._models = models;
+    return this;
+  }
+  /**
+   * Set config overrides
+   */
+  withConfig(config) {
+    this._config = config;
+    return this;
+  }
+  /**
+   * Enable single-tenant mode
+   * 
+   * Use this when building a single-organization HRM (no organizationId needed)
+   * 
+   * @example
+   * ```typescript
+   * const payroll = createPayrollInstance()
+   *   .withModels({ EmployeeModel, PayrollRecordModel, TransactionModel })
+   *   .withSingleTenant({ organizationId: 'my-company' })
+   *   .build();
+   * ```
+   */
+  withSingleTenant(config) {
+    this._singleTenant = config;
+    return this;
+  }
+  /**
+   * Enable single-tenant mode (shorthand)
+   * 
+   * Alias for withSingleTenant() - consistent with @classytic/clockin API
+   * 
+   * @example
+   * ```typescript
+   * const payroll = createPayrollInstance()
+   *   .withModels({ ... })
+   *   .forSingleTenant() // ← No organizationId needed!
+   *   .build();
+   * ```
+   */
+  forSingleTenant(config = {}) {
+    return this.withSingleTenant(config);
+  }
+  /**
+   * Set custom logger
+   */
+  withLogger(logger) {
+    this._logger = logger;
+    return this;
+  }
+  /**
+   * Build and initialize Payroll instance
+   */
+  build() {
+    if (!this._models) {
+      throw new Error("Models are required. Call withModels() first.");
+    }
+    const payroll3 = new Payroll();
+    payroll3.initialize({
+      EmployeeModel: this._models.EmployeeModel,
+      PayrollRecordModel: this._models.PayrollRecordModel,
+      TransactionModel: this._models.TransactionModel,
+      AttendanceModel: this._models.AttendanceModel,
+      config: this._config,
+      singleTenant: this._singleTenant,
+      logger: this._logger
+    });
+    return payroll3;
+  }
+};
+function createPayrollInstance() {
+  return new PayrollBuilder();
+}
+var payrollInstance = null;
+function getPayroll() {
+  if (!payrollInstance) {
+    payrollInstance = new Payroll();
+  }
+  return payrollInstance;
+}
+function resetPayroll() {
+  payrollInstance = null;
+  Container.resetInstance();
+}
+var payroll2 = getPayroll();
+var payroll_default = payroll2;
+
+export { Payroll, PayrollBuilder, createPayrollInstance, payroll_default as default, getPayroll, payroll2 as payroll, resetPayroll };
+//# sourceMappingURL=payroll.js.map
+//# sourceMappingURL=payroll.js.map