@classytic/payroll 1.0.2 → 2.3.0

package/dist/shift-compliance/index.js

@@ -0,0 +1,1479 @@
+import { Schema } from 'mongoose';
+
+// src/shift-compliance/calculators/late-penalty.ts
+function calculateFlatPenalty(occurrenceCount, flatAmount) {
+  return {
+    amount: occurrenceCount * flatAmount,
+    occurrences: occurrenceCount
+  };
+}
+function calculatePerMinutePenalty(totalMinutesLate, perMinuteRate) {
+  return {
+    amount: Math.round(totalMinutesLate * perMinuteRate),
+    minutes: totalMinutesLate
+  };
+}
+function calculatePercentagePenalty(occurrenceCount, percentageRate, dailyWage) {
+  const penaltyPerOccurrence = Math.round(dailyWage * percentageRate / 100);
+  return {
+    amount: occurrenceCount * penaltyPerOccurrence,
+    percentage: percentageRate
+  };
+}
+function findTier(occurrenceNumber, tiers) {
+  for (const tier of tiers) {
+    if (tier.to === void 0 && occurrenceNumber >= tier.from) {
+      return tier;
+    }
+    if (tier.to !== void 0 && occurrenceNumber >= tier.from && occurrenceNumber <= tier.to) {
+      return tier;
+    }
+  }
+  return null;
+}
+function calculateTieredPenaltyForOccurrence(occurrenceNumber, tiers) {
+  const tier = findTier(occurrenceNumber, tiers);
+  if (!tier) {
+    return { amount: 0, tier: null, warning: false };
+  }
+  if (tier.warning) {
+    return { amount: 0, tier, warning: true };
+  }
+  return { amount: tier.penalty, tier, warning: false };
+}
+function calculateTieredPenalty(newOccurrences, currentOccurrenceCount, tiers) {
+  let totalPenalty = 0;
+  const breakdown = [];
+  for (let i = 0; i < newOccurrences; i++) {
+    const occurrenceNumber = currentOccurrenceCount + i + 1;
+    const result = calculateTieredPenaltyForOccurrence(occurrenceNumber, tiers);
+    totalPenalty += result.amount;
+    breakdown.push({
+      occurrence: occurrenceNumber,
+      penalty: result.amount,
+      tier: result.tier ? tiers.indexOf(result.tier) : void 0,
+      warning: result.warning
+    });
+  }
+  return { amount: totalPenalty, breakdown };
+}
+function calculateLatePenalty(input) {
+  const {
+    policy,
+    occurrences = [],
+    lateCount = 0,
+    totalLateMinutes = 0,
+    dailyWage = 0,
+    currentOccurrenceCount = 0
+  } = input;
+  if (!policy.enabled) {
+    return {
+      amount: 0,
+      occurrences: 0,
+      breakdown: []
+    };
+  }
+  const penalizableOccurrences = occurrences.filter(
+    (occ) => occ.minutesLate > policy.gracePeriod
+  );
+  const penalizableCount = penalizableOccurrences.length || Math.max(0, lateCount);
+  const penalizableMinutes = penalizableOccurrences.reduce((sum, occ) => sum + Math.max(0, occ.minutesLate - policy.gracePeriod), 0) || totalLateMinutes;
+  if (penalizableCount === 0) {
+    return {
+      amount: 0,
+      occurrences: 0,
+      breakdown: occurrences.map((occ) => ({
+        date: occ.date,
+        minutesLate: occ.minutesLate,
+        penaltyAmount: 0,
+        waived: true,
+        reason: "Within grace period"
+      }))
+    };
+  }
+  let totalPenalty = 0;
+  let tierBreakdown = [];
+  switch (policy.mode) {
+    case "flat":
+      if (policy.flatAmount) {
+        const result = calculateFlatPenalty(penalizableCount, policy.flatAmount);
+        totalPenalty = result.amount;
+      }
+      break;
+    case "per-minute":
+      if (policy.perMinuteRate) {
+        const result = calculatePerMinutePenalty(penalizableMinutes, policy.perMinuteRate);
+        totalPenalty = result.amount;
+      }
+      break;
+    case "percentage":
+      if (policy.percentageRate && dailyWage > 0) {
+        const result = calculatePercentagePenalty(penalizableCount, policy.percentageRate, dailyWage);
+        totalPenalty = result.amount;
+      }
+      break;
+    case "tiered":
+      if (policy.tiers && policy.tiers.length > 0) {
+        const result = calculateTieredPenalty(penalizableCount, currentOccurrenceCount, policy.tiers);
+        totalPenalty = result.amount;
+        tierBreakdown = result.breakdown;
+      }
+      break;
+  }
+  if (policy.maxPenaltyAmount) {
+    totalPenalty = Math.min(totalPenalty, policy.maxPenaltyAmount.amount);
+  }
+  const breakdown = penalizableOccurrences.map((occ, index) => {
+    const tierInfo = tierBreakdown[index];
+    const penaltyPerOccurrence = policy.mode === "tiered" && tierInfo ? tierInfo.penalty : totalPenalty / penalizableCount;
+    return {
+      date: occ.date,
+      minutesLate: occ.minutesLate,
+      penaltyAmount: Math.round(penaltyPerOccurrence),
+      tier: tierInfo?.tier,
+      waived: false
+    };
+  });
+  return {
+    amount: Math.round(totalPenalty),
+    occurrences: penalizableCount,
+    breakdown
+  };
+}
+
+// src/shift-compliance/calculators/overtime.ts
+function calculateDailyOvertime(hoursWorked, threshold, multiplier, hourlyRate) {
+  const overtimeHours = Math.max(0, hoursWorked - threshold);
+  if (overtimeHours === 0) {
+    return { amount: 0, overtimeHours: 0 };
+  }
+  const extraMultiplier = multiplier - 1;
+  const bonus = Math.round(overtimeHours * hourlyRate * extraMultiplier);
+  return { amount: bonus, overtimeHours };
+}
+function calculateWeeklyOvertime(hoursWorked, threshold, multiplier, hourlyRate) {
+  return calculateDailyOvertime(hoursWorked, threshold, multiplier, hourlyRate);
+}
+function calculateMonthlyOvertime(hoursWorked, threshold, multiplier, hourlyRate) {
+  return calculateDailyOvertime(hoursWorked, threshold, multiplier, hourlyRate);
+}
+function calculateWeekendPremium(hours, multiplier, hourlyRate, day) {
+  const extraMultiplier = multiplier - 1;
+  const bonus = Math.round(hours * hourlyRate * extraMultiplier);
+  return { amount: bonus, hours, day };
+}
+function calculateNightShiftDifferential(hours, multiplier, hourlyRate) {
+  const extraMultiplier = multiplier - 1;
+  const bonus = Math.round(hours * hourlyRate * extraMultiplier);
+  return { amount: bonus, hours };
+}
+function calculateOvertimeBonus(input) {
+  const {
+    policy,
+    occurrences = [],
+    overtimeHours = 0,
+    overtimeDays = 0,
+    hourlyRate
+  } = input;
+  if (!policy.enabled) {
+    return {
+      amount: 0,
+      hours: 0,
+      breakdown: []
+    };
+  }
+  let totalBonus = 0;
+  let totalHours = 0;
+  const breakdown = [];
+  if (occurrences.length > 0) {
+    for (const occ of occurrences) {
+      let bonus = 0;
+      const extraMultiplier = occ.multiplier - 1;
+      switch (occ.type) {
+        case "daily":
+        case "weekly":
+        case "monthly":
+          bonus = Math.round(occ.hours * hourlyRate * extraMultiplier);
+          break;
+        case "weekend-saturday":
+        case "weekend-sunday":
+          bonus = Math.round(occ.hours * hourlyRate * extraMultiplier);
+          break;
+        case "night-shift":
+          bonus = Math.round(occ.hours * hourlyRate * extraMultiplier);
+          break;
+      }
+      totalBonus += bonus;
+      totalHours += occ.hours;
+      breakdown.push({
+        date: occ.date,
+        type: occ.type,
+        hours: occ.hours,
+        rate: hourlyRate,
+        multiplier: occ.multiplier,
+        amount: bonus
+      });
+    }
+  } else {
+    const hours = overtimeHours || 0;
+    const days = overtimeDays || 0;
+    if (policy.mode === "daily" && policy.dailyThreshold && policy.dailyMultiplier) {
+      const hoursFromDays = days * policy.dailyThreshold;
+      const result = calculateDailyOvertime(
+        hoursFromDays + hours,
+        policy.dailyThreshold,
+        policy.dailyMultiplier,
+        hourlyRate
+      );
+      totalBonus = result.amount;
+      totalHours = result.overtimeHours;
+    } else if (policy.mode === "weekly" && policy.weeklyThreshold && policy.weeklyMultiplier) {
+      const result = calculateWeeklyOvertime(
+        hours,
+        policy.weeklyThreshold,
+        policy.weeklyMultiplier,
+        hourlyRate
+      );
+      totalBonus = result.amount;
+      totalHours = result.overtimeHours;
+    } else if (policy.mode === "monthly" && policy.monthlyThreshold && policy.monthlyMultiplier) {
+      const result = calculateMonthlyOvertime(
+        hours,
+        policy.monthlyThreshold,
+        policy.monthlyMultiplier,
+        hourlyRate
+      );
+      totalBonus = result.amount;
+      totalHours = result.overtimeHours;
+    }
+    if (totalBonus > 0) {
+      breakdown.push({
+        date: /* @__PURE__ */ new Date(),
+        type: policy.mode,
+        hours: totalHours,
+        rate: hourlyRate,
+        multiplier: policy.dailyMultiplier || policy.weeklyMultiplier || policy.monthlyMultiplier || 1.5,
+        amount: totalBonus
+      });
+    }
+  }
+  return {
+    amount: Math.round(totalBonus),
+    hours: totalHours,
+    breakdown
+  };
+}
+
+// src/shift-compliance/calculators/index.ts
+function calculateShiftCompliance(input) {
+  const {
+    attendance,
+    policy,
+    dailyWage,
+    hourlyRate,
+    currentOccurrenceCount = 0
+  } = input;
+  const latePenalty = calculateLatePenalty({
+    policy: policy.lateArrival,
+    occurrences: attendance.lateOccurrences,
+    lateCount: attendance.lateArrivals,
+    totalLateMinutes: attendance.totalLateMinutes,
+    dailyWage,
+    currentOccurrenceCount
+  });
+  const earlyDeparturePenalty = calculateLatePenalty({
+    policy: policy.earlyDeparture,
+    occurrences: attendance.earlyOccurrences?.map((occ) => ({
+      date: occ.date,
+      scheduledTime: occ.scheduledTime,
+      actualTime: occ.actualTime,
+      minutesLate: occ.minutesEarly
+      // Reuse "late" logic with "early" minutes
+    })),
+    lateCount: attendance.earlyDepartures,
+    totalLateMinutes: attendance.totalEarlyMinutes,
+    dailyWage,
+    currentOccurrenceCount
+  });
+  const overtimeBonus = calculateOvertimeBonus({
+    policy: policy.overtime,
+    occurrences: attendance.overtimeOccurrences,
+    overtimeHours: attendance.overtimeHours,
+    overtimeDays: attendance.overtimeDays,
+    hourlyRate
+  });
+  const totalPenalties = latePenalty.amount + earlyDeparturePenalty.amount;
+  const totalBonuses = overtimeBonus.amount;
+  const netAdjustment = totalBonuses - totalPenalties;
+  const totalOccurrences = latePenalty.occurrences + earlyDeparturePenalty.occurrences;
+  const complianceScore = calculateComplianceScore(totalOccurrences);
+  const isAtRisk = determineRiskStatus(totalOccurrences, policy);
+  return {
+    latePenalty,
+    earlyDeparturePenalty,
+    overtimeBonus,
+    totalPenalties,
+    totalBonuses,
+    netAdjustment,
+    complianceScore,
+    occurrenceCount: totalOccurrences,
+    isAtRisk,
+    policyId: policy.id,
+    policyName: policy.name
+  };
+}
+function calculateComplianceScore(totalOccurrences, attendance) {
+  if (totalOccurrences === 0) {
+    return 100;
+  }
+  return Math.max(0, 100 - totalOccurrences * 10);
+}
+function determineRiskStatus(totalOccurrences, policy) {
+  if (policy.lateArrival.mode === "tiered" && policy.lateArrival.tiers) {
+    const lastTier = policy.lateArrival.tiers[policy.lateArrival.tiers.length - 1];
+    if (lastTier && lastTier.from && totalOccurrences >= lastTier.from) {
+      return true;
+    }
+  }
+  return totalOccurrences >= 7;
+}
+
+// src/shift-compliance/config.ts
+var DEFAULT_ATTENDANCE_POLICY = {
+  lateArrival: {
+    enabled: true,
+    gracePeriod: 10,
+    // 10 minutes grace
+    mode: "tiered",
+    tiers: [
+      { from: 1, to: 2, penalty: 0, warning: true },
+      // 1st-2nd: warning
+      { from: 3, to: 4, penalty: 25 },
+      // 3rd-4th: $25
+      { from: 5, penalty: 50 }
+      // 5th+: $50
+    ],
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  earlyDeparture: {
+    enabled: true,
+    gracePeriod: 10,
+    mode: "tiered",
+    tiers: [
+      { from: 1, to: 2, penalty: 0, warning: true },
+      { from: 3, to: 4, penalty: 30 },
+      { from: 5, penalty: 60 }
+    ],
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  overtime: {
+    enabled: true,
+    mode: "daily",
+    dailyThreshold: 8,
+    dailyMultiplier: 1.5,
+    weeklyThreshold: 40,
+    weeklyMultiplier: 1.5
+  },
+  clockRounding: {
+    enabled: false,
+    roundTo: 15,
+    mode: "nearest"
+  }
+};
+var MANUFACTURING_POLICY = {
+  lateArrival: {
+    enabled: true,
+    gracePeriod: 0,
+    // No grace period
+    mode: "flat",
+    flatAmount: 100,
+    // $100 per occurrence
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  earlyDeparture: {
+    enabled: true,
+    gracePeriod: 0,
+    mode: "flat",
+    flatAmount: 150,
+    // Higher penalty for early departure
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  overtime: {
+    enabled: true,
+    mode: "daily",
+    dailyThreshold: 8,
+    dailyMultiplier: 1.5,
+    weeklyThreshold: 40,
+    weeklyMultiplier: 2
+    // Double time for weekly OT
+  },
+  clockRounding: {
+    enabled: true,
+    roundTo: 15,
+    mode: "down"
+    // Round down (favor employer)
+  }
+};
+var RETAIL_POLICY = {
+  lateArrival: {
+    enabled: true,
+    gracePeriod: 5,
+    mode: "flat",
+    flatAmount: 25,
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "monthly"
+  },
+  earlyDeparture: {
+    enabled: true,
+    gracePeriod: 5,
+    mode: "flat",
+    flatAmount: 25,
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "monthly"
+  },
+  overtime: {
+    enabled: true,
+    mode: "weekly",
+    weeklyThreshold: 40,
+    weeklyMultiplier: 1.5,
+    weekendPremium: {
+      saturday: 1.5,
+      // Time and half on Saturday
+      sunday: 2
+      // Double time on Sunday
+    }
+  },
+  clockRounding: {
+    enabled: true,
+    roundTo: 5,
+    mode: "nearest"
+  }
+};
+var OFFICE_POLICY = {
+  lateArrival: {
+    enabled: true,
+    gracePeriod: 15,
+    // 15 minutes grace
+    mode: "tiered",
+    tiers: [
+      { from: 1, to: 3, penalty: 0, warning: true },
+      // 1st-3rd: warning only
+      { from: 4, to: 5, penalty: 20 },
+      // 4th-5th: $20
+      { from: 6, penalty: 40 }
+      // 6th+: $40
+    ],
+    maxPenaltiesPerPeriod: {
+      count: 3,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  earlyDeparture: {
+    enabled: false,
+    // Often not tracked in office environments
+    gracePeriod: 30,
+    mode: "flat",
+    flatAmount: 0
+  },
+  overtime: {
+    enabled: true,
+    mode: "weekly",
+    weeklyThreshold: 40,
+    weeklyMultiplier: 1.5
+  },
+  clockRounding: {
+    enabled: false,
+    // No rounding for office workers
+    roundTo: 15,
+    mode: "nearest"
+  }
+};
+var HEALTHCARE_POLICY = {
+  lateArrival: {
+    enabled: true,
+    gracePeriod: 5,
+    mode: "flat",
+    flatAmount: 50,
+    maxPenaltiesPerPeriod: {
+      count: 3,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  earlyDeparture: {
+    enabled: true,
+    gracePeriod: 5,
+    mode: "flat",
+    flatAmount: 75,
+    // Higher penalty due to patient care
+    maxPenaltiesPerPeriod: {
+      count: 3,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "quarterly"
+  },
+  overtime: {
+    enabled: true,
+    mode: "daily",
+    dailyThreshold: 8,
+    dailyMultiplier: 1.5,
+    weekendPremium: {
+      saturday: 1.5,
+      sunday: 2
+    },
+    nightShiftDifferential: {
+      startHour: 22,
+      // 10pm
+      endHour: 6,
+      // 6am
+      multiplier: 1.3
+      // 30% premium
+    }
+  },
+  clockRounding: {
+    enabled: true,
+    roundTo: 15,
+    mode: "nearest"
+  }
+};
+var HOSPITALITY_POLICY = {
+  lateArrival: {
+    enabled: true,
+    gracePeriod: 5,
+    mode: "percentage",
+    percentageRate: 1,
+    // 1% of daily wage per occurrence
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "monthly"
+  },
+  earlyDeparture: {
+    enabled: true,
+    gracePeriod: 5,
+    mode: "percentage",
+    percentageRate: 1.5,
+    // 1.5% of daily wage
+    maxPenaltiesPerPeriod: {
+      count: 5,
+      period: "monthly"
+    },
+    resetOccurrenceCount: "monthly"
+  },
+  overtime: {
+    enabled: true,
+    mode: "weekly",
+    weeklyThreshold: 40,
+    weeklyMultiplier: 1.5,
+    weekendPremium: {
+      saturday: 1.25,
+      sunday: 1.5
+    },
+    nightShiftDifferential: {
+      startHour: 22,
+      endHour: 6,
+      multiplier: 1.2
+    }
+  },
+  clockRounding: {
+    enabled: true,
+    roundTo: 10,
+    mode: "nearest"
+  }
+};
+function createPolicyFromPreset(preset, overrides) {
+  let basePolicy;
+  switch (preset) {
+    case "manufacturing":
+      basePolicy = MANUFACTURING_POLICY;
+      break;
+    case "retail":
+      basePolicy = RETAIL_POLICY;
+      break;
+    case "office":
+      basePolicy = OFFICE_POLICY;
+      break;
+    case "healthcare":
+      basePolicy = HEALTHCARE_POLICY;
+      break;
+    case "hospitality":
+      basePolicy = HOSPITALITY_POLICY;
+      break;
+    default:
+      basePolicy = DEFAULT_ATTENDANCE_POLICY;
+  }
+  return {
+    ...basePolicy,
+    name: overrides?.name || `${preset.charAt(0).toUpperCase() + preset.slice(1)} Policy`,
+    effectiveFrom: overrides?.effectiveFrom || /* @__PURE__ */ new Date(),
+    active: overrides?.active ?? true,
+    ...overrides
+  };
+}
+
+// src/shift-compliance/builders.ts
+var LatePolicyBuilder = class {
+  policy = {
+    enabled: true,
+    gracePeriod: 0
+  };
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Enable this policy
+   */
+  enable() {
+    this.policy.enabled = true;
+    return this;
+  }
+  /**
+   * Disable this policy
+   */
+  disable() {
+    this.policy.enabled = false;
+    return this;
+  }
+  /**
+   * Set grace period in minutes (how many minutes late before penalty applies)
+   */
+  gracePeriod(minutes) {
+    this.policy.gracePeriod = minutes;
+    return this;
+  }
+  /**
+   * Use flat penalty mode (same penalty for each occurrence)
+   *
+   * @param amount - Penalty amount per occurrence
+   */
+  flatPenalty(amount) {
+    this.policy.mode = "flat";
+    this.policy.flatAmount = amount;
+    delete this.policy.perMinuteRate;
+    delete this.policy.percentageRate;
+    delete this.policy.tiers;
+    return this;
+  }
+  /**
+   * Use per-minute penalty mode (penalty based on minutes late)
+   *
+   * @param rate - Penalty per minute late
+   */
+  perMinutePenalty(rate) {
+    this.policy.mode = "per-minute";
+    this.policy.perMinuteRate = rate;
+    delete this.policy.flatAmount;
+    delete this.policy.percentageRate;
+    delete this.policy.tiers;
+    return this;
+  }
+  /**
+   * Use percentage penalty mode (percentage of daily wage)
+   *
+   * @param percentage - Percentage of daily wage (e.g., 2 for 2%)
+   */
+  percentagePenalty(percentage) {
+    this.policy.mode = "percentage";
+    this.policy.percentageRate = percentage;
+    delete this.policy.flatAmount;
+    delete this.policy.perMinuteRate;
+    delete this.policy.tiers;
+    return this;
+  }
+  /**
+   * Start building tiered penalty (progressive discipline)
+   *
+   * @example
+   * ```typescript
+   * .tieredPenalty()
+   *   .tier(1, 2).warning()
+   *   .tier(3, 4).penalty(25)
+   *   .tier(5).penalty(50)
+   * .end()
+   * ```
+   */
+  tieredPenalty() {
+    this.policy.mode = "tiered";
+    this.policy.tiers = [];
+    delete this.policy.flatAmount;
+    delete this.policy.perMinuteRate;
+    delete this.policy.percentageRate;
+    return new TieredPenaltyBuilder(this);
+  }
+  /**
+   * Set maximum penalties per period (caps total penalties)
+   *
+   * @param count - Max number of penalties
+   * @param period - Period type ('daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly')
+   */
+  maxPenalties(count, period) {
+    this.policy.maxPenaltiesPerPeriod = { count, period };
+    return this;
+  }
+  /**
+   * Set when to reset occurrence counter
+   *
+   * @param period - Reset period ('monthly' | 'quarterly' | 'yearly')
+   */
+  resetOccurrences(period) {
+    this.policy.resetOccurrenceCount = period;
+    return this;
+  }
+  /**
+   * Add a custom tier (advanced usage)
+   */
+  addTier(tier) {
+    if (!this.policy.tiers) {
+      this.policy.tiers = [];
+    }
+    this.policy.tiers.push(tier);
+    return this;
+  }
+  /**
+   * Finish building this policy and return to parent builder
+   */
+  end() {
+    if (!this.parent) {
+      throw new Error("Cannot call end() without parent builder");
+    }
+    return this.parent;
+  }
+  /**
+   * Build the policy (for standalone usage)
+   */
+  build() {
+    if (this.policy.mode === void 0) {
+      throw new Error("Penalty mode is required. Use flatPenalty(), perMinutePenalty(), percentagePenalty(), or tieredPenalty()");
+    }
+    if (this.policy.mode === "flat" && this.policy.flatAmount === void 0) {
+      throw new Error("flatAmount is required for flat penalty mode");
+    }
+    if (this.policy.mode === "per-minute" && this.policy.perMinuteRate === void 0) {
+      throw new Error("perMinuteRate is required for per-minute penalty mode");
+    }
+    if (this.policy.mode === "percentage" && this.policy.percentageRate === void 0) {
+      throw new Error("percentageRate is required for percentage penalty mode");
+    }
+    if (this.policy.mode === "tiered" && (!this.policy.tiers || this.policy.tiers.length === 0)) {
+      throw new Error("At least one tier is required for tiered penalty mode");
+    }
+    return this.policy;
+  }
+  /** @internal */
+  _getPolicy() {
+    return this.policy;
+  }
+};
+var TieredPenaltyBuilder = class {
+  tiers = [];
+  parent;
+  currentTier = {};
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Start a new tier
+   *
+   * @param from - Starting occurrence number (1-indexed)
+   * @param to - Ending occurrence number (optional, omit for open-ended tier)
+   */
+  tier(from, to) {
+    if (Object.keys(this.currentTier).length > 0) {
+      this.saveTier();
+    }
+    this.currentTier = { from, to };
+    return this;
+  }
+  /**
+   * Set this tier as warning only (no financial penalty)
+   */
+  warning() {
+    this.currentTier.penalty = 0;
+    this.currentTier.warning = true;
+    return this;
+  }
+  /**
+   * Set penalty amount for this tier
+   */
+  penalty(amount) {
+    this.currentTier.penalty = amount;
+    this.currentTier.warning = false;
+    return this;
+  }
+  /**
+   * Finish building tiers and return to parent
+   */
+  end() {
+    if (Object.keys(this.currentTier).length > 0) {
+      this.saveTier();
+    }
+    if (this.parent instanceof LatePolicyBuilder) {
+      this.parent.policy.tiers = this.tiers;
+    }
+    return this.parent;
+  }
+  saveTier() {
+    if (this.currentTier.from === void 0) {
+      throw new Error('Tier must have a "from" value. Use .tier(from, to?)');
+    }
+    if (this.currentTier.penalty === void 0) {
+      throw new Error("Tier must have a penalty or be marked as warning. Use .penalty(amount) or .warning()");
+    }
+    this.tiers.push(this.currentTier);
+    this.currentTier = {};
+  }
+};
+var OvertimePolicyBuilder = class {
+  policy = {
+    enabled: true
+  };
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Enable overtime calculations
+   */
+  enable() {
+    this.policy.enabled = true;
+    return this;
+  }
+  /**
+   * Disable overtime calculations
+   */
+  disable() {
+    this.policy.enabled = false;
+    return this;
+  }
+  /**
+   * Set overtime calculation mode
+   */
+  mode(mode) {
+    this.policy.mode = mode;
+    return this;
+  }
+  /**
+   * Set daily overtime threshold and multiplier
+   *
+   * @param hours - Hours threshold (e.g., 8)
+   * @param multiplier - Overtime multiplier (e.g., 1.5 for time-and-a-half)
+   */
+  dailyThreshold(hours, multiplier) {
+    this.policy.dailyThreshold = hours;
+    this.policy.dailyMultiplier = multiplier;
+    return this;
+  }
+  /**
+   * Set weekly overtime threshold and multiplier
+   *
+   * @param hours - Hours threshold (e.g., 40)
+   * @param multiplier - Overtime multiplier (e.g., 1.5 for time-and-a-half)
+   */
+  weeklyThreshold(hours, multiplier) {
+    this.policy.weeklyThreshold = hours;
+    this.policy.weeklyMultiplier = multiplier;
+    return this;
+  }
+  /**
+   * Set monthly overtime threshold and multiplier
+   *
+   * @param hours - Hours threshold (e.g., 160)
+   * @param multiplier - Overtime multiplier (e.g., 2.0 for double time)
+   */
+  monthlyThreshold(hours, multiplier) {
+    this.policy.monthlyThreshold = hours;
+    this.policy.monthlyMultiplier = multiplier;
+    return this;
+  }
+  /**
+   * Set weekend premium rates
+   *
+   * @param saturday - Saturday multiplier (e.g., 1.5)
+   * @param sunday - Sunday multiplier (e.g., 2.0)
+   */
+  weekendPremium(saturday, sunday) {
+    this.policy.weekendPremium = { saturday, sunday };
+    return this;
+  }
+  /**
+   * Set night shift differential
+   *
+   * @param startHour - Start hour (24-hour format, e.g., 22 for 10pm)
+   * @param endHour - End hour (24-hour format, e.g., 6 for 6am)
+   * @param multiplier - Night shift multiplier (e.g., 1.3 for 30% premium)
+   */
+  nightShiftDifferential(startHour, endHour, multiplier) {
+    this.policy.nightShiftDifferential = { startHour, endHour, multiplier };
+    return this;
+  }
+  /**
+   * Finish building this policy and return to parent builder
+   */
+  end() {
+    if (!this.parent) {
+      throw new Error("Cannot call end() without parent builder");
+    }
+    return this.parent;
+  }
+  /**
+   * Build the policy (for standalone usage)
+   */
+  build() {
+    if (this.policy.mode === void 0) {
+      throw new Error('Overtime mode is required. Use .mode("daily" | "weekly" | "monthly")');
+    }
+    if (this.policy.mode === "daily" && (this.policy.dailyThreshold === void 0 || this.policy.dailyMultiplier === void 0)) {
+      throw new Error("dailyThreshold and dailyMultiplier are required for daily mode. Use .dailyThreshold(hours, multiplier)");
+    }
+    if (this.policy.mode === "weekly" && (this.policy.weeklyThreshold === void 0 || this.policy.weeklyMultiplier === void 0)) {
+      throw new Error("weeklyThreshold and weeklyMultiplier are required for weekly mode. Use .weeklyThreshold(hours, multiplier)");
+    }
+    if (this.policy.mode === "monthly" && (this.policy.monthlyThreshold === void 0 || this.policy.monthlyMultiplier === void 0)) {
+      throw new Error("monthlyThreshold and monthlyMultiplier are required for monthly mode. Use .monthlyThreshold(hours, multiplier)");
+    }
+    return this.policy;
+  }
+  /** @internal */
+  _getPolicy() {
+    return this.policy;
+  }
+};
+var ClockRoundingPolicyBuilder = class {
+  policy = {
+    enabled: false
+  };
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Enable clock rounding
+   */
+  enable() {
+    this.policy.enabled = true;
+    return this;
+  }
+  /**
+   * Disable clock rounding
+   */
+  disable() {
+    this.policy.enabled = false;
+    return this;
+  }
+  /**
+   * Set rounding interval in minutes
+   *
+   * @param minutes - Round to nearest N minutes (e.g., 5, 10, 15)
+   */
+  roundTo(minutes) {
+    this.policy.roundTo = minutes;
+    return this;
+  }
+  /**
+   * Set rounding mode
+   *
+   * @param mode - 'up' (favor employee) | 'down' (favor employer) | 'nearest' (neutral)
+   */
+  roundingMode(mode) {
+    this.policy.mode = mode;
+    return this;
+  }
+  /**
+   * Finish building this policy and return to parent builder
+   */
+  end() {
+    if (!this.parent) {
+      throw new Error("Cannot call end() without parent builder");
+    }
+    return this.parent;
+  }
+  /**
+   * Build the policy (for standalone usage)
+   */
+  build() {
+    if (this.policy.enabled && (this.policy.roundTo === void 0 || this.policy.mode === void 0)) {
+      throw new Error("roundTo and mode are required when clock rounding is enabled");
+    }
+    return this.policy;
+  }
+  /** @internal */
+  _getPolicy() {
+    return this.policy;
+  }
+};
+var AttendancePolicyBuilder = class _AttendancePolicyBuilder {
+  policy = {
+    active: true,
+    effectiveFrom: /* @__PURE__ */ new Date()
+  };
+  lateArrivalBuilder;
+  earlyDepartureBuilder;
+  overtimeBuilder;
+  clockRoundingBuilder;
+  /**
+   * Create a new policy builder
+   */
+  static create() {
+    return new _AttendancePolicyBuilder();
+  }
+  /**
+   * Set policy name
+   */
+  named(name) {
+    this.policy.name = name;
+    return this;
+  }
+  /**
+   * Set policy description
+   */
+  description(description) {
+    this.policy.description = description;
+    return this;
+  }
+  /**
+   * Set organization ID (for multi-tenant systems)
+   */
+  organizationId(id) {
+    this.policy.organizationId = id;
+    return this;
+  }
+  /**
+   * Set policy ID (for updates)
+   */
+  id(id) {
+    this.policy.id = id;
+    return this;
+  }
+  /**
+   * Set effective from date
+   */
+  effectiveFrom(date) {
+    this.policy.effectiveFrom = date;
+    return this;
+  }
+  /**
+   * Set effective to date (when policy expires)
+   */
+  effectiveTo(date) {
+    this.policy.effectiveTo = date;
+    return this;
+  }
+  /**
+   * Set policy active status
+   */
+  active(active) {
+    this.policy.active = active;
+    return this;
+  }
+  /**
+   * Start building late arrival policy
+   */
+  lateArrival() {
+    if (!this.lateArrivalBuilder) {
+      this.lateArrivalBuilder = new LatePolicyBuilder(this);
+    }
+    return this.lateArrivalBuilder;
+  }
+  /**
+   * Start building early departure policy
+   */
+  earlyDeparture() {
+    if (!this.earlyDepartureBuilder) {
+      this.earlyDepartureBuilder = new LatePolicyBuilder(this);
+    }
+    return this.earlyDepartureBuilder;
+  }
+  /**
+   * Start building overtime policy
+   */
+  overtime() {
+    if (!this.overtimeBuilder) {
+      this.overtimeBuilder = new OvertimePolicyBuilder(this);
+    }
+    return this.overtimeBuilder;
+  }
+  /**
+   * Start building clock rounding policy
+   */
+  clockRounding() {
+    if (!this.clockRoundingBuilder) {
+      this.clockRoundingBuilder = new ClockRoundingPolicyBuilder(this);
+    }
+    return this.clockRoundingBuilder;
+  }
+  /**
+   * Build the complete attendance policy
+   */
+  build() {
+    if (!this.policy.name) {
+      throw new Error("Policy name is required. Use .named(name)");
+    }
+    if (this.lateArrivalBuilder) {
+      this.policy.lateArrival = this.lateArrivalBuilder.build();
+    } else {
+      throw new Error("Late arrival policy is required. Use .lateArrival()...end()");
+    }
+    if (this.earlyDepartureBuilder) {
+      this.policy.earlyDeparture = this.earlyDepartureBuilder.build();
+    } else {
+      throw new Error("Early departure policy is required. Use .earlyDeparture()...end()");
+    }
+    if (this.overtimeBuilder) {
+      this.policy.overtime = this.overtimeBuilder.build();
+    } else {
+      throw new Error("Overtime policy is required. Use .overtime()...end()");
+    }
+    if (this.clockRoundingBuilder) {
+      this.policy.clockRounding = this.clockRoundingBuilder.build();
+    }
+    return this.policy;
+  }
+};
+function createLatePolicyBuilder() {
+  return new LatePolicyBuilder();
+}
+function createOvertimePolicyBuilder() {
+  return new OvertimePolicyBuilder();
+}
+function createClockRoundingPolicyBuilder() {
+  return new ClockRoundingPolicyBuilder();
+}
+var PenaltyTierSchemaDefinition = {
+  from: {
+    type: Number,
+    required: true,
+    min: 1,
+    description: "Starting occurrence number (1-indexed)"
+  },
+  to: {
+    type: Number,
+    min: 1,
+    description: "Ending occurrence number (optional for open-ended tier)"
+  },
+  penalty: {
+    type: Number,
+    required: true,
+    min: 0,
+    description: "Penalty amount (0 for warnings)"
+  },
+  warning: {
+    type: Boolean,
+    default: false,
+    description: "Whether this is a warning-only tier"
+  }
+};
+var PenaltyTierSchema = new Schema(PenaltyTierSchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var MaxPenaltiesSchemaDefinition = {
+  count: {
+    type: Number,
+    required: true,
+    min: 1,
+    description: "Maximum number of penalties allowed in period"
+  },
+  period: {
+    type: String,
+    enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
+    required: true,
+    description: "Period type"
+  }
+};
+var MaxPenaltiesSchema = new Schema(MaxPenaltiesSchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var LateArrivalPolicySchemaDefinition = {
+  enabled: {
+    type: Boolean,
+    required: true,
+    default: true,
+    description: "Whether late arrival penalties are enabled"
+  },
+  gracePeriod: {
+    type: Number,
+    required: true,
+    min: 0,
+    max: 60,
+    default: 0,
+    description: "Grace period in minutes before penalty applies"
+  },
+  mode: {
+    type: String,
+    enum: ["flat", "per-minute", "percentage", "tiered"],
+    required: true,
+    description: "Penalty calculation mode"
+  },
+  flatAmount: {
+    type: Number,
+    min: 0,
+    description: "Flat penalty amount per occurrence (for flat mode)"
+  },
+  perMinuteRate: {
+    type: Number,
+    min: 0,
+    description: "Penalty per minute late (for per-minute mode)"
+  },
+  percentageRate: {
+    type: Number,
+    min: 0,
+    max: 100,
+    description: "Percentage of daily wage (for percentage mode)"
+  },
+  tiers: {
+    type: [PenaltyTierSchema],
+    description: "Penalty tiers for progressive discipline (for tiered mode)"
+  },
+  maxPenaltiesPerPeriod: {
+    type: MaxPenaltiesSchema,
+    description: "Maximum penalties allowed per period"
+  },
+  resetOccurrenceCount: {
+    type: String,
+    enum: ["monthly", "quarterly", "yearly"],
+    description: "When to reset occurrence counter"
+  }
+};
+var LateArrivalPolicySchema = new Schema(LateArrivalPolicySchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var EarlyDeparturePolicySchemaDefinition = LateArrivalPolicySchemaDefinition;
+var EarlyDeparturePolicySchema = new Schema(EarlyDeparturePolicySchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var WeekendPremiumSchemaDefinition = {
+  saturday: {
+    type: Number,
+    required: true,
+    min: 1,
+    description: "Saturday premium multiplier (e.g., 1.5 for time-and-a-half)"
+  },
+  sunday: {
+    type: Number,
+    required: true,
+    min: 1,
+    description: "Sunday premium multiplier (e.g., 2.0 for double time)"
+  }
+};
+var WeekendPremiumSchema = new Schema(WeekendPremiumSchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var NightShiftDifferentialSchemaDefinition = {
+  startHour: {
+    type: Number,
+    required: true,
+    min: 0,
+    max: 23,
+    description: "Night shift start hour (24-hour format, e.g., 22 for 10pm)"
+  },
+  endHour: {
+    type: Number,
+    required: true,
+    min: 0,
+    max: 23,
+    description: "Night shift end hour (24-hour format, e.g., 6 for 6am)"
+  },
+  multiplier: {
+    type: Number,
+    required: true,
+    min: 1,
+    description: "Night shift premium multiplier (e.g., 1.3 for 30% premium)"
+  }
+};
+var NightShiftDifferentialSchema = new Schema(NightShiftDifferentialSchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var OvertimePolicySchemaDefinition = {
+  enabled: {
+    type: Boolean,
+    required: true,
+    default: true,
+    description: "Whether overtime bonuses are enabled"
+  },
+  mode: {
+    type: String,
+    enum: ["daily", "weekly", "monthly"],
+    required: true,
+    description: "Overtime calculation mode"
+  },
+  dailyThreshold: {
+    type: Number,
+    min: 0,
+    description: "Daily overtime threshold in hours (for daily mode)"
+  },
+  dailyMultiplier: {
+    type: Number,
+    min: 1,
+    description: "Daily overtime pay multiplier (e.g., 1.5 for time-and-a-half)"
+  },
+  weeklyThreshold: {
+    type: Number,
+    min: 0,
+    description: "Weekly overtime threshold in hours (for weekly mode)"
+  },
+  weeklyMultiplier: {
+    type: Number,
+    min: 1,
+    description: "Weekly overtime pay multiplier"
+  },
+  monthlyThreshold: {
+    type: Number,
+    min: 0,
+    description: "Monthly overtime threshold in hours (for monthly mode)"
+  },
+  monthlyMultiplier: {
+    type: Number,
+    min: 1,
+    description: "Monthly overtime pay multiplier"
+  },
+  weekendPremium: {
+    type: WeekendPremiumSchema,
+    description: "Weekend premium rates"
+  },
+  nightShiftDifferential: {
+    type: NightShiftDifferentialSchema,
+    description: "Night shift differential rates"
+  }
+};
+var OvertimePolicySchema = new Schema(OvertimePolicySchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var ClockRoundingPolicySchemaDefinition = {
+  enabled: {
+    type: Boolean,
+    required: true,
+    default: false,
+    description: "Whether clock rounding is enabled"
+  },
+  roundTo: {
+    type: Number,
+    enum: [5, 10, 15],
+    description: "Round to nearest N minutes"
+  },
+  mode: {
+    type: String,
+    enum: ["up", "down", "nearest"],
+    description: "Rounding mode: up (favor employee), down (favor employer), nearest (neutral)"
+  }
+};
+var ClockRoundingPolicySchema = new Schema(ClockRoundingPolicySchemaDefinition, {
+  _id: false,
+  timestamps: false
+});
+var AttendancePolicySchemaDefinition = {
+  organizationId: {
+    type: Schema.Types.ObjectId,
+    index: true,
+    description: "Organization this policy belongs to (for multi-tenant)"
+  },
+  name: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 200,
+    description: "Policy name"
+  },
+  description: {
+    type: String,
+    trim: true,
+    maxlength: 1e3,
+    description: "Policy description"
+  },
+  lateArrival: {
+    type: LateArrivalPolicySchema,
+    required: true,
+    description: "Late arrival penalty policy"
+  },
+  earlyDeparture: {
+    type: EarlyDeparturePolicySchema,
+    required: true,
+    description: "Early departure penalty policy"
+  },
+  overtime: {
+    type: OvertimePolicySchema,
+    required: true,
+    description: "Overtime bonus policy"
+  },
+  clockRounding: {
+    type: ClockRoundingPolicySchema,
+    description: "Clock rounding policy (optional)"
+  },
+  effectiveFrom: {
+    type: Date,
+    required: true,
+    default: Date.now,
+    description: "When this policy becomes effective"
+  },
+  effectiveTo: {
+    type: Date,
+    default: null,
+    description: "When this policy expires (null for no expiration)"
+  },
+  active: {
+    type: Boolean,
+    required: true,
+    default: true,
+    index: true,
+    description: "Whether this policy is currently active"
+  }
+};
+var AttendancePolicySchema = new Schema(AttendancePolicySchemaDefinition, {
+  timestamps: true,
+  collection: "attendance_policies"
+});
+AttendancePolicySchema.index({ organizationId: 1, active: 1, effectiveFrom: -1 });
+AttendancePolicySchema.index({ effectiveFrom: 1, effectiveTo: 1 });
+AttendancePolicySchema.methods.isCurrentlyActive = function() {
+  if (!this.active) return false;
+  const now = /* @__PURE__ */ new Date();
+  if (this.effectiveFrom > now) return false;
+  if (this.effectiveTo && this.effectiveTo < now) return false;
+  return true;
+};
+AttendancePolicySchema.statics.findActiveForOrganization = function(organizationId, date = /* @__PURE__ */ new Date()) {
+  return this.findOne({
+    organizationId,
+    active: true,
+    effectiveFrom: { $lte: date },
+    $or: [
+      { effectiveTo: null },
+      { effectiveTo: { $gt: date } }
+    ]
+  }).sort({ effectiveFrom: -1 });
+};
+var schemas_default = AttendancePolicySchema;
+
+export { AttendancePolicyBuilder, AttendancePolicySchema, AttendancePolicySchemaDefinition, ClockRoundingPolicyBuilder, ClockRoundingPolicySchema, ClockRoundingPolicySchemaDefinition, DEFAULT_ATTENDANCE_POLICY, EarlyDeparturePolicySchema, EarlyDeparturePolicySchemaDefinition, HEALTHCARE_POLICY, HOSPITALITY_POLICY, LateArrivalPolicySchema, LateArrivalPolicySchemaDefinition, LatePolicyBuilder, MANUFACTURING_POLICY, MaxPenaltiesSchema, MaxPenaltiesSchemaDefinition, NightShiftDifferentialSchema, NightShiftDifferentialSchemaDefinition, OFFICE_POLICY, OvertimePolicyBuilder, OvertimePolicySchema, OvertimePolicySchemaDefinition, PenaltyTierSchema, PenaltyTierSchemaDefinition, RETAIL_POLICY, TieredPenaltyBuilder, WeekendPremiumSchema, WeekendPremiumSchemaDefinition, calculateDailyOvertime, calculateFlatPenalty, calculateLatePenalty, calculateMonthlyOvertime, calculateNightShiftDifferential, calculateOvertimeBonus, calculatePerMinutePenalty, calculatePercentagePenalty, calculateShiftCompliance, calculateTieredPenalty, calculateWeekendPremium, calculateWeeklyOvertime, createClockRoundingPolicyBuilder, createLatePolicyBuilder, createOvertimePolicyBuilder, createPolicyFromPreset, schemas_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map