@classytic/payroll 2.0.0 → 2.3.0

package/dist/utils/index.d.ts

@@ -1,5 +1,6 @@
-import { o as Logger, $ as PayPeriodInfo, a0 as ProRatingResult, y as Allowance, z as Deduction, C as Compensation, F as CompensationBreakdownResult, a1 as TaxCalculationResult, G as EmployeeStatus, a2 as EmployeeValidationResult, Q as BankDetails, t as EmploymentType, O as ObjectIdLike, s as Department, K as PayrollStatus } from '../types-BSYyX2KJ.js';
+import { C as Logger, aT as PayPeriodInfo, N as Allowance, Q as Deduction, X as Compensation, aO as CompensationBreakdownResult, aU as ProRatingResult, aV as TaxCalculationResult, aK as EmployeeStatus, V as BankDetails, F as EmploymentType, aW as EmployeeValidationResult, O as ObjectIdLike, I as Department, aX as PayrollStatus } from '../types-BN3K_Uhr.js';
 import { Types } from 'mongoose';
+export { C as ContainerLike, a as DEFAULT_CARRY_OVER, D as DEFAULT_LEAVE_ALLOCATIONS, E as EmployeeIdMode, z as EmployeeIdType, A as EmployeeQueryFilter, R as ResolveOrganizationIdParams, S as SecureEmployeeLookupOptions, l as accrueLeaveToBalance, k as calculateCarryOver, c as calculateLeaveDays, f as calculateUnpaidLeaveDeduction, s as detectEmployeeIdType, n as employeeExistsSecure, m as findEmployeeSecure, o as findEmployeesSecure, y as formatEmployeeId, d as getAvailableDays, g as getLeaveBalance, b as getLeaveBalances, e as getLeaveSummary, j as getUnpaidLeaveDays, h as hasLeaveBalance, i as initializeLeaveBalances, x as isObjectIdEmployeeId, w as isStringEmployeeId, _ as leaveUtils, u as normalizeEmployeeId, p as proRateAllocation, r as requireOrganizationId, q as resolveOrganizationId, t as tryResolveOrganizationId, v as validateOrganizationId } from '../employee-identity-DXhgOgXE.js';
 
 /**
  * @classytic/payroll - Logger
@@ -685,6 +686,22 @@ declare class EmployeeQueryBuilder extends QueryBuilder {
      * Filter by user
      */
     forUser(userId: ObjectIdLike): this;
+    /**
+     * Filter by employeeId (human-readable ID)
+     */
+    forEmployeeId(employeeId: string): this;
+    /**
+     * Filter by email (for guest employees)
+     */
+    forEmail(email: string): this;
+    /**
+     * Filter guest employees (no userId)
+     */
+    guestEmployees(): this;
+    /**
+     * Filter user-linked employees (has userId)
+     */
+    userLinkedEmployees(): this;
     /**
      * Filter by status(es)
      */
@@ -741,8 +758,11 @@ declare class PayrollQueryBuilder extends QueryBuilder {
     forOrganization(organizationId: ObjectIdLike): this;
     /**
      * Filter by employee
+     *
+     * Note: PayrollRecord.employeeId is always ObjectId _id
+     * If passing a string business ID, resolve to _id first
      */
-    forEmployee(employeeId: ObjectIdLike): this;
+    forEmployee(employeeId: ObjectIdLike | string): this;
     /**
      * Filter by period
      */

package/dist/utils/index.js

@@ -804,6 +804,30 @@ var EmployeeQueryBuilder = class extends QueryBuilder {
   forUser(userId) {
     return this.where("userId", toObjectId(userId));
   }
+  /**
+   * Filter by employeeId (human-readable ID)
+   */
+  forEmployeeId(employeeId) {
+    return this.where("employeeId", employeeId);
+  }
+  /**
+   * Filter by email (for guest employees)
+   */
+  forEmail(email) {
+    return this.where("email", email.toLowerCase().trim());
+  }
+  /**
+   * Filter guest employees (no userId)
+   */
+  guestEmployees() {
+    return this.where("userId", null);
+  }
+  /**
+   * Filter user-linked employees (has userId)
+   */
+  userLinkedEmployees() {
+    return this.where("userId", { $ne: null });
+  }
   /**
    * Filter by status(es)
    */
@@ -889,6 +913,9 @@ var PayrollQueryBuilder = class extends QueryBuilder {
   }
   /**
    * Filter by employee
+   *
+   * Note: PayrollRecord.employeeId is always ObjectId _id
+   * If passing a string business ID, resolve to _id first
    */
   forEmployee(employeeId) {
     return this.where("employeeId", toObjectId(employeeId));
@@ -1041,6 +1068,448 @@ var query_builders_default = {
   unwindStage
 };
 
-export { EmployeeQueryBuilder, PayrollQueryBuilder, QueryBuilder, addDays, addMonths, addYears, applyPercentage, applyProRating, applyTaxBrackets, buildAggregationPipeline, buildEmployeeQuery, buildPayrollQuery, calculateAllowanceAmount, calculateAllowances, calculateCompensationBreakdown, calculateDailyRate, calculateDeductionAmount, calculateDeductions, calculateGross, calculateHourlyRate, calculateNet, calculateOvertime, calculatePercentage, calculateProRatedSalary, calculateProRating, calculateProbationEnd, calculateTax, calculateTotalCompensation, calculateYearsOfService, calculation_default as calculationUtils, canReceiveSalary, canUpdateEmployment, compose, composeValidators, createAllowanceCalculator, createChildLogger, createDeductionCalculator, createQueryBuilder, createSilentLogger, createValidator, date_default as dateUtils, daysBetween, diffInDays, diffInMonths, diffInYears, disableLogging, employee, enableLogging, endOfDay, endOfMonth, endOfYear, formatDateForDB, formatPeriod, getCurrentPeriod, getDayName, getDayOfWeek, getDaysInMonth, getLogger, getMonthName, getPayPeriod, getPayPeriodDateRange, getShortMonthName, getWorkingDaysInMonth, groupStage, hasCompensation, hasCompletedProbation, hasRequiredFields, inRange, isActive, isDateInRange, isEligibleForBonus, isEligibleForPayroll, isEmployed, isInProbation, isInRange, isLoggingEnabled, isOnLeave, isOnProbation, isPositive, isSuspended, isTerminated, isValidBankDetails, isValidCompensation, isValidEmploymentType, isValidObjectId, isValidStatus, isWeekday, isWeekend, limitStage, logger, lookupStage, matchStage, max, maxValue, min, minValue, monthsBetween, oneOf, parseDBDate, parsePeriod, payroll, pipe, projectStage, query_builders_default as queryBuilders, required, resetLogger, roundTo, safeToObjectId, setLogger, skipStage, sortStage, startOfDay, startOfMonth, startOfYear, subDays, subMonths, sum, sumAllowances, sumBy, sumDeductions, toObjectId, unwindStage, validation_default as validationUtils };
+// src/utils/leave.ts
+var DEFAULT_LEAVE_ALLOCATIONS = {
+  annual: 20,
+  sick: 10,
+  unpaid: 0,
+  // Unlimited
+  maternity: 90,
+  paternity: 10,
+  bereavement: 5,
+  compensatory: 0,
+  other: 0
+};
+var DEFAULT_CARRY_OVER = {
+  annual: 5,
+  sick: 0,
+  unpaid: 0,
+  maternity: 0,
+  paternity: 0,
+  bereavement: 0,
+  compensatory: 5,
+  other: 0
+};
+function calculateLeaveDays(startDate, endDate, options = {}) {
+  const {
+    workingDays = [1, 2, 3, 4, 5],
+    // Mon-Fri by default
+    holidays = [],
+    includeEndDate = true
+  } = options;
+  const holidaySet = new Set(holidays.map((d) => new Date(d).toDateString()));
+  let count = 0;
+  const current = new Date(startDate);
+  current.setHours(0, 0, 0, 0);
+  const end = new Date(endDate);
+  end.setHours(0, 0, 0, 0);
+  if (!includeEndDate) {
+    end.setDate(end.getDate() - 1);
+  }
+  while (current <= end) {
+    const isWorkDay = workingDays.includes(current.getDay());
+    const isHoliday = holidaySet.has(current.toDateString());
+    if (isWorkDay && !isHoliday) {
+      count++;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  return count;
+}
+function hasLeaveBalance(employee2, type, days, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  if (type === "unpaid") return true;
+  const balance = getLeaveBalance(employee2, type, year);
+  if (!balance) return false;
+  const available = balance.allocated + balance.carriedOver - balance.used - balance.pending;
+  return available >= days;
+}
+function getLeaveBalance(employee2, type, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  return employee2.leaveBalances?.find((b) => b.type === type && b.year === year);
+}
+function getLeaveBalances(employee2, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  return (employee2.leaveBalances || []).filter((b) => b.year === year);
+}
+function getAvailableDays(employee2, type, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  if (type === "unpaid") return Infinity;
+  const balance = getLeaveBalance(employee2, type, year);
+  if (!balance) return 0;
+  return Math.max(
+    0,
+    balance.allocated + balance.carriedOver - balance.used - balance.pending
+  );
+}
+function getLeaveSummary(employee2, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  const balances = getLeaveBalances(employee2, year);
+  const byType = {};
+  let totalAllocated = 0;
+  let totalUsed = 0;
+  let totalPending = 0;
+  for (const balance of balances) {
+    const available = Math.max(
+      0,
+      balance.allocated + balance.carriedOver - balance.used - balance.pending
+    );
+    byType[balance.type] = {
+      allocated: balance.allocated + balance.carriedOver,
+      used: balance.used,
+      pending: balance.pending,
+      available
+    };
+    totalAllocated += balance.allocated + balance.carriedOver;
+    totalUsed += balance.used;
+    totalPending += balance.pending;
+  }
+  return {
+    year,
+    balances,
+    totalAllocated,
+    totalUsed,
+    totalPending,
+    totalAvailable: Math.max(0, totalAllocated - totalUsed - totalPending),
+    byType
+  };
+}
+function initializeLeaveBalances(hireDate, config = {}, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  const {
+    defaultAllocations = DEFAULT_LEAVE_ALLOCATIONS,
+    proRateNewHires = true,
+    fiscalYearStartMonth = 1
+  } = config;
+  const fiscalYearStart = new Date(year, fiscalYearStartMonth - 1, 1);
+  const fiscalYearEnd = new Date(year + 1, fiscalYearStartMonth - 1, 0);
+  let prorationRatio = 1;
+  if (proRateNewHires && hireDate > fiscalYearStart) {
+    const totalDays = diffInDays2(fiscalYearStart, fiscalYearEnd);
+    const remainingDays = diffInDays2(hireDate, fiscalYearEnd);
+    prorationRatio = Math.max(0, Math.min(1, remainingDays / totalDays));
+  }
+  const balances = [];
+  for (const [type, allocation] of Object.entries(defaultAllocations)) {
+    if (allocation > 0) {
+      balances.push({
+        type,
+        allocated: Math.round(allocation * prorationRatio),
+        used: 0,
+        pending: 0,
+        carriedOver: 0,
+        year
+      });
+    }
+  }
+  return balances;
+}
+function proRateAllocation(fullAllocation, hireDate, fiscalYearStartMonth = 1, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  const fiscalYearStart = new Date(year, fiscalYearStartMonth - 1, 1);
+  if (hireDate <= fiscalYearStart) {
+    return fullAllocation;
+  }
+  const fiscalYearEnd = new Date(year + 1, fiscalYearStartMonth - 1, 0);
+  const totalDays = diffInDays2(fiscalYearStart, fiscalYearEnd);
+  const remainingDays = Math.max(0, diffInDays2(hireDate, fiscalYearEnd));
+  return Math.round(fullAllocation * remainingDays / totalDays);
+}
+function calculateUnpaidLeaveDeduction(baseSalary, unpaidDays, workingDaysInMonth) {
+  if (unpaidDays <= 0 || workingDaysInMonth <= 0) return 0;
+  const dailyRate = baseSalary / workingDaysInMonth;
+  return Math.round(dailyRate * unpaidDays);
+}
+function getUnpaidLeaveDays(leaveRequests, status = "approved") {
+  return leaveRequests.filter((r) => r.type === "unpaid" && r.status === status).reduce((sum2, r) => sum2 + r.days, 0);
+}
+function calculateCarryOver(balances, maxCarryOver = DEFAULT_CARRY_OVER, newYearAllocations = DEFAULT_LEAVE_ALLOCATIONS) {
+  if (!balances.length) return [];
+  const currentYear = balances[0].year;
+  const newYear = currentYear + 1;
+  return balances.map((balance) => {
+    const available = balance.allocated + balance.carriedOver - balance.used - balance.pending;
+    const maxForType = maxCarryOver[balance.type] ?? 0;
+    const carryOver = maxForType > 0 ? Math.min(Math.max(0, available), maxForType) : 0;
+    return {
+      type: balance.type,
+      allocated: newYearAllocations[balance.type] ?? DEFAULT_LEAVE_ALLOCATIONS[balance.type] ?? 0,
+      used: 0,
+      pending: 0,
+      carriedOver: carryOver,
+      year: newYear
+    };
+  });
+}
+function accrueLeaveToBalance(balances, type, amount, year = (/* @__PURE__ */ new Date()).getFullYear()) {
+  const existingIdx = balances.findIndex((b) => b.type === type && b.year === year);
+  if (existingIdx >= 0) {
+    balances[existingIdx].allocated += amount;
+  } else {
+    balances.push({
+      type,
+      allocated: amount,
+      used: 0,
+      pending: 0,
+      carriedOver: 0,
+      year
+    });
+  }
+  return balances;
+}
+function diffInDays2(start, end) {
+  const startDate = new Date(start);
+  const endDate = new Date(end);
+  startDate.setHours(0, 0, 0, 0);
+  endDate.setHours(0, 0, 0, 0);
+  return Math.ceil((endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24));
+}
+var leave_default = {
+  DEFAULT_LEAVE_ALLOCATIONS,
+  DEFAULT_CARRY_OVER,
+  calculateLeaveDays,
+  hasLeaveBalance,
+  getLeaveBalance,
+  getLeaveBalances,
+  getAvailableDays,
+  getLeaveSummary,
+  initializeLeaveBalances,
+  proRateAllocation,
+  calculateUnpaidLeaveDeduction,
+  getUnpaidLeaveDays,
+  calculateCarryOver,
+  accrueLeaveToBalance
+};
+
+// src/errors/index.ts
+var PayrollError = class extends Error {
+  code;
+  status;
+  context;
+  timestamp;
+  /**
+   * Create a PayrollError.
+   *
+   * Supports BOTH constructor styles for backwards compatibility:
+   * - new PayrollError(message, code?, status?, context?)
+   * - new PayrollError(code, status, message, context?)
+   */
+  constructor(messageOrCode, codeOrStatus = "PAYROLL_ERROR", statusOrMessage = 500, context = {}) {
+    const isLegacySignature = typeof messageOrCode === "string" && typeof codeOrStatus === "string";
+    const message = isLegacySignature ? messageOrCode : statusOrMessage;
+    super(message);
+    this.name = this.constructor.name;
+    this.code = isLegacySignature ? codeOrStatus : messageOrCode;
+    this.status = isLegacySignature ? statusOrMessage : codeOrStatus;
+    this.context = context ?? {};
+    this.timestamp = /* @__PURE__ */ new Date();
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Convert error to JSON for API responses (ClockIn-compatible shape)
+   */
+  toJSON() {
+    return {
+      error: {
+        type: this.name,
+        code: this.code,
+        message: this.message,
+        status: this.status,
+        context: this.context,
+        timestamp: this.timestamp.toISOString()
+      }
+    };
+  }
+  /**
+   * Check if error is operational (expected) vs programmer error
+   */
+  isOperational() {
+    return true;
+  }
+};
+var EmployeeNotFoundError = class extends PayrollError {
+  constructor(employeeId, context) {
+    super(
+      employeeId ? `Employee not found: ${employeeId}` : "Employee not found",
+      "EMPLOYEE_NOT_FOUND",
+      404,
+      context ?? {}
+    );
+  }
+};
+
+// src/utils/employee-lookup.ts
+async function findEmployeeSecure(model, options) {
+  const {
+    organizationId,
+    _id,
+    employeeId,
+    employeeIdMode = "auto",
+    userId,
+    email,
+    session,
+    populate
+  } = options;
+  const query = {};
+  if (organizationId) {
+    query.organizationId = toObjectId(organizationId);
+  }
+  if (_id) {
+    query._id = toObjectId(_id);
+  } else if (employeeId !== void 0) {
+    const shouldTreatAsObjectId = employeeIdMode === "objectId" || employeeIdMode === "auto" && isValidObjectId(employeeId);
+    const shouldTreatAsBusinessId = employeeIdMode === "businessId" || employeeIdMode === "auto" && !isValidObjectId(employeeId);
+    if (shouldTreatAsObjectId) {
+      query._id = toObjectId(employeeId);
+    } else if (shouldTreatAsBusinessId) {
+      query.employeeId = employeeId;
+    }
+  } else if (userId) {
+    query.userId = toObjectId(userId);
+  } else if (email) {
+    query.email = email;
+  } else {
+    throw new Error(
+      "findEmployeeSecure requires at least one identifier: _id, employeeId, userId, or email"
+    );
+  }
+  let mongooseQuery = model.findOne(query);
+  if (session) {
+    mongooseQuery = mongooseQuery.session(session);
+  }
+  if (populate) {
+    const fields = Array.isArray(populate) ? populate : [populate];
+    for (const field of fields) {
+      mongooseQuery = mongooseQuery.populate(field);
+    }
+  }
+  const employee2 = await mongooseQuery;
+  if (!employee2) {
+    const identifier = _id ? `_id=${_id}` : employeeId ? `employeeId=${employeeId}` : userId ? `userId=${userId}` : `email=${email}`;
+    throw new EmployeeNotFoundError(
+      `Employee not found: ${identifier}${organizationId ? ` in organization ${organizationId}` : ""}`
+    );
+  }
+  return employee2;
+}
+async function employeeExistsSecure(model, options) {
+  try {
+    await findEmployeeSecure(model, options);
+    return true;
+  } catch (error) {
+    if (error instanceof EmployeeNotFoundError) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function findEmployeesSecure(model, options) {
+  const { organizationId, filter = {}, session, limit, skip, sort } = options;
+  const query = {
+    organizationId: toObjectId(organizationId),
+    ...filter
+  };
+  let mongooseQuery = model.find(query);
+  if (session) {
+    mongooseQuery = mongooseQuery.session(session);
+  }
+  if (limit) {
+    mongooseQuery = mongooseQuery.limit(limit);
+  }
+  if (skip) {
+    mongooseQuery = mongooseQuery.skip(skip);
+  }
+  if (sort) {
+    mongooseQuery = mongooseQuery.sort(sort);
+  }
+  return mongooseQuery;
+}
+function requireOrganizationId(organizationId, operation) {
+  if (!organizationId) {
+    throw new Error(
+      `${operation} requires organizationId. In multi-tenant mode, you must explicitly provide organizationId. In single-tenant mode, ensure autoInject is enabled in configuration.`
+    );
+  }
+}
+
+// src/utils/org-resolution.ts
+function resolveOrganizationId(params) {
+  const { explicit, context, container, operation } = params;
+  if (explicit) {
+    return toObjectId(explicit);
+  }
+  if (context?.organizationId) {
+    return toObjectId(context.organizationId);
+  }
+  if (container?.isSingleTenant()) {
+    const singleTenantConfig = container.getSingleTenantConfig();
+    if (singleTenantConfig?.autoInject) {
+      const orgId = container.getOrganizationId();
+      if (orgId) {
+        return toObjectId(orgId);
+      }
+    }
+  }
+  const operationName = operation || "Operation";
+  throw new Error(
+    `${operationName} requires organizationId. Options:
+1. Provide it explicitly in parameters
+2. Pass it via context (from middleware/auth)
+3. Enable single-tenant mode with autoInject: true
+
+Example (multi-tenant):
+  await payroll.${operation || "method"}({ organizationId: org._id, ... });
+
+Example (single-tenant):
+  const payroll = createPayrollInstance()
+    .withModels({ ... })
+    .forSingleTenant({ organizationId: myOrg._id, autoInject: true })
+    .build();`
+  );
+}
+function validateOrganizationId(organizationId, operation) {
+  if (!organizationId) {
+    throw new Error(
+      `${operation} requires organizationId. Provide it explicitly, via context, or enable single-tenant mode with autoInject.`
+    );
+  }
+  try {
+    return toObjectId(organizationId);
+  } catch (error) {
+    throw new Error(
+      `${operation} received invalid organizationId: ${organizationId}. Must be a valid ObjectId, ObjectId string, or ObjectId-like object.`
+    );
+  }
+}
+function tryResolveOrganizationId(params) {
+  try {
+    return resolveOrganizationId(params);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/employee-identity.ts
+function detectEmployeeIdType(employeeId) {
+  if (isValidObjectId(employeeId)) {
+    return "objectId";
+  }
+  return "string";
+}
+function normalizeEmployeeId(employeeId) {
+  const idType = detectEmployeeIdType(employeeId);
+  if (idType === "objectId") {
+    return toObjectId(employeeId);
+  }
+  return employeeId;
+}
+function isStringEmployeeId(value) {
+  return typeof value === "string" && !isValidObjectId(value);
+}
+function isObjectIdEmployeeId(value) {
+  return isValidObjectId(value);
+}
+function formatEmployeeId(employeeId) {
+  const idType = detectEmployeeIdType(employeeId);
+  if (idType === "objectId") {
+    return `_id=${toObjectId(employeeId).toString()}`;
+  }
+  return `employeeId=${employeeId}`;
+}
+
+export { DEFAULT_CARRY_OVER, DEFAULT_LEAVE_ALLOCATIONS, EmployeeQueryBuilder, PayrollQueryBuilder, QueryBuilder, accrueLeaveToBalance, addDays, addMonths, addYears, applyPercentage, applyProRating, applyTaxBrackets, buildAggregationPipeline, buildEmployeeQuery, buildPayrollQuery, calculateAllowanceAmount, calculateAllowances, calculateCarryOver, calculateCompensationBreakdown, calculateDailyRate, calculateDeductionAmount, calculateDeductions, calculateGross, calculateHourlyRate, calculateLeaveDays, calculateNet, calculateOvertime, calculatePercentage, calculateProRatedSalary, calculateProRating, calculateProbationEnd, calculateTax, calculateTotalCompensation, calculateUnpaidLeaveDeduction, calculateYearsOfService, calculation_default as calculationUtils, canReceiveSalary, canUpdateEmployment, compose, composeValidators, createAllowanceCalculator, createChildLogger, createDeductionCalculator, createQueryBuilder, createSilentLogger, createValidator, date_default as dateUtils, daysBetween, detectEmployeeIdType, diffInDays, diffInMonths, diffInYears, disableLogging, employee, employeeExistsSecure, enableLogging, endOfDay, endOfMonth, endOfYear, findEmployeeSecure, findEmployeesSecure, formatDateForDB, formatEmployeeId, formatPeriod, getAvailableDays, getCurrentPeriod, getDayName, getDayOfWeek, getDaysInMonth, getLeaveBalance, getLeaveBalances, getLeaveSummary, getLogger, getMonthName, getPayPeriod, getPayPeriodDateRange, getShortMonthName, getUnpaidLeaveDays, getWorkingDaysInMonth, groupStage, hasCompensation, hasCompletedProbation, hasLeaveBalance, hasRequiredFields, inRange, initializeLeaveBalances, isActive, isDateInRange, isEligibleForBonus, isEligibleForPayroll, isEmployed, isInProbation, isInRange, isLoggingEnabled, isObjectIdEmployeeId, isOnLeave, isOnProbation, isPositive, isStringEmployeeId, isSuspended, isTerminated, isValidBankDetails, isValidCompensation, isValidEmploymentType, isValidObjectId, isValidStatus, isWeekday, isWeekend, leave_default as leaveUtils, limitStage, logger, lookupStage, matchStage, max, maxValue, min, minValue, monthsBetween, normalizeEmployeeId, oneOf, parseDBDate, parsePeriod, payroll, pipe, proRateAllocation, projectStage, query_builders_default as queryBuilders, requireOrganizationId, required, resetLogger, resolveOrganizationId, roundTo, safeToObjectId, setLogger, skipStage, sortStage, startOfDay, startOfMonth, startOfYear, subDays, subMonths, sum, sumAllowances, sumBy, sumDeductions, toObjectId, tryResolveOrganizationId, unwindStage, validateOrganizationId, validation_default as validationUtils };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map