@classytic/payroll 1.0.2 → 2.0.0

package/dist/index.js

@@ -0,0 +1,4352 @@
+import mongoose2, { Schema, 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();
+var loggingEnabled = true;
+function getLogger() {
+  return currentLogger;
+}
+function setLogger(logger2) {
+  currentLogger = logger2;
+}
+function enableLogging() {
+  loggingEnabled = true;
+}
+function disableLogging() {
+  loggingEnabled = false;
+}
+function isLoggingEnabled() {
+  return loggingEnabled;
+}
+var logger = {
+  info: (message, meta) => {
+    if (loggingEnabled) currentLogger.info(message, meta);
+  },
+  error: (message, meta) => {
+    if (loggingEnabled) currentLogger.error(message, meta);
+  },
+  warn: (message, meta) => {
+    if (loggingEnabled) currentLogger.warn(message, meta);
+  },
+  debug: (message, meta) => {
+    if (loggingEnabled) currentLogger.debug(message, meta);
+  }
+};
+
+// 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);
+var ROLE_MAPPING = {
+  byDepartment: {
+    management: "manager",
+    training: "trainer",
+    sales: "staff",
+    operations: "staff",
+    finance: "staff",
+    hr: "staff",
+    marketing: "staff",
+    it: "staff",
+    support: "staff",
+    maintenance: "staff"
+  },
+  byEmploymentType: {
+    full_time: "staff",
+    part_time: "staff",
+    contract: "consultant",
+    intern: "intern",
+    consultant: "consultant"
+  },
+  default: "staff"
+};
+function calculateTax(annualIncome, currency = "BDT") {
+  const brackets = TAX_BRACKETS[currency];
+  if (!brackets) return 0;
+  let tax = 0;
+  for (const bracket of brackets) {
+    if (annualIncome > bracket.min) {
+      const taxableAmount = Math.min(annualIncome, bracket.max) - bracket.min;
+      tax += taxableAmount * bracket.rate;
+    }
+  }
+  return Math.round(tax);
+}
+function determineOrgRole(employmentData) {
+  const { department, type: employmentType } = employmentData;
+  if (department && department in ROLE_MAPPING.byDepartment) {
+    return ROLE_MAPPING.byDepartment[department];
+  }
+  if (employmentType && employmentType in ROLE_MAPPING.byEmploymentType) {
+    return ROLE_MAPPING.byEmploymentType[employmentType];
+  }
+  return ROLE_MAPPING.default;
+}
+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(logger2) {
+    this._logger = logger2;
+  }
+  /**
+   * 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 addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function addMonths(date, months) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + months);
+  return result;
+}
+function addYears(date, years) {
+  const result = new Date(date);
+  result.setFullYear(result.getFullYear() + years);
+  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 startOfYear(date) {
+  const result = new Date(date);
+  result.setMonth(0, 1);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfYear(date) {
+  const result = new Date(date);
+  result.setMonth(11, 31);
+  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 diffInMonths(start, end) {
+  const startDate = new Date(start);
+  const endDate = new Date(end);
+  return (endDate.getFullYear() - startDate.getFullYear()) * 12 + (endDate.getMonth() - startDate.getMonth());
+}
+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 getCurrentPeriod(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  return {
+    year: d.getFullYear(),
+    month: d.getMonth() + 1
+  };
+}
+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);
+}
+function isOnProbation(probationEndDate, now = /* @__PURE__ */ new Date()) {
+  if (!probationEndDate) return false;
+  return now < new Date(probationEndDate);
+}
+function isDateInRange(date, start, end) {
+  const checkDate = new Date(date);
+  return checkDate >= new Date(start) && checkDate <= new Date(end);
+}
+function formatDateForDB(date) {
+  if (!date) return "";
+  return new Date(date).toISOString();
+}
+
+// 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 EmployeeBuilder = class {
+  data = {
+    employment: {},
+    compensation: {},
+    bankDetails: {}
+  };
+  /**
+   * Set user ID
+   */
+  forUser(userId) {
+    this.data.userId = userId;
+    return this;
+  }
+  /**
+   * Set organization ID
+   */
+  inOrganization(organizationId) {
+    this.data.organizationId = organizationId;
+    return this;
+  }
+  /**
+   * Set employee ID
+   */
+  withEmployeeId(employeeId) {
+    this.data.employment = { ...this.data.employment, employeeId };
+    return this;
+  }
+  /**
+   * Set department
+   */
+  inDepartment(department) {
+    this.data.employment = { ...this.data.employment, department };
+    return this;
+  }
+  /**
+   * Set position
+   */
+  asPosition(position) {
+    this.data.employment = { ...this.data.employment, position };
+    return this;
+  }
+  /**
+   * Set employment type
+   */
+  withEmploymentType(type) {
+    this.data.employment = { ...this.data.employment, type };
+    return this;
+  }
+  /**
+   * Set hire date
+   */
+  hiredOn(date) {
+    this.data.employment = { ...this.data.employment, hireDate: date };
+    return this;
+  }
+  /**
+   * Set probation period
+   */
+  withProbation(months) {
+    this.data.employment = { ...this.data.employment, probationMonths: months };
+    return this;
+  }
+  /**
+   * Set work schedule
+   */
+  withSchedule(schedule) {
+    this.data.employment = { ...this.data.employment, workSchedule: schedule };
+    return this;
+  }
+  /**
+   * Set base salary
+   */
+  withBaseSalary(amount, frequency = "monthly", currency = "BDT") {
+    this.data.compensation = {
+      ...this.data.compensation,
+      baseAmount: amount,
+      frequency,
+      currency
+    };
+    return this;
+  }
+  /**
+   * Add allowance
+   */
+  addAllowance(type, amount, options = {}) {
+    const allowances = this.data.compensation?.allowances || [];
+    this.data.compensation = {
+      ...this.data.compensation,
+      allowances: [
+        ...allowances,
+        { type, amount, taxable: options.taxable, recurring: options.recurring }
+      ]
+    };
+    return this;
+  }
+  /**
+   * Add deduction
+   */
+  addDeduction(type, amount, options = {}) {
+    const deductions = this.data.compensation?.deductions || [];
+    this.data.compensation = {
+      ...this.data.compensation,
+      deductions: [
+        ...deductions,
+        {
+          type,
+          amount,
+          auto: options.auto,
+          recurring: options.recurring,
+          description: options.description
+        }
+      ]
+    };
+    return this;
+  }
+  /**
+   * Set bank details
+   */
+  withBankDetails(bankDetails) {
+    this.data.bankDetails = bankDetails;
+    return this;
+  }
+  /**
+   * Build employee data
+   */
+  build() {
+    if (!this.data.userId || !this.data.organizationId) {
+      throw new Error("userId and organizationId are required");
+    }
+    if (!this.data.employment?.employeeId || !this.data.employment?.position) {
+      throw new Error("employeeId and position are required");
+    }
+    if (!this.data.compensation?.baseAmount) {
+      throw new Error("baseAmount is required");
+    }
+    return EmployeeFactory.create(this.data);
+  }
+};
+
+// src/enums.ts
+var EMPLOYMENT_TYPE = {
+  FULL_TIME: "full_time",
+  PART_TIME: "part_time",
+  CONTRACT: "contract",
+  INTERN: "intern",
+  CONSULTANT: "consultant"
+};
+var EMPLOYMENT_TYPE_VALUES = Object.values(EMPLOYMENT_TYPE);
+var EMPLOYEE_STATUS = {
+  ACTIVE: "active",
+  ON_LEAVE: "on_leave",
+  SUSPENDED: "suspended",
+  TERMINATED: "terminated"
+};
+var EMPLOYEE_STATUS_VALUES = Object.values(EMPLOYEE_STATUS);
+var DEPARTMENT = {
+  MANAGEMENT: "management",
+  TRAINING: "training",
+  SALES: "sales",
+  OPERATIONS: "operations",
+  SUPPORT: "support",
+  HR: "hr",
+  MAINTENANCE: "maintenance",
+  MARKETING: "marketing",
+  FINANCE: "finance",
+  IT: "it"
+};
+var DEPARTMENT_VALUES = Object.values(DEPARTMENT);
+var PAYMENT_FREQUENCY = {
+  MONTHLY: "monthly",
+  BI_WEEKLY: "bi_weekly",
+  WEEKLY: "weekly",
+  HOURLY: "hourly",
+  DAILY: "daily"
+};
+var PAYMENT_FREQUENCY_VALUES = Object.values(PAYMENT_FREQUENCY);
+var ALLOWANCE_TYPE = {
+  HOUSING: "housing",
+  TRANSPORT: "transport",
+  MEAL: "meal",
+  MOBILE: "mobile",
+  MEDICAL: "medical",
+  EDUCATION: "education",
+  BONUS: "bonus",
+  OTHER: "other"
+};
+var ALLOWANCE_TYPE_VALUES = Object.values(ALLOWANCE_TYPE);
+var DEDUCTION_TYPE = {
+  TAX: "tax",
+  LOAN: "loan",
+  ADVANCE: "advance",
+  PROVIDENT_FUND: "provident_fund",
+  INSURANCE: "insurance",
+  ABSENCE: "absence",
+  OTHER: "other"
+};
+var DEDUCTION_TYPE_VALUES = Object.values(DEDUCTION_TYPE);
+var PAYROLL_STATUS = {
+  PENDING: "pending",
+  PROCESSING: "processing",
+  PAID: "paid",
+  FAILED: "failed",
+  CANCELLED: "cancelled"
+};
+Object.values(PAYROLL_STATUS);
+var TERMINATION_REASON = {
+  RESIGNATION: "resignation",
+  RETIREMENT: "retirement",
+  TERMINATION: "termination",
+  CONTRACT_END: "contract_end",
+  MUTUAL_AGREEMENT: "mutual_agreement",
+  OTHER: "other"
+};
+var TERMINATION_REASON_VALUES = Object.values(TERMINATION_REASON);
+var HRM_TRANSACTION_CATEGORIES = {
+  SALARY: "salary",
+  BONUS: "bonus",
+  COMMISSION: "commission",
+  OVERTIME: "overtime",
+  SEVERANCE: "severance"
+};
+Object.values(HRM_TRANSACTION_CATEGORIES);
+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(min2, max2) {
+    return this.whereBetween("compensation.netSalary", min2, max2);
+  }
+};
+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 sum(numbers) {
+  return numbers.reduce((total, n) => total + n, 0);
+}
+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 applyPercentage(amount, percentage) {
+  return Math.round(amount * (percentage / 100));
+}
+function calculateGross(baseAmount, allowances) {
+  return baseAmount + sumAllowances(allowances);
+}
+function calculateNet(gross, deductions) {
+  return Math.max(0, gross - sumDeductions(deductions));
+}
+function calculateProRating(hireDate, periodStart, periodEnd) {
+  const totalDays = diffInDays(periodStart, periodEnd) + 1;
+  if (hireDate <= periodStart) {
+    return {
+      isProRated: false,
+      totalDays,
+      actualDays: totalDays,
+      ratio: 1
+    };
+  }
+  if (hireDate > periodStart && hireDate <= periodEnd) {
+    const actualDays = diffInDays(hireDate, periodEnd) + 1;
+    const ratio = actualDays / totalDays;
+    return {
+      isProRated: true,
+      totalDays,
+      actualDays,
+      ratio
+    };
+  }
+  return {
+    isProRated: false,
+    totalDays,
+    actualDays: 0,
+    ratio: 0
+  };
+}
+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);
+}
+function pipe(...fns) {
+  return (value) => fns.reduce((acc, fn) => fn(acc), value);
+}
+function compose(...fns) {
+  return (value) => fns.reduceRight((acc, fn) => fn(acc), value);
+}
+
+// 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((sum2, r) => sum2 + 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(logger2) {
+    this._logger = logger2;
+    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 allowanceSchema = new Schema(
+  {
+    type: {
+      type: String,
+      enum: ALLOWANCE_TYPE_VALUES,
+      required: true
+    },
+    name: { type: String },
+    amount: { type: Number, required: true, min: 0 },
+    isPercentage: { type: Boolean, default: false },
+    value: { type: Number },
+    taxable: { type: Boolean, default: true },
+    recurring: { type: Boolean, default: true },
+    effectiveFrom: { type: Date, default: () => /* @__PURE__ */ new Date() },
+    effectiveTo: { type: Date }
+  },
+  { _id: false }
+);
+var deductionSchema = new Schema(
+  {
+    type: {
+      type: String,
+      enum: DEDUCTION_TYPE_VALUES,
+      required: true
+    },
+    name: { type: String },
+    amount: { type: Number, required: true, min: 0 },
+    isPercentage: { type: Boolean, default: false },
+    value: { type: Number },
+    auto: { type: Boolean, default: false },
+    recurring: { type: Boolean, default: true },
+    effectiveFrom: { type: Date, default: () => /* @__PURE__ */ new Date() },
+    effectiveTo: { type: Date },
+    description: { type: String }
+  },
+  { _id: false }
+);
+var compensationSchema = new Schema(
+  {
+    baseAmount: { type: Number, required: true, min: 0 },
+    frequency: {
+      type: String,
+      enum: PAYMENT_FREQUENCY_VALUES,
+      default: "monthly"
+    },
+    currency: { type: String, default: "BDT" },
+    allowances: [allowanceSchema],
+    deductions: [deductionSchema],
+    grossSalary: { type: Number, default: 0 },
+    netSalary: { type: Number, default: 0 },
+    effectiveFrom: { type: Date, default: () => /* @__PURE__ */ new Date() },
+    lastModified: { type: Date, default: () => /* @__PURE__ */ new Date() }
+  },
+  { _id: false }
+);
+var workScheduleSchema = new Schema(
+  {
+    hoursPerWeek: { type: Number, min: 0, max: 168 },
+    hoursPerDay: { type: Number, min: 0, max: 24 },
+    workingDays: [{ type: Number, min: 0, max: 6 }],
+    shiftStart: { type: String },
+    shiftEnd: { type: String }
+  },
+  { _id: false }
+);
+var bankDetailsSchema = new Schema(
+  {
+    accountName: { type: String },
+    accountNumber: { type: String },
+    bankName: { type: String },
+    branchName: { type: String },
+    routingNumber: { type: String }
+  },
+  { _id: false }
+);
+var employmentHistorySchema = new Schema(
+  {
+    hireDate: { type: Date, required: true },
+    terminationDate: { type: Date, required: true },
+    reason: { type: String, enum: TERMINATION_REASON_VALUES },
+    finalSalary: { type: Number },
+    position: { type: String },
+    department: { type: String },
+    notes: { type: String }
+  },
+  { timestamps: true }
+);
+var payrollStatsSchema = new Schema(
+  {
+    totalPaid: { type: Number, default: 0, min: 0 },
+    lastPaymentDate: { type: Date },
+    nextPaymentDate: { type: Date },
+    paymentsThisYear: { type: Number, default: 0, min: 0 },
+    averageMonthly: { type: Number, default: 0, min: 0 },
+    updatedAt: { type: Date, default: () => /* @__PURE__ */ new Date() }
+  },
+  { _id: false }
+);
+var employmentFields = {
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: true
+  },
+  organizationId: {
+    type: Schema.Types.ObjectId,
+    ref: "Organization",
+    required: true
+  },
+  employeeId: { type: String, required: true },
+  employmentType: {
+    type: String,
+    enum: EMPLOYMENT_TYPE_VALUES,
+    default: "full_time"
+  },
+  status: {
+    type: String,
+    enum: EMPLOYEE_STATUS_VALUES,
+    default: "active"
+  },
+  department: { type: String, enum: DEPARTMENT_VALUES },
+  position: { type: String, required: true },
+  hireDate: { type: Date, required: true },
+  terminationDate: { type: Date },
+  probationEndDate: { type: Date },
+  employmentHistory: [employmentHistorySchema],
+  compensation: { type: compensationSchema, required: true },
+  workSchedule: workScheduleSchema,
+  bankDetails: bankDetailsSchema,
+  payrollStats: { type: payrollStatsSchema, default: () => ({}) }
+};
+new Schema(
+  {
+    baseAmount: { type: Number, required: true, min: 0 },
+    allowances: [
+      {
+        type: { type: String },
+        amount: { type: Number, min: 0 },
+        taxable: { type: Boolean, default: true }
+      }
+    ],
+    deductions: [
+      {
+        type: { type: String },
+        amount: { type: Number, min: 0 },
+        description: { type: String }
+      }
+    ],
+    grossSalary: { type: Number, required: true, min: 0 },
+    netSalary: { type: Number, required: true, min: 0 },
+    workingDays: { type: Number, min: 0 },
+    actualDays: { type: Number, min: 0 },
+    proRatedAmount: { type: Number, default: 0, min: 0 },
+    attendanceDeduction: { type: Number, default: 0, min: 0 },
+    overtimeAmount: { type: Number, default: 0, min: 0 },
+    bonusAmount: { type: Number, default: 0, min: 0 }
+  },
+  { _id: false }
+);
+new Schema(
+  {
+    month: { type: Number, required: true, min: 1, max: 12 },
+    year: { type: Number, required: true, min: 2020 },
+    startDate: { type: Date, required: true },
+    endDate: { type: Date, required: true },
+    payDate: { type: Date, required: true }
+  },
+  { _id: false }
+);
+({
+  organizationId: {
+    type: Schema.Types.ObjectId},
+  employeeId: {
+    type: Schema.Types.ObjectId},
+  userId: {
+    type: Schema.Types.ObjectId},
+  transactionId: { type: Schema.Types.ObjectId},
+  processedBy: { type: Schema.Types.ObjectId}});
+[
+  {
+    fields: { organizationId: 1, employeeId: 1, "period.month": 1, "period.year": 1 },
+    options: { unique: true }
+  },
+  { fields: { organizationId: 1, "period.year": 1, "period.month": 1 } },
+  { fields: { employeeId: 1, "period.year": -1, "period.month": -1 } },
+  { fields: { status: 1, createdAt: -1 } },
+  { fields: { organizationId: 1, status: 1, "period.payDate": 1 } },
+  {
+    fields: { createdAt: 1 },
+    options: {
+      expireAfterSeconds: HRM_CONFIG.dataRetention.payrollRecordsTTL,
+      partialFilterExpression: { exported: true }
+    }
+  }
+];
+var allowanceBreakdownSchema = new Schema(
+  {
+    type: { type: String, required: true },
+    amount: { type: Number, required: true },
+    taxable: { type: Boolean, default: true }
+  },
+  { _id: false }
+);
+var deductionBreakdownSchema = new Schema(
+  {
+    type: { type: String, required: true },
+    amount: { type: Number, required: true },
+    description: { type: String }
+  },
+  { _id: false }
+);
+var breakdownSchema = new Schema(
+  {
+    baseAmount: { type: Number, required: true },
+    allowances: [allowanceBreakdownSchema],
+    deductions: [deductionBreakdownSchema],
+    grossSalary: { type: Number, required: true },
+    netSalary: { type: Number, required: true },
+    taxableAmount: { type: Number, default: 0 },
+    taxAmount: { type: Number, default: 0 },
+    workingDays: { type: Number },
+    actualDays: { type: Number },
+    proRatedAmount: { type: Number, default: 0 },
+    attendanceDeduction: { type: Number, default: 0 }
+  },
+  { _id: false }
+);
+var periodSchema2 = new Schema(
+  {
+    month: { type: Number, required: true, min: 1, max: 12 },
+    year: { type: Number, required: true },
+    startDate: { type: Date, required: true },
+    endDate: { type: Date, required: true },
+    payDate: { type: Date }
+  },
+  { _id: false }
+);
+var payrollRecordSchema = new Schema(
+  {
+    organizationId: {
+      type: Schema.Types.ObjectId,
+      required: true,
+      ref: "Organization",
+      index: true
+    },
+    employeeId: {
+      type: Schema.Types.ObjectId,
+      required: true,
+      ref: "Employee",
+      index: true
+    },
+    userId: {
+      type: Schema.Types.ObjectId,
+      required: true,
+      ref: "User",
+      index: true
+    },
+    period: {
+      type: periodSchema2,
+      required: true
+    },
+    breakdown: {
+      type: breakdownSchema,
+      required: true
+    },
+    status: {
+      type: String,
+      enum: Object.values(PAYROLL_STATUS),
+      default: PAYROLL_STATUS.PENDING,
+      index: true
+    },
+    paymentMethod: {
+      type: String,
+      enum: ["cash", "bank", "check", "mobile", "bkash", "nagad", "rocket"],
+      default: "bank"
+    },
+    transactionId: {
+      type: Schema.Types.ObjectId,
+      ref: "Transaction"
+    },
+    paidAt: Date,
+    processedAt: Date,
+    processedBy: {
+      type: Schema.Types.ObjectId,
+      ref: "User"
+    },
+    notes: String,
+    metadata: {
+      type: Schema.Types.Mixed,
+      default: {}
+    },
+    exported: {
+      type: Boolean,
+      default: false
+    },
+    exportedAt: Date,
+    corrections: [
+      {
+        previousAmount: Number,
+        newAmount: Number,
+        reason: String,
+        correctedBy: { type: Schema.Types.ObjectId, ref: "User" },
+        correctedAt: { type: Date, default: Date.now }
+      }
+    ]
+  },
+  {
+    timestamps: true
+  }
+);
+payrollRecordSchema.index({ organizationId: 1, "period.month": 1, "period.year": 1 });
+payrollRecordSchema.index({ employeeId: 1, "period.month": 1, "period.year": 1 }, { unique: true });
+payrollRecordSchema.index({ organizationId: 1, status: 1 });
+payrollRecordSchema.index({ createdAt: 1 }, { expireAfterSeconds: HRM_CONFIG.dataRetention.payrollRecordsTTL });
+payrollRecordSchema.virtual("isPaid").get(function() {
+  return this.status === PAYROLL_STATUS.PAID;
+});
+payrollRecordSchema.virtual("totalDeductions").get(function() {
+  return (this.breakdown?.deductions || []).reduce(
+    (sum2, d) => sum2 + d.amount,
+    0
+  );
+});
+payrollRecordSchema.virtual("totalAllowances").get(function() {
+  return (this.breakdown?.allowances || []).reduce(
+    (sum2, a) => sum2 + a.amount,
+    0
+  );
+});
+payrollRecordSchema.methods.markAsPaid = function(transactionId, paidAt = /* @__PURE__ */ new Date()) {
+  this.status = PAYROLL_STATUS.PAID;
+  this.transactionId = transactionId;
+  this.paidAt = paidAt;
+};
+payrollRecordSchema.methods.markAsCancelled = function(reason) {
+  if (this.status === PAYROLL_STATUS.PAID) {
+    throw new Error("Cannot cancel paid payroll record");
+  }
+  this.status = PAYROLL_STATUS.CANCELLED;
+  this.notes = (this.notes || "") + `
+Cancelled: ${reason}`;
+};
+payrollRecordSchema.methods.addCorrection = function(previousAmount, newAmount, reason, correctedBy) {
+  if (!this.corrections) {
+    this.corrections = [];
+  }
+  this.corrections.push({
+    previousAmount,
+    newAmount,
+    reason,
+    correctedBy,
+    correctedAt: /* @__PURE__ */ new Date()
+  });
+  this.breakdown.netSalary = newAmount;
+  logger.info("Payroll correction added", {
+    recordId: this._id.toString(),
+    previousAmount,
+    newAmount,
+    reason
+  });
+};
+payrollRecordSchema.methods.getBreakdownSummary = function() {
+  const { baseAmount, allowances, deductions, grossSalary, netSalary } = this.breakdown;
+  return {
+    base: baseAmount,
+    totalAllowances: (allowances || []).reduce(
+      (sum2, a) => sum2 + a.amount,
+      0
+    ),
+    totalDeductions: (deductions || []).reduce(
+      (sum2, d) => sum2 + d.amount,
+      0
+    ),
+    gross: grossSalary,
+    net: netSalary
+  };
+};
+payrollRecordSchema.statics.findByPeriod = function(organizationId, month, year) {
+  return this.find({
+    organizationId,
+    "period.month": month,
+    "period.year": year
+  });
+};
+payrollRecordSchema.statics.findByEmployee = function(employeeId, limit = 12) {
+  return this.find({ employeeId }).sort({ "period.year": -1, "period.month": -1 }).limit(limit);
+};
+payrollRecordSchema.statics.getSummary = function(organizationId, month, year) {
+  const match2 = { organizationId };
+  if (month) match2["period.month"] = month;
+  if (year) match2["period.year"] = year;
+  return this.aggregate([
+    { $match: match2 },
+    {
+      $group: {
+        _id: null,
+        totalGross: { $sum: "$breakdown.grossSalary" },
+        totalNet: { $sum: "$breakdown.netSalary" },
+        count: { $sum: 1 },
+        paidCount: {
+          $sum: { $cond: [{ $eq: ["$status", PAYROLL_STATUS.PAID] }, 1, 0] }
+        }
+      }
+    }
+  ]).then((results) => results[0] || { totalGross: 0, totalNet: 0, count: 0, paidCount: 0 });
+};
+payrollRecordSchema.statics.getExpiringSoon = function(organizationId, daysBeforeExpiry = 30) {
+  const expiryThreshold = /* @__PURE__ */ new Date();
+  expiryThreshold.setSeconds(
+    expiryThreshold.getSeconds() + HRM_CONFIG.dataRetention.payrollRecordsTTL - daysBeforeExpiry * 24 * 60 * 60
+  );
+  return this.find({
+    organizationId,
+    exported: false,
+    createdAt: { $lte: expiryThreshold }
+  });
+};
+function getPayrollRecordModel(connection = mongoose2.connection) {
+  const modelName = "PayrollRecord";
+  if (connection.models[modelName]) {
+    return connection.models[modelName];
+  }
+  return connection.model(
+    modelName,
+    payrollRecordSchema
+  );
+}
+
+// src/utils/validation.ts
+function isActive(employee2) {
+  return employee2?.status === "active";
+}
+function isOnLeave(employee2) {
+  return employee2?.status === "on_leave";
+}
+function isSuspended(employee2) {
+  return employee2?.status === "suspended";
+}
+function isTerminated(employee2) {
+  return employee2?.status === "terminated";
+}
+function isEmployed(employee2) {
+  return isActive(employee2) || isOnLeave(employee2) || isSuspended(employee2);
+}
+function canReceiveSalary(employee2) {
+  return (isActive(employee2) || isOnLeave(employee2)) && (employee2.compensation?.baseAmount ?? 0) > 0;
+}
+function required(fieldName) {
+  return (value) => value !== void 0 && value !== null && value !== "" ? true : `${fieldName} is required`;
+}
+function min(minValue2, fieldName) {
+  return (value) => value >= minValue2 ? true : `${fieldName} must be at least ${minValue2}`;
+}
+function max(maxValue2, fieldName) {
+  return (value) => value <= maxValue2 ? true : `${fieldName} must not exceed ${maxValue2}`;
+}
+function inRange(minValue2, maxValue2, fieldName) {
+  return (value) => value >= minValue2 && value <= maxValue2 ? true : `${fieldName} must be between ${minValue2} and ${maxValue2}`;
+}
+function oneOf(allowedValues, fieldName) {
+  return (value) => allowedValues.includes(value) ? true : `${fieldName} must be one of: ${allowedValues.join(", ")}`;
+}
+function createValidator(validationFns) {
+  return (data) => {
+    const errors = [];
+    for (const [field, validator] of Object.entries(validationFns)) {
+      const result = validator(data[field], data);
+      if (result !== true) {
+        errors.push(result);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  };
+}
+
+// src/factories/compensation.factory.ts
+var CompensationFactory = class {
+  /**
+   * Create compensation object
+   */
+  static create(params) {
+    const {
+      baseAmount,
+      frequency = "monthly",
+      currency = HRM_CONFIG.payroll.defaultCurrency,
+      allowances = [],
+      deductions = [],
+      effectiveFrom = /* @__PURE__ */ new Date()
+    } = params;
+    return {
+      baseAmount,
+      frequency,
+      currency,
+      allowances: allowances.map((a) => this.createAllowance(a, baseAmount)),
+      deductions: deductions.map((d) => this.createDeduction(d, baseAmount)),
+      effectiveFrom,
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create allowance
+   */
+  static createAllowance(params, baseAmount) {
+    const amount = params.isPercentage && baseAmount ? applyPercentage(baseAmount, params.value) : params.value;
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount,
+      isPercentage: params.isPercentage ?? false,
+      value: params.isPercentage ? params.value : void 0,
+      taxable: params.taxable ?? true,
+      recurring: true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create deduction
+   */
+  static createDeduction(params, baseAmount) {
+    const amount = params.isPercentage && baseAmount ? applyPercentage(baseAmount, params.value) : params.value;
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount,
+      isPercentage: params.isPercentage ?? false,
+      value: params.isPercentage ? params.value : void 0,
+      auto: params.auto ?? false,
+      recurring: true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Update base amount (immutable)
+   */
+  static updateBaseAmount(compensation, newAmount, effectiveFrom = /* @__PURE__ */ new Date()) {
+    return {
+      ...compensation,
+      baseAmount: newAmount,
+      lastModified: effectiveFrom
+    };
+  }
+  /**
+   * Add allowance (immutable)
+   */
+  static addAllowance(compensation, allowance) {
+    return {
+      ...compensation,
+      allowances: [
+        ...compensation.allowances,
+        this.createAllowance(allowance, compensation.baseAmount)
+      ],
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Remove allowance (immutable)
+   */
+  static removeAllowance(compensation, allowanceType) {
+    return {
+      ...compensation,
+      allowances: compensation.allowances.filter((a) => a.type !== allowanceType),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Add deduction (immutable)
+   */
+  static addDeduction(compensation, deduction) {
+    return {
+      ...compensation,
+      deductions: [
+        ...compensation.deductions,
+        this.createDeduction(deduction, compensation.baseAmount)
+      ],
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Remove deduction (immutable)
+   */
+  static removeDeduction(compensation, deductionType) {
+    return {
+      ...compensation,
+      deductions: compensation.deductions.filter((d) => d.type !== deductionType),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Calculate compensation breakdown
+   */
+  static calculateBreakdown(compensation) {
+    const { baseAmount, allowances, deductions } = compensation;
+    const calculatedAllowances = allowances.map((a) => ({
+      ...a,
+      calculatedAmount: a.isPercentage && a.value !== void 0 ? applyPercentage(baseAmount, a.value) : a.amount
+    }));
+    const calculatedDeductions = deductions.map((d) => ({
+      ...d,
+      calculatedAmount: d.isPercentage && d.value !== void 0 ? applyPercentage(baseAmount, d.value) : d.amount
+    }));
+    const grossAmount = calculateGross(
+      baseAmount,
+      calculatedAllowances.map((a) => ({ amount: a.calculatedAmount }))
+    );
+    const netAmount = calculateNet(
+      grossAmount,
+      calculatedDeductions.map((d) => ({ amount: d.calculatedAmount }))
+    );
+    return {
+      baseAmount,
+      allowances: calculatedAllowances,
+      deductions: calculatedDeductions,
+      grossAmount,
+      netAmount: Math.max(0, netAmount)
+    };
+  }
+  /**
+   * Apply salary increment (immutable)
+   */
+  static applyIncrement(compensation, params) {
+    const newBaseAmount = params.amount ? compensation.baseAmount + params.amount : compensation.baseAmount * (1 + (params.percentage || 0) / 100);
+    return this.updateBaseAmount(
+      compensation,
+      Math.round(newBaseAmount),
+      params.effectiveFrom
+    );
+  }
+};
+var CompensationBuilder = class {
+  data = {
+    baseAmount: 0,
+    frequency: "monthly",
+    currency: HRM_CONFIG.payroll.defaultCurrency,
+    allowances: [],
+    deductions: []
+  };
+  /**
+   * Set base amount
+   */
+  withBase(amount, frequency = "monthly", currency = HRM_CONFIG.payroll.defaultCurrency) {
+    this.data.baseAmount = amount;
+    this.data.frequency = frequency;
+    this.data.currency = currency;
+    return this;
+  }
+  /**
+   * Add allowance
+   */
+  addAllowance(type, value, isPercentage = false, name) {
+    this.data.allowances = [
+      ...this.data.allowances || [],
+      { type, value, isPercentage, name }
+    ];
+    return this;
+  }
+  /**
+   * Add deduction
+   */
+  addDeduction(type, value, isPercentage = false, name) {
+    this.data.deductions = [
+      ...this.data.deductions || [],
+      { type, value, isPercentage, name }
+    ];
+    return this;
+  }
+  /**
+   * Set effective date
+   */
+  effectiveFrom(date) {
+    this.data.effectiveFrom = date;
+    return this;
+  }
+  /**
+   * Build compensation
+   */
+  build() {
+    if (!this.data.baseAmount) {
+      throw new Error("baseAmount is required");
+    }
+    return CompensationFactory.create(this.data);
+  }
+};
+var CompensationPresets = {
+  /**
+   * Basic compensation (base only)
+   */
+  basic(baseAmount) {
+    return new CompensationBuilder().withBase(baseAmount).build();
+  },
+  /**
+   * With house rent allowance
+   */
+  withHouseRent(baseAmount, rentPercentage = 50) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", rentPercentage, true, "House Rent").build();
+  },
+  /**
+   * With medical allowance
+   */
+  withMedical(baseAmount, medicalPercentage = 10) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("medical", medicalPercentage, true, "Medical Allowance").build();
+  },
+  /**
+   * Standard package (house rent + medical + transport)
+   */
+  standard(baseAmount) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", 50, true, "House Rent").addAllowance("medical", 10, true, "Medical Allowance").addAllowance("transport", 5, true, "Transport Allowance").build();
+  },
+  /**
+   * With provident fund
+   */
+  withProvidentFund(baseAmount, pfPercentage = 10) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", 50, true, "House Rent").addAllowance("medical", 10, true, "Medical Allowance").addDeduction("provident_fund", pfPercentage, true, "Provident Fund").build();
+  },
+  /**
+   * Executive package
+   */
+  executive(baseAmount) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", 60, true, "House Rent").addAllowance("medical", 15, true, "Medical Allowance").addAllowance("transport", 10, true, "Transport Allowance").addAllowance("mobile", 5, true, "Mobile Allowance").addDeduction("provident_fund", 10, true, "Provident Fund").build();
+  }
+};
+
+// src/plugins/employee.plugin.ts
+function employeePlugin(schema, options = {}) {
+  const {
+    requireBankDetails = false,
+    compensationField = "compensation",
+    statusField = "status",
+    autoCalculateSalary = true
+  } = options;
+  schema.virtual("currentSalary").get(function() {
+    const compensation = this[compensationField];
+    return compensation?.netSalary || 0;
+  });
+  schema.virtual("isActive").get(function() {
+    return isActive({ status: this[statusField] });
+  });
+  schema.virtual("isTerminated").get(function() {
+    return isTerminated({ status: this[statusField] });
+  });
+  schema.virtual("yearsOfService").get(function() {
+    const hireDate = this.hireDate;
+    const terminationDate = this.terminationDate;
+    if (!hireDate) return 0;
+    const end = terminationDate || /* @__PURE__ */ new Date();
+    const days = diffInDays(hireDate, end);
+    return Math.max(0, Math.floor(days / 365.25 * 10) / 10);
+  });
+  schema.virtual("isOnProbation").get(function() {
+    const probationEndDate = this.probationEndDate;
+    if (!probationEndDate) return false;
+    return /* @__PURE__ */ new Date() < new Date(probationEndDate);
+  });
+  schema.methods.calculateSalary = function() {
+    const compensation = this[compensationField];
+    if (!compensation) {
+      return { gross: 0, deductions: 0, net: 0 };
+    }
+    const breakdown = CompensationFactory.calculateBreakdown(compensation);
+    return {
+      gross: breakdown.grossAmount,
+      deductions: sumDeductions(
+        breakdown.deductions.map((d) => ({ amount: d.calculatedAmount }))
+      ),
+      net: breakdown.netAmount
+    };
+  };
+  schema.methods.updateSalaryCalculations = function() {
+    const compensation = this[compensationField];
+    if (!compensation) return;
+    const calculated = this.calculateSalary();
+    this[compensationField].grossSalary = calculated.gross;
+    this[compensationField].netSalary = calculated.net;
+    this[compensationField].lastModified = /* @__PURE__ */ new Date();
+  };
+  schema.methods.canReceiveSalary = function() {
+    const status = this[statusField];
+    const compensation = this[compensationField];
+    const bankDetails = this.bankDetails;
+    return status === "active" && (compensation?.baseAmount ?? 0) > 0 && (!requireBankDetails || !!bankDetails?.accountNumber);
+  };
+  schema.methods.addAllowance = function(type, amount, taxable = true) {
+    const compensation = this[compensationField];
+    if (!compensation.allowances) {
+      compensation.allowances = [];
+    }
+    compensation.allowances.push({
+      type,
+      name: type,
+      amount,
+      taxable,
+      recurring: true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    });
+    this.updateSalaryCalculations();
+  };
+  schema.methods.addDeduction = function(type, amount, auto = false, description = "") {
+    const compensation = this[compensationField];
+    if (!compensation.deductions) {
+      compensation.deductions = [];
+    }
+    compensation.deductions.push({
+      type,
+      name: type,
+      amount,
+      auto,
+      recurring: true,
+      description,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    });
+    this.updateSalaryCalculations();
+  };
+  schema.methods.removeAllowance = function(type) {
+    const compensation = this[compensationField];
+    if (!compensation.allowances) return;
+    compensation.allowances = compensation.allowances.filter((a) => a.type !== type);
+    this.updateSalaryCalculations();
+  };
+  schema.methods.removeDeduction = function(type) {
+    const compensation = this[compensationField];
+    if (!compensation.deductions) return;
+    compensation.deductions = compensation.deductions.filter((d) => d.type !== type);
+    this.updateSalaryCalculations();
+  };
+  schema.methods.terminate = function(reason, terminationDate = /* @__PURE__ */ new Date()) {
+    const status = this[statusField];
+    if (status === "terminated") {
+      throw new Error("Employee already terminated");
+    }
+    const compensation = this[compensationField];
+    const employmentHistory = this.employmentHistory || [];
+    employmentHistory.push({
+      hireDate: this.hireDate,
+      terminationDate,
+      reason,
+      finalSalary: compensation?.netSalary || 0,
+      position: this.position,
+      department: this.department
+    });
+    this[statusField] = "terminated";
+    this.terminationDate = terminationDate;
+    this.employmentHistory = employmentHistory;
+    logger.info("Employee terminated", {
+      employeeId: this.employeeId,
+      organizationId: this.organizationId?.toString(),
+      reason
+    });
+  };
+  schema.methods.reHire = function(hireDate = /* @__PURE__ */ new Date(), position, department) {
+    const status = this[statusField];
+    if (status !== "terminated") {
+      throw new Error("Can only re-hire terminated employees");
+    }
+    this[statusField] = "active";
+    this.hireDate = hireDate;
+    this.terminationDate = null;
+    if (position) this.position = position;
+    if (department) this.department = department;
+    logger.info("Employee re-hired", {
+      employeeId: this.employeeId,
+      organizationId: this.organizationId?.toString()
+    });
+  };
+  if (autoCalculateSalary) {
+    schema.pre("save", async function() {
+      if (this.isModified(compensationField)) {
+        this.updateSalaryCalculations();
+      }
+    });
+  }
+  schema.index({ organizationId: 1, employeeId: 1 }, { unique: true });
+  schema.index({ userId: 1, organizationId: 1 }, { unique: true });
+  schema.index({ organizationId: 1, status: 1 });
+  schema.index({ organizationId: 1, department: 1 });
+  schema.index({ organizationId: 1, "compensation.netSalary": -1 });
+  logger.debug("Employee plugin applied", {
+    requireBankDetails,
+    autoCalculateSalary
+  });
+}
+
+// src/core/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function unwrap(result) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  return defaultValue;
+}
+function map(result, fn) {
+  if (isOk(result)) {
+    return ok(fn(result.value));
+  }
+  return result;
+}
+function mapErr(result, fn) {
+  if (isErr(result)) {
+    return err(fn(result.error));
+  }
+  return result;
+}
+
+// src/factories/payroll.factory.ts
+var PayrollFactory = class {
+  /**
+   * Create payroll data object
+   */
+  static create(params) {
+    const {
+      employeeId,
+      organizationId,
+      baseAmount,
+      allowances = [],
+      deductions = [],
+      period = {},
+      metadata = {}
+    } = params;
+    const calculatedAllowances = this.calculateAllowances(baseAmount, allowances);
+    const calculatedDeductions = this.calculateDeductions(baseAmount, deductions);
+    const gross = calculateGross(baseAmount, calculatedAllowances);
+    const net = calculateNet(gross, calculatedDeductions);
+    return {
+      employeeId,
+      organizationId,
+      period: this.createPeriod(period),
+      breakdown: {
+        baseAmount,
+        allowances: calculatedAllowances,
+        deductions: calculatedDeductions,
+        grossSalary: gross,
+        netSalary: net
+      },
+      status: "pending",
+      processedAt: null,
+      paidAt: null,
+      metadata: {
+        currency: metadata.currency || HRM_CONFIG.payroll.defaultCurrency,
+        paymentMethod: metadata.paymentMethod,
+        notes: metadata.notes
+      }
+    };
+  }
+  /**
+   * Create pay period
+   */
+  static createPeriod(params) {
+    const now = /* @__PURE__ */ new Date();
+    const month = params.month || now.getMonth() + 1;
+    const year = params.year || now.getFullYear();
+    const period = getPayPeriod(month, year);
+    return {
+      ...period,
+      payDate: params.payDate || /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Calculate allowances from base amount
+   */
+  static calculateAllowances(baseAmount, allowances) {
+    return allowances.map((allowance) => {
+      const amount = allowance.isPercentage && allowance.value !== void 0 ? Math.round(baseAmount * allowance.value / 100) : allowance.amount;
+      return {
+        type: allowance.type,
+        amount,
+        taxable: allowance.taxable ?? true
+      };
+    });
+  }
+  /**
+   * Calculate deductions from base amount
+   */
+  static calculateDeductions(baseAmount, deductions) {
+    return deductions.map((deduction) => {
+      const amount = deduction.isPercentage && deduction.value !== void 0 ? Math.round(baseAmount * deduction.value / 100) : deduction.amount;
+      return {
+        type: deduction.type,
+        amount,
+        description: deduction.description
+      };
+    });
+  }
+  /**
+   * Create bonus object
+   */
+  static createBonus(params) {
+    return {
+      type: params.type,
+      amount: params.amount,
+      reason: params.reason,
+      approvedBy: params.approvedBy,
+      approvedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Mark payroll as paid (immutable)
+   * Sets both top-level transactionId and metadata for compatibility
+   */
+  static markAsPaid(payroll3, params = {}) {
+    return {
+      ...payroll3,
+      status: "paid",
+      paidAt: params.paidAt || /* @__PURE__ */ new Date(),
+      processedAt: payroll3.processedAt || params.paidAt || /* @__PURE__ */ new Date(),
+      transactionId: params.transactionId || payroll3.transactionId,
+      metadata: {
+        ...payroll3.metadata,
+        transactionId: params.transactionId,
+        paymentMethod: params.paymentMethod || payroll3.metadata?.paymentMethod
+      }
+    };
+  }
+  /**
+   * Mark payroll as processed (immutable)
+   */
+  static markAsProcessed(payroll3, params = {}) {
+    return {
+      ...payroll3,
+      status: "processing",
+      processedAt: params.processedAt || /* @__PURE__ */ new Date()
+    };
+  }
+};
+var BatchPayrollFactory = class {
+  /**
+   * Create payroll records for multiple employees
+   */
+  static createBatch(employees, params) {
+    return employees.map(
+      (employee2) => PayrollFactory.create({
+        employeeId: employee2._id,
+        organizationId: params.organizationId || employee2.organizationId,
+        baseAmount: employee2.compensation.baseAmount,
+        allowances: employee2.compensation.allowances || [],
+        deductions: employee2.compensation.deductions || [],
+        period: { month: params.month, year: params.year },
+        metadata: { currency: employee2.compensation.currency }
+      })
+    );
+  }
+  /**
+   * Calculate total payroll amounts
+   */
+  static calculateTotalPayroll(payrolls) {
+    return payrolls.reduce(
+      (totals, payroll3) => ({
+        count: totals.count + 1,
+        totalGross: totals.totalGross + payroll3.breakdown.grossSalary,
+        totalNet: totals.totalNet + payroll3.breakdown.netSalary,
+        totalAllowances: totals.totalAllowances + sumAllowances(payroll3.breakdown.allowances),
+        totalDeductions: totals.totalDeductions + sumDeductions(payroll3.breakdown.deductions)
+      }),
+      { count: 0, totalGross: 0, totalNet: 0, totalAllowances: 0, totalDeductions: 0 }
+    );
+  }
+};
+
+// src/services/employee.service.ts
+var EmployeeService = class {
+  constructor(EmployeeModel) {
+    this.EmployeeModel = EmployeeModel;
+  }
+  /**
+   * Find employee by ID
+   */
+  async findById(employeeId, options = {}) {
+    let query = this.EmployeeModel.findById(toObjectId(employeeId));
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    if (options.populate) {
+      query = query.populate("userId", "name email phone");
+    }
+    return query.exec();
+  }
+  /**
+   * Find employee by user and organization
+   */
+  async findByUserId(userId, organizationId, options = {}) {
+    const query = employee().forUser(userId).forOrganization(organizationId).build();
+    let mongooseQuery = this.EmployeeModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find active employees in organization
+   */
+  async findActive(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).active().build();
+    let mongooseQuery = this.EmployeeModel.find(query, options.projection);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employed employees (not terminated)
+   */
+  async findEmployed(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).employed().build();
+    let mongooseQuery = this.EmployeeModel.find(query, options.projection);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employees by department
+   */
+  async findByDepartment(organizationId, department, options = {}) {
+    const query = employee().forOrganization(organizationId).inDepartment(department).active().build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employees eligible for payroll
+   */
+  async findEligibleForPayroll(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).employed().build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    const employees = await mongooseQuery.exec();
+    return employees.filter((emp) => canReceiveSalary(emp));
+  }
+  /**
+   * Create new employee
+   */
+  async create(params, options = {}) {
+    const employeeData = EmployeeFactory.create(params);
+    const [employee2] = await this.EmployeeModel.create([employeeData], {
+      session: options.session
+    });
+    logger.info("Employee created", {
+      employeeId: employee2.employeeId,
+      organizationId: employee2.organizationId.toString()
+    });
+    return employee2;
+  }
+  /**
+   * Update employee status
+   */
+  async updateStatus(employeeId, status, context = {}, options = {}) {
+    const employee2 = await this.findById(employeeId, options);
+    if (!employee2) {
+      throw new Error("Employee not found");
+    }
+    employee2.status = status;
+    await employee2.save({ session: options.session });
+    logger.info("Employee status updated", {
+      employeeId: employee2.employeeId,
+      newStatus: status
+    });
+    return employee2;
+  }
+  /**
+   * Update employee compensation
+   * 
+   * NOTE: This merges the compensation fields rather than replacing the entire object.
+   * To update allowances/deductions, use addAllowance/removeAllowance methods.
+   */
+  async updateCompensation(employeeId, compensation, options = {}) {
+    const currentEmployee = await this.EmployeeModel.findById(toObjectId(employeeId)).session(options.session || null);
+    if (!currentEmployee) {
+      throw new Error("Employee not found");
+    }
+    const updateFields = {
+      "compensation.lastModified": /* @__PURE__ */ new Date()
+    };
+    if (compensation.baseAmount !== void 0) {
+      updateFields["compensation.baseAmount"] = compensation.baseAmount;
+    }
+    if (compensation.currency !== void 0) {
+      updateFields["compensation.currency"] = compensation.currency;
+    }
+    if (compensation.frequency !== void 0) {
+      updateFields["compensation.frequency"] = compensation.frequency;
+    }
+    if (compensation.effectiveFrom !== void 0) {
+      updateFields["compensation.effectiveFrom"] = compensation.effectiveFrom;
+    }
+    const employee2 = await this.EmployeeModel.findByIdAndUpdate(
+      toObjectId(employeeId),
+      { $set: updateFields },
+      { new: true, runValidators: true, session: options.session }
+    );
+    if (!employee2) {
+      throw new Error("Employee not found");
+    }
+    return employee2;
+  }
+  /**
+   * Get employee statistics for organization
+   */
+  async getEmployeeStats(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    const employees = await mongooseQuery.exec();
+    return {
+      total: employees.length,
+      active: employees.filter(isActive).length,
+      employed: employees.filter(isEmployed).length,
+      canReceiveSalary: employees.filter(canReceiveSalary).length,
+      byStatus: this.groupByStatus(employees),
+      byDepartment: this.groupByDepartment(employees)
+    };
+  }
+  /**
+   * Group employees by status
+   */
+  groupByStatus(employees) {
+    return employees.reduce(
+      (acc, emp) => {
+        acc[emp.status] = (acc[emp.status] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Group employees by department
+   */
+  groupByDepartment(employees) {
+    return employees.reduce(
+      (acc, emp) => {
+        const dept = emp.department || "unassigned";
+        acc[dept] = (acc[dept] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Check if employee is active
+   */
+  isActive(employee2) {
+    return isActive(employee2);
+  }
+  /**
+   * Check if employee is employed
+   */
+  isEmployed(employee2) {
+    return isEmployed(employee2);
+  }
+  /**
+   * Check if employee can receive salary
+   */
+  canReceiveSalary(employee2) {
+    return canReceiveSalary(employee2);
+  }
+};
+
+// src/services/payroll.service.ts
+var PayrollService = class {
+  constructor(PayrollModel, employeeService) {
+    this.PayrollModel = PayrollModel;
+    this.employeeService = employeeService;
+  }
+  /**
+   * Find payroll by ID
+   */
+  async findById(payrollId, options = {}) {
+    let query = this.PayrollModel.findById(toObjectId(payrollId));
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    return query.exec();
+  }
+  /**
+   * Find payrolls by employee
+   */
+  async findByEmployee(employeeId, organizationId, options = {}) {
+    const query = payroll().forEmployee(employeeId).forOrganization(organizationId).build();
+    let mongooseQuery = this.PayrollModel.find(query).sort({ "period.year": -1, "period.month": -1 }).limit(options.limit || 12);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find payrolls for a period
+   */
+  async findForPeriod(organizationId, month, year, options = {}) {
+    const query = payroll().forOrganization(organizationId).forPeriod(month, year).build();
+    let mongooseQuery = this.PayrollModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find pending payrolls
+   */
+  async findPending(organizationId, month, year, options = {}) {
+    const query = payroll().forOrganization(organizationId).forPeriod(month, year).pending().build();
+    let mongooseQuery = this.PayrollModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find payroll by employee and period
+   */
+  async findByEmployeeAndPeriod(employeeId, organizationId, month, year, options = {}) {
+    const query = payroll().forEmployee(employeeId).forOrganization(organizationId).forPeriod(month, year).build();
+    let mongooseQuery = this.PayrollModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Create payroll record
+   */
+  async create(data, options = {}) {
+    const [payroll3] = await this.PayrollModel.create([data], {
+      session: options.session
+    });
+    logger.info("Payroll record created", {
+      payrollId: payroll3._id.toString(),
+      employeeId: payroll3.employeeId.toString()
+    });
+    return payroll3;
+  }
+  /**
+   * Generate payroll for employee
+   */
+  async generateForEmployee(employeeId, organizationId, month, year, options = {}) {
+    const employee2 = await this.employeeService.findById(employeeId, options);
+    if (!employee2) {
+      throw new Error("Employee not found");
+    }
+    if (!canReceiveSalary(employee2)) {
+      throw new Error("Employee not eligible for payroll");
+    }
+    const existing = await this.findByEmployeeAndPeriod(
+      employeeId,
+      organizationId,
+      month,
+      year,
+      options
+    );
+    if (existing) {
+      throw new Error("Payroll already exists for this period");
+    }
+    const payrollData = PayrollFactory.create({
+      employeeId,
+      organizationId,
+      baseAmount: employee2.compensation.baseAmount,
+      allowances: employee2.compensation.allowances || [],
+      deductions: employee2.compensation.deductions || [],
+      period: { month, year },
+      metadata: { currency: employee2.compensation.currency }
+    });
+    return this.create(payrollData, options);
+  }
+  /**
+   * Generate batch payroll
+   */
+  async generateBatch(organizationId, month, year, options = {}) {
+    const employees = await this.employeeService.findEligibleForPayroll(
+      organizationId,
+      options
+    );
+    if (employees.length === 0) {
+      return {
+        success: true,
+        generated: 0,
+        skipped: 0,
+        payrolls: [],
+        message: "No eligible employees"
+      };
+    }
+    const existingPayrolls = await this.findForPeriod(
+      organizationId,
+      month,
+      year,
+      options
+    );
+    const existingEmployeeIds = new Set(
+      existingPayrolls.map((p) => p.employeeId.toString())
+    );
+    const eligibleEmployees = employees.filter(
+      (emp) => !existingEmployeeIds.has(emp._id.toString())
+    );
+    if (eligibleEmployees.length === 0) {
+      return {
+        success: true,
+        generated: 0,
+        skipped: employees.length,
+        payrolls: [],
+        message: "Payrolls already exist for all employees"
+      };
+    }
+    const payrollsData = BatchPayrollFactory.createBatch(eligibleEmployees, {
+      month,
+      year,
+      organizationId
+    });
+    const created = await this.PayrollModel.insertMany(payrollsData, {
+      session: options.session
+    });
+    logger.info("Batch payroll generated", {
+      organizationId: organizationId.toString(),
+      month,
+      year,
+      count: created.length
+    });
+    return {
+      success: true,
+      generated: created.length,
+      skipped: existingEmployeeIds.size,
+      payrolls: created,
+      message: `Generated ${created.length} payrolls`
+    };
+  }
+  /**
+   * Mark payroll as paid
+   */
+  async markAsPaid(payrollId, paymentDetails = {}, options = {}) {
+    const payroll3 = await this.findById(payrollId, options);
+    if (!payroll3) {
+      throw new Error("Payroll not found");
+    }
+    if (payroll3.status === "paid") {
+      throw new Error("Payroll already paid");
+    }
+    const payrollObj = payroll3.toObject();
+    const updatedData = PayrollFactory.markAsPaid(payrollObj, paymentDetails);
+    const updated = await this.PayrollModel.findByIdAndUpdate(
+      payrollId,
+      updatedData,
+      { new: true, runValidators: true, session: options.session }
+    );
+    if (!updated) {
+      throw new Error("Failed to update payroll");
+    }
+    logger.info("Payroll marked as paid", {
+      payrollId: payrollId.toString()
+    });
+    return updated;
+  }
+  /**
+   * Mark payroll as processed
+   */
+  async markAsProcessed(payrollId, options = {}) {
+    const payroll3 = await this.findById(payrollId, options);
+    if (!payroll3) {
+      throw new Error("Payroll not found");
+    }
+    const payrollObj = payroll3.toObject();
+    const updatedData = PayrollFactory.markAsProcessed(payrollObj);
+    const updated = await this.PayrollModel.findByIdAndUpdate(
+      payrollId,
+      updatedData,
+      { new: true, runValidators: true, session: options.session }
+    );
+    if (!updated) {
+      throw new Error("Failed to update payroll");
+    }
+    return updated;
+  }
+  /**
+   * Calculate period summary
+   */
+  async calculatePeriodSummary(organizationId, month, year, options = {}) {
+    const payrolls = await this.findForPeriod(organizationId, month, year, options);
+    const summary = BatchPayrollFactory.calculateTotalPayroll(payrolls);
+    return {
+      period: { month, year },
+      ...summary,
+      byStatus: this.groupByStatus(payrolls)
+    };
+  }
+  /**
+   * Get employee payroll history
+   */
+  async getEmployeePayrollHistory(employeeId, organizationId, limit = 12, options = {}) {
+    return this.findByEmployee(employeeId, organizationId, { ...options, limit });
+  }
+  /**
+   * Get overview stats
+   */
+  async getOverviewStats(organizationId, options = {}) {
+    const { month, year } = getCurrentPeriod();
+    const result = await this.calculatePeriodSummary(organizationId, month, year, options);
+    return {
+      currentPeriod: result.period,
+      count: result.count,
+      totalGross: result.totalGross,
+      totalNet: result.totalNet,
+      totalAllowances: result.totalAllowances,
+      totalDeductions: result.totalDeductions,
+      byStatus: result.byStatus
+    };
+  }
+  /**
+   * Group payrolls by status
+   */
+  groupByStatus(payrolls) {
+    return payrolls.reduce(
+      (acc, payroll3) => {
+        acc[payroll3.status] = (acc[payroll3.status] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+  }
+};
+
+// src/services/compensation.service.ts
+var CompensationService = class {
+  constructor(EmployeeModel) {
+    this.EmployeeModel = EmployeeModel;
+  }
+  /**
+   * Get employee compensation
+   */
+  async getEmployeeCompensation(employeeId, options = {}) {
+    let query = this.EmployeeModel.findById(toObjectId(employeeId));
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    const employee2 = await query.exec();
+    if (!employee2) {
+      throw new Error("Employee not found");
+    }
+    return employee2.compensation;
+  }
+  /**
+   * Calculate compensation breakdown
+   */
+  async calculateBreakdown(employeeId, options = {}) {
+    const compensation = await this.getEmployeeCompensation(employeeId, options);
+    return CompensationFactory.calculateBreakdown(compensation);
+  }
+  /**
+   * Update base amount
+   */
+  async updateBaseAmount(employeeId, newAmount, effectiveFrom = /* @__PURE__ */ new Date(), options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    const updatedCompensation = CompensationFactory.updateBaseAmount(
+      employee2.compensation,
+      newAmount,
+      effectiveFrom
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Compensation base amount updated", {
+      employeeId: employee2.employeeId,
+      newAmount
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Apply salary increment
+   */
+  async applyIncrement(employeeId, params, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    const previousAmount = employee2.compensation.baseAmount;
+    const updatedCompensation = CompensationFactory.applyIncrement(
+      employee2.compensation,
+      params
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Salary increment applied", {
+      employeeId: employee2.employeeId,
+      previousAmount,
+      newAmount: updatedCompensation.baseAmount,
+      percentage: params.percentage
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Add allowance
+   */
+  async addAllowance(employeeId, allowance, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    const updatedCompensation = CompensationFactory.addAllowance(
+      employee2.compensation,
+      allowance
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Allowance added", {
+      employeeId: employee2.employeeId,
+      type: allowance.type,
+      value: allowance.value
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Remove allowance
+   */
+  async removeAllowance(employeeId, allowanceType, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    const updatedCompensation = CompensationFactory.removeAllowance(
+      employee2.compensation,
+      allowanceType
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Allowance removed", {
+      employeeId: employee2.employeeId,
+      type: allowanceType
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Add deduction
+   */
+  async addDeduction(employeeId, deduction, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    const updatedCompensation = CompensationFactory.addDeduction(
+      employee2.compensation,
+      deduction
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Deduction added", {
+      employeeId: employee2.employeeId,
+      type: deduction.type,
+      value: deduction.value
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Remove deduction
+   */
+  async removeDeduction(employeeId, deductionType, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    const updatedCompensation = CompensationFactory.removeDeduction(
+      employee2.compensation,
+      deductionType
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Deduction removed", {
+      employeeId: employee2.employeeId,
+      type: deductionType
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Set standard compensation
+   */
+  async setStandardCompensation(employeeId, baseAmount, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, options);
+    employee2.compensation = CompensationPresets.standard(baseAmount);
+    await employee2.save({ session: options.session });
+    logger.info("Standard compensation set", {
+      employeeId: employee2.employeeId,
+      baseAmount
+    });
+    return this.calculateBreakdown(employeeId, options);
+  }
+  /**
+   * Compare compensation between two employees
+   */
+  async compareCompensation(employeeId1, employeeId2, options = {}) {
+    const breakdown1 = await this.calculateBreakdown(employeeId1, options);
+    const breakdown2 = await this.calculateBreakdown(employeeId2, options);
+    return {
+      employee1: breakdown1,
+      employee2: breakdown2,
+      difference: {
+        base: breakdown2.baseAmount - breakdown1.baseAmount,
+        gross: breakdown2.grossAmount - breakdown1.grossAmount,
+        net: breakdown2.netAmount - breakdown1.netAmount
+      },
+      ratio: {
+        base: breakdown1.baseAmount > 0 ? breakdown2.baseAmount / breakdown1.baseAmount : 0,
+        gross: breakdown1.grossAmount > 0 ? breakdown2.grossAmount / breakdown1.grossAmount : 0,
+        net: breakdown1.netAmount > 0 ? breakdown2.netAmount / breakdown1.netAmount : 0
+      }
+    };
+  }
+  /**
+   * Get department compensation stats
+   */
+  async getDepartmentCompensationStats(organizationId, department, options = {}) {
+    let query = this.EmployeeModel.find({
+      organizationId: toObjectId(organizationId),
+      department,
+      status: { $in: ["active", "on_leave"] }
+    });
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    const employees = await query.exec();
+    const breakdowns = employees.map(
+      (emp) => CompensationFactory.calculateBreakdown(emp.compensation)
+    );
+    const totals = breakdowns.reduce(
+      (acc, breakdown) => ({
+        totalBase: acc.totalBase + breakdown.baseAmount,
+        totalGross: acc.totalGross + breakdown.grossAmount,
+        totalNet: acc.totalNet + breakdown.netAmount
+      }),
+      { totalBase: 0, totalGross: 0, totalNet: 0 }
+    );
+    const count = employees.length || 1;
+    return {
+      department,
+      employeeCount: employees.length,
+      ...totals,
+      averageBase: Math.round(totals.totalBase / count),
+      averageGross: Math.round(totals.totalGross / count),
+      averageNet: Math.round(totals.totalNet / count)
+    };
+  }
+  /**
+   * Get organization compensation stats
+   */
+  async getOrganizationCompensationStats(organizationId, options = {}) {
+    let query = this.EmployeeModel.find({
+      organizationId: toObjectId(organizationId),
+      status: { $in: ["active", "on_leave"] }
+    });
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    const employees = await query.exec();
+    const breakdowns = employees.map(
+      (emp) => CompensationFactory.calculateBreakdown(emp.compensation)
+    );
+    const totals = breakdowns.reduce(
+      (acc, breakdown) => ({
+        totalBase: acc.totalBase + breakdown.baseAmount,
+        totalGross: acc.totalGross + breakdown.grossAmount,
+        totalNet: acc.totalNet + breakdown.netAmount
+      }),
+      { totalBase: 0, totalGross: 0, totalNet: 0 }
+    );
+    const byDepartment = {};
+    employees.forEach((emp, i) => {
+      const dept = emp.department || "unassigned";
+      if (!byDepartment[dept]) {
+        byDepartment[dept] = { count: 0, totalNet: 0 };
+      }
+      byDepartment[dept].count++;
+      byDepartment[dept].totalNet += breakdowns[i].netAmount;
+    });
+    const count = employees.length || 1;
+    return {
+      employeeCount: employees.length,
+      ...totals,
+      averageBase: Math.round(totals.totalBase / count),
+      averageGross: Math.round(totals.totalGross / count),
+      averageNet: Math.round(totals.totalNet / count),
+      byDepartment
+    };
+  }
+  /**
+   * Find employee helper
+   */
+  async findEmployee(employeeId, options = {}) {
+    let query = this.EmployeeModel.findById(toObjectId(employeeId));
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    const employee2 = await query.exec();
+    if (!employee2) {
+      throw new Error("Employee not found");
+    }
+    return employee2;
+  }
+};
+
+// src/attendance.ts
+async function getAttendance(AttendanceModel, params) {
+  const record = await AttendanceModel.findOne({
+    tenantId: params.organizationId,
+    targetId: params.employeeId,
+    targetModel: "Employee",
+    year: params.year,
+    month: params.month
+  }).lean();
+  if (!record) return null;
+  const fullDays = record.fullDaysCount || 0;
+  const halfDays = (record.halfDaysCount || 0) * 0.5;
+  const paidLeave = record.paidLeaveDaysCount || 0;
+  const actualDays = Math.round(fullDays + halfDays + paidLeave);
+  const absentDays = Math.max(0, params.expectedDays - actualDays);
+  const overtimeDays = record.overtimeDaysCount || 0;
+  return {
+    expectedDays: params.expectedDays,
+    actualDays,
+    absentDays,
+    overtimeDays
+  };
+}
+async function batchGetAttendance(AttendanceModel, params) {
+  const records = await AttendanceModel.find({
+    tenantId: params.organizationId,
+    targetId: { $in: params.employeeIds },
+    targetModel: "Employee",
+    year: params.year,
+    month: params.month
+  }).lean();
+  const map2 = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const fullDays = record.fullDaysCount || 0;
+    const halfDays = (record.halfDaysCount || 0) * 0.5;
+    const paidLeave = record.paidLeaveDaysCount || 0;
+    const actualDays = Math.round(fullDays + halfDays + paidLeave);
+    map2.set(record.targetId.toString(), {
+      expectedDays: params.expectedDays,
+      actualDays
+    });
+  }
+  return map2;
+}
+function createHolidaySchema(options = {}) {
+  const fields = {
+    date: { type: Date, required: true, index: true },
+    name: { type: String, required: true },
+    type: {
+      type: String,
+      enum: ["public", "company", "religious"],
+      default: "company"
+    },
+    paid: { type: Boolean, default: true }
+  };
+  if (!options.singleTenant) {
+    fields.organizationId = {
+      type: Schema.Types.ObjectId,
+      ref: "Organization",
+      required: true,
+      index: true
+    };
+  }
+  const schema = new Schema(fields, { timestamps: true });
+  if (!options.singleTenant) {
+    schema.index({ organizationId: 1, date: 1 });
+  } else {
+    schema.index({ date: 1 });
+  }
+  return schema;
+}
+async function getHolidays(HolidayModel, params) {
+  const query = {
+    date: { $gte: params.startDate, $lte: params.endDate }
+  };
+  if (params.organizationId) {
+    query.organizationId = params.organizationId;
+  }
+  const holidays = await HolidayModel.find(query).select("date").lean();
+  return holidays.map((h) => h.date);
+}
+
+// src/index.ts
+var index_default = payroll2;
+
+export { ALLOWANCE_TYPE, BatchPayrollFactory, CompensationBuilder, CompensationFactory, CompensationService, Container, DEDUCTION_TYPE, DEPARTMENT, DuplicatePayrollError, EMPLOYEE_STATUS, EMPLOYMENT_TYPE, EmployeeBuilder, EmployeeFactory, EmployeeNotFoundError, EmployeeQueryBuilder, EmployeeService, EmployeeTerminatedError, HRM_CONFIG, HRM_TRANSACTION_CATEGORIES, NotEligibleError, NotInitializedError, PAYMENT_FREQUENCY, PAYROLL_STATUS, Payroll, PayrollBuilder, PayrollError, PayrollFactory, PayrollQueryBuilder, PayrollService, PluginManager, QueryBuilder, TERMINATION_REASON, ValidationError, addDays, addMonths, addYears, allowanceSchema, applyPercentage, bankDetailsSchema, batchGetAttendance, calculateGross, calculateNet, calculateProRating, calculateTax, canReceiveSalary, compensationSchema, compose, createEventBus, createHolidaySchema, createPayrollInstance, createValidator, deductionSchema, index_default as default, determineOrgRole, diffInDays, diffInMonths, disableLogging, employee, employeePlugin, employmentFields, employmentHistorySchema, enableLogging, endOfMonth, endOfYear, err, formatDateForDB, getAttendance, getCurrentPeriod, getHolidays, getLogger, getPayPeriod, getPayroll, getPayrollRecordModel, getWorkingDaysInMonth, inRange, initializeContainer, isActive, isDateInRange, isEmployed, isErr, isLoggingEnabled, isOk, isOnProbation, isTerminated, logger, map, mapErr, max, mergeConfig, min, ok, oneOf, payroll, payroll2 as payrollInstance, payrollRecordSchema, payrollStatsSchema, pipe, required, resetPayroll, setLogger, startOfMonth, startOfYear, sum, sumAllowances, sumBy, sumDeductions, toObjectId, unwrap, unwrapOr, workScheduleSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map