@classytic/payroll 1.0.2 → 2.0.0

package/dist/utils/index.d.ts

@@ -0,0 +1,873 @@
+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 { Types } from 'mongoose';
+
+/**
+ * @classytic/payroll - Logger
+ *
+ * Pluggable logger abstraction
+ * Defaults to console, can be replaced with pino, winston, etc.
+ */
+
+/**
+ * Get the current logger instance
+ */
+declare function getLogger(): Logger;
+/**
+ * Set a custom logger instance
+ */
+declare function setLogger(logger: Logger): void;
+/**
+ * Reset to default console logger
+ */
+declare function resetLogger(): void;
+/**
+ * Create a child logger with prefix
+ */
+declare function createChildLogger(prefix: string): Logger;
+/**
+ * Create a silent logger (for testing)
+ */
+declare function createSilentLogger(): Logger;
+/**
+ * Enable logging globally
+ */
+declare function enableLogging(): void;
+/**
+ * Disable logging globally (useful for production)
+ */
+declare function disableLogging(): void;
+/**
+ * Check if logging is enabled
+ */
+declare function isLoggingEnabled(): boolean;
+/**
+ * Logger proxy that always delegates to currentLogger
+ * Respects global logging enabled/disabled state
+ */
+declare const logger: Logger;
+
+/**
+ * @classytic/payroll - Date Utilities
+ *
+ * Pure, composable, testable date operations
+ * No side effects, no mutations
+ */
+
+/**
+ * Add days to a date
+ */
+declare function addDays(date: Date, days: number): Date;
+/**
+ * Add months to a date
+ */
+declare function addMonths(date: Date, months: number): Date;
+/**
+ * Add years to a date
+ */
+declare function addYears(date: Date, years: number): Date;
+/**
+ * Subtract days from a date
+ */
+declare function subDays(date: Date, days: number): Date;
+/**
+ * Subtract months from a date
+ */
+declare function subMonths(date: Date, months: number): Date;
+/**
+ * Get the start of a month
+ */
+declare function startOfMonth(date: Date): Date;
+/**
+ * Get the end of a month
+ */
+declare function endOfMonth(date: Date): Date;
+/**
+ * Get the start of a year
+ */
+declare function startOfYear(date: Date): Date;
+/**
+ * Get the end of a year
+ */
+declare function endOfYear(date: Date): Date;
+/**
+ * Get the start of a day
+ */
+declare function startOfDay(date: Date): Date;
+/**
+ * Get the end of a day
+ */
+declare function endOfDay(date: Date): Date;
+/**
+ * Calculate difference in days between two dates
+ */
+declare function diffInDays(start: Date, end: Date): number;
+/**
+ * Calculate difference in months between two dates
+ */
+declare function diffInMonths(start: Date, end: Date): number;
+/**
+ * Calculate difference in years between two dates
+ */
+declare function diffInYears(start: Date, end: Date): number;
+declare const daysBetween: typeof diffInDays;
+declare const monthsBetween: typeof diffInMonths;
+/**
+ * Check if date is a weekday (Mon-Fri)
+ */
+declare function isWeekday(date: Date): boolean;
+/**
+ * Check if date is a weekend (Sat-Sun)
+ */
+declare function isWeekend(date: Date): boolean;
+/**
+ * Get day of week (0=Sunday, 6=Saturday)
+ */
+declare function getDayOfWeek(date: Date): number;
+/**
+ * Get day name
+ */
+declare function getDayName(date: Date): string;
+/**
+ * Get pay period for a given month and year
+ */
+declare function getPayPeriod(month: number, year: number): PayPeriodInfo;
+/**
+ * Get current pay period
+ */
+declare function getCurrentPeriod(date?: Date): {
+    year: number;
+    month: number;
+};
+/**
+ * Get working days in a month
+ */
+declare function getWorkingDaysInMonth(year: number, month: number): number;
+/**
+ * Get total days in a month
+ */
+declare function getDaysInMonth(year: number, month: number): number;
+/**
+ * Calculate probation end date
+ */
+declare function calculateProbationEnd(hireDate: Date, probationMonths: number): Date | null;
+/**
+ * Check if employee is on probation
+ */
+declare function isOnProbation(probationEndDate: Date | null | undefined, now?: Date): boolean;
+/**
+ * Calculate years of service
+ */
+declare function calculateYearsOfService(hireDate: Date, terminationDate?: Date | null): number;
+/**
+ * Check if a date is within a range
+ */
+declare function isDateInRange(date: Date, start: Date, end: Date): boolean;
+/**
+ * Get date range for a pay period
+ */
+declare function getPayPeriodDateRange(month: number, year: number): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Format date for database storage
+ */
+declare function formatDateForDB(date: Date): string;
+/**
+ * Parse date from database
+ */
+declare function parseDBDate(dateString: string): Date | null;
+/**
+ * Format period as string (e.g., "01/2025")
+ */
+declare function formatPeriod({ month, year }: {
+    month: number;
+    year: number;
+}): string;
+/**
+ * Parse period string back to object
+ */
+declare function parsePeriod(periodString: string): {
+    month: number;
+    year: number;
+};
+/**
+ * Format month name
+ */
+declare function getMonthName(month: number): string;
+/**
+ * Format short month name
+ */
+declare function getShortMonthName(month: number): string;
+declare const _default$3: {
+    addDays: typeof addDays;
+    addMonths: typeof addMonths;
+    addYears: typeof addYears;
+    subDays: typeof subDays;
+    subMonths: typeof subMonths;
+    startOfMonth: typeof startOfMonth;
+    endOfMonth: typeof endOfMonth;
+    startOfYear: typeof startOfYear;
+    endOfYear: typeof endOfYear;
+    startOfDay: typeof startOfDay;
+    endOfDay: typeof endOfDay;
+    diffInDays: typeof diffInDays;
+    diffInMonths: typeof diffInMonths;
+    diffInYears: typeof diffInYears;
+    daysBetween: typeof diffInDays;
+    monthsBetween: typeof diffInMonths;
+    isWeekday: typeof isWeekday;
+    isWeekend: typeof isWeekend;
+    getDayOfWeek: typeof getDayOfWeek;
+    getDayName: typeof getDayName;
+    getPayPeriod: typeof getPayPeriod;
+    getCurrentPeriod: typeof getCurrentPeriod;
+    getWorkingDaysInMonth: typeof getWorkingDaysInMonth;
+    getDaysInMonth: typeof getDaysInMonth;
+    calculateProbationEnd: typeof calculateProbationEnd;
+    isOnProbation: typeof isOnProbation;
+    calculateYearsOfService: typeof calculateYearsOfService;
+    isDateInRange: typeof isDateInRange;
+    getPayPeriodDateRange: typeof getPayPeriodDateRange;
+    formatDateForDB: typeof formatDateForDB;
+    parseDBDate: typeof parseDBDate;
+    formatPeriod: typeof formatPeriod;
+    parsePeriod: typeof parsePeriod;
+    getMonthName: typeof getMonthName;
+    getShortMonthName: typeof getShortMonthName;
+};
+
+/**
+ * @classytic/payroll - Calculation Utilities
+ *
+ * Pure, functional, composable financial calculations
+ * No side effects, highly testable
+ */
+
+/**
+ * Sum array of numbers
+ */
+declare function sum(numbers: number[]): number;
+/**
+ * Sum by property
+ */
+declare function sumBy<T>(items: T[], getter: (item: T) => number): number;
+/**
+ * Sum allowances
+ */
+declare function sumAllowances(allowances: Array<{
+    amount: number;
+}>): number;
+/**
+ * Sum deductions
+ */
+declare function sumDeductions(deductions: Array<{
+    amount: number;
+}>): number;
+/**
+ * Apply percentage to amount
+ */
+declare function applyPercentage(amount: number, percentage: number): number;
+/**
+ * Calculate percentage of total
+ */
+declare function calculatePercentage(part: number, total: number): number;
+/**
+ * Round to decimal places
+ */
+declare function roundTo(value: number, decimals?: number): number;
+/**
+ * Calculate gross salary from base and allowances
+ */
+declare function calculateGross(baseAmount: number, allowances: Array<{
+    amount: number;
+}>): number;
+/**
+ * Calculate net salary from gross and deductions
+ */
+declare function calculateNet(gross: number, deductions: Array<{
+    amount: number;
+}>): number;
+/**
+ * Calculate total compensation
+ */
+declare function calculateTotalCompensation(baseAmount: number, allowances: Array<{
+    amount: number;
+}>, deductions: Array<{
+    amount: number;
+}>): {
+    gross: number;
+    net: number;
+    deductions: number;
+};
+/**
+ * Calculate allowance amount (handles percentage-based)
+ */
+declare function calculateAllowanceAmount(allowance: Pick<Allowance, 'amount' | 'isPercentage' | 'value'>, baseAmount: number): number;
+/**
+ * Calculate deduction amount (handles percentage-based)
+ */
+declare function calculateDeductionAmount(deduction: Pick<Deduction, 'amount' | 'isPercentage' | 'value'>, baseAmount: number): number;
+/**
+ * Calculate all allowances with their actual amounts
+ */
+declare function calculateAllowances(allowances: Allowance[], baseAmount: number): Array<Allowance & {
+    calculatedAmount: number;
+}>;
+/**
+ * Calculate all deductions with their actual amounts
+ */
+declare function calculateDeductions(deductions: Deduction[], baseAmount: number): Array<Deduction & {
+    calculatedAmount: number;
+}>;
+/**
+ * Calculate full compensation breakdown
+ */
+declare function calculateCompensationBreakdown(compensation: Pick<Compensation, 'baseAmount' | 'allowances' | 'deductions'>): CompensationBreakdownResult;
+/**
+ * Calculate pro-rating for mid-month hires
+ */
+declare function calculateProRating(hireDate: Date, periodStart: Date, periodEnd: Date): ProRatingResult;
+/**
+ * Apply pro-rating to an amount
+ */
+declare function applyProRating(amount: number, proRating: ProRatingResult): number;
+/**
+ * Calculate pro-rated salary
+ */
+declare function calculateProRatedSalary(baseAmount: number, hireDate: Date, period: PayPeriodInfo): {
+    amount: number;
+    proRating: ProRatingResult;
+};
+/**
+ * Apply tax brackets to calculate tax
+ */
+declare function applyTaxBrackets(amount: number, brackets: Array<{
+    min: number;
+    max: number;
+    rate: number;
+}>): number;
+/**
+ * Calculate tax with result
+ */
+declare function calculateTax(amount: number, brackets: Array<{
+    min: number;
+    max: number;
+    rate: number;
+}>): TaxCalculationResult;
+/**
+ * Pipe functions left-to-right
+ * pipe(f, g, h)(x) === h(g(f(x)))
+ */
+declare function pipe<T>(...fns: Array<(value: T) => T>): (value: T) => T;
+/**
+ * Compose functions right-to-left
+ * compose(f, g, h)(x) === f(g(h(x)))
+ */
+declare function compose<T>(...fns: Array<(value: T) => T>): (value: T) => T;
+/**
+ * Create an allowance calculator factory
+ */
+declare function createAllowanceCalculator(allowances: Allowance[]): (baseSalary: number) => Array<Allowance & {
+    calculatedAmount: number;
+}>;
+/**
+ * Create a deduction calculator factory
+ */
+declare function createDeductionCalculator(deductions: Deduction[]): (baseSalary: number) => Array<Deduction & {
+    calculatedAmount: number;
+}>;
+/**
+ * Calculate overtime pay
+ */
+declare function calculateOvertime(hourlyRate: number, overtimeHours: number, multiplier?: number): number;
+/**
+ * Calculate hourly rate from monthly salary
+ */
+declare function calculateHourlyRate(monthlySalary: number, hoursPerMonth?: number): number;
+/**
+ * Calculate daily rate from monthly salary
+ */
+declare function calculateDailyRate(monthlySalary: number, daysPerMonth?: number): number;
+declare const _default$2: {
+    sum: typeof sum;
+    sumBy: typeof sumBy;
+    sumAllowances: typeof sumAllowances;
+    sumDeductions: typeof sumDeductions;
+    applyPercentage: typeof applyPercentage;
+    calculatePercentage: typeof calculatePercentage;
+    roundTo: typeof roundTo;
+    calculateGross: typeof calculateGross;
+    calculateNet: typeof calculateNet;
+    calculateTotalCompensation: typeof calculateTotalCompensation;
+    calculateAllowanceAmount: typeof calculateAllowanceAmount;
+    calculateDeductionAmount: typeof calculateDeductionAmount;
+    calculateAllowances: typeof calculateAllowances;
+    calculateDeductions: typeof calculateDeductions;
+    calculateCompensationBreakdown: typeof calculateCompensationBreakdown;
+    calculateProRating: typeof calculateProRating;
+    applyProRating: typeof applyProRating;
+    calculateProRatedSalary: typeof calculateProRatedSalary;
+    applyTaxBrackets: typeof applyTaxBrackets;
+    calculateTax: typeof calculateTax;
+    pipe: typeof pipe;
+    compose: typeof compose;
+    createAllowanceCalculator: typeof createAllowanceCalculator;
+    createDeductionCalculator: typeof createDeductionCalculator;
+    calculateOvertime: typeof calculateOvertime;
+    calculateHourlyRate: typeof calculateHourlyRate;
+    calculateDailyRate: typeof calculateDailyRate;
+};
+
+/**
+ * @classytic/payroll - Validation Utilities
+ *
+ * Fluent, composable, type-safe validation
+ * Clear semantics and helpful error messages
+ */
+
+/**
+ * Check if employee is active
+ */
+declare function isActive(employee: {
+    status?: EmployeeStatus;
+}): boolean;
+/**
+ * Check if employee is on leave
+ */
+declare function isOnLeave(employee: {
+    status?: EmployeeStatus;
+}): boolean;
+/**
+ * Check if employee is suspended
+ */
+declare function isSuspended(employee: {
+    status?: EmployeeStatus;
+}): boolean;
+/**
+ * Check if employee is terminated
+ */
+declare function isTerminated(employee: {
+    status?: EmployeeStatus;
+}): boolean;
+/**
+ * Check if employee is employed (not terminated)
+ */
+declare function isEmployed(employee: {
+    status?: EmployeeStatus;
+}): boolean;
+/**
+ * Check if employee can receive salary
+ */
+declare function canReceiveSalary(employee: {
+    status?: EmployeeStatus;
+    compensation?: {
+        baseAmount?: number;
+    };
+}): boolean;
+/**
+ * Check if employment can be updated
+ */
+declare function canUpdateEmployment(employee: {
+    status?: EmployeeStatus;
+}): boolean;
+/**
+ * Check if employee has valid compensation
+ */
+declare function hasCompensation(employee: {
+    compensation?: {
+        baseAmount?: number;
+    };
+}): boolean;
+/**
+ * Check if compensation is valid
+ */
+declare function isValidCompensation(compensation?: Compensation): boolean;
+/**
+ * Check if bank details are valid
+ */
+declare function isValidBankDetails(bankDetails?: BankDetails): boolean;
+/**
+ * Check if employee is in probation
+ */
+declare function isInProbation(employee: {
+    probationEndDate?: Date | null;
+}, now?: Date): boolean;
+/**
+ * Check if employee has completed probation
+ */
+declare function hasCompletedProbation(employee: {
+    probationEndDate?: Date | null;
+}, now?: Date): boolean;
+/**
+ * Check if employee is eligible for bonus
+ */
+declare function isEligibleForBonus(employee: {
+    status?: EmployeeStatus;
+    hireDate?: Date;
+}, requiredMonths?: number): boolean;
+/**
+ * Check if employee is eligible for payroll
+ */
+declare function isEligibleForPayroll(employee: {
+    status?: EmployeeStatus;
+    compensation?: {
+        baseAmount?: number;
+    };
+    bankDetails?: BankDetails;
+}): {
+    eligible: boolean;
+    reasons: string[];
+};
+/**
+ * Check if value is required
+ */
+declare function required(fieldName: string): (value: unknown) => string | true;
+/**
+ * Check minimum value
+ */
+declare function min(minValue: number, fieldName: string): (value: number) => string | true;
+/**
+ * Check maximum value
+ */
+declare function max(maxValue: number, fieldName: string): (value: number) => string | true;
+/**
+ * Check value is in range
+ */
+declare function inRange(minValue: number, maxValue: number, fieldName: string): (value: number) => string | true;
+/**
+ * Check value is positive
+ */
+declare function isPositive(fieldName: string): (value: number) => string | true;
+/**
+ * Check value is one of allowed values
+ */
+declare function oneOf<T extends string>(allowedValues: readonly T[], fieldName: string): (value: T) => string | true;
+/**
+ * Check if status is valid
+ */
+declare function isValidStatus(value: string): value is EmployeeStatus;
+/**
+ * Check if employment type is valid
+ */
+declare function isValidEmploymentType(value: string): value is EmploymentType;
+/**
+ * Compose multiple validators
+ */
+declare function composeValidators<T>(...validators: Array<(value: T, data?: unknown) => string | true>): (value: T, data?: unknown) => string | true;
+/**
+ * Create a validator from validation functions
+ */
+declare function createValidator<T extends Record<string, unknown>>(validationFns: Record<string, (value: unknown, data: T) => string | true>): (data: T) => EmployeeValidationResult;
+/**
+ * Validate required fields exist
+ */
+declare function hasRequiredFields(obj: Record<string, unknown>, fields: string[]): {
+    valid: boolean;
+    missing: string[];
+};
+declare const minValue: typeof min;
+declare const maxValue: typeof max;
+declare const isInRange: typeof inRange;
+declare const _default$1: {
+    isActive: typeof isActive;
+    isOnLeave: typeof isOnLeave;
+    isSuspended: typeof isSuspended;
+    isTerminated: typeof isTerminated;
+    isEmployed: typeof isEmployed;
+    canReceiveSalary: typeof canReceiveSalary;
+    canUpdateEmployment: typeof canUpdateEmployment;
+    hasCompensation: typeof hasCompensation;
+    isValidCompensation: typeof isValidCompensation;
+    isValidBankDetails: typeof isValidBankDetails;
+    isInProbation: typeof isInProbation;
+    hasCompletedProbation: typeof hasCompletedProbation;
+    isEligibleForBonus: typeof isEligibleForBonus;
+    isEligibleForPayroll: typeof isEligibleForPayroll;
+    required: typeof required;
+    min: typeof min;
+    max: typeof max;
+    inRange: typeof inRange;
+    isPositive: typeof isPositive;
+    oneOf: typeof oneOf;
+    isValidStatus: typeof isValidStatus;
+    isValidEmploymentType: typeof isValidEmploymentType;
+    composeValidators: typeof composeValidators;
+    createValidator: typeof createValidator;
+    hasRequiredFields: typeof hasRequiredFields;
+};
+
+/**
+ * @classytic/payroll - Query Builders
+ *
+ * Fluent API for building MongoDB queries
+ * Type-safe, chainable, beautiful
+ */
+
+/**
+ * Convert string or ObjectId to ObjectId
+ */
+declare function toObjectId(id: ObjectIdLike): Types.ObjectId;
+/**
+ * Safely convert to ObjectId (returns null if invalid)
+ */
+declare function safeToObjectId(id: unknown): Types.ObjectId | null;
+/**
+ * Check if value is valid ObjectId
+ */
+declare function isValidObjectId(value: unknown): boolean;
+declare class QueryBuilder<T extends Record<string, unknown> = Record<string, unknown>> {
+    protected query: T;
+    constructor(initialQuery?: T);
+    /**
+     * Add where condition
+     */
+    where<K extends string>(field: K, value: unknown): this;
+    /**
+     * Add $in condition
+     */
+    whereIn<K extends string>(field: K, values: unknown[]): this;
+    /**
+     * Add $nin condition
+     */
+    whereNotIn<K extends string>(field: K, values: unknown[]): this;
+    /**
+     * Add $gte condition
+     */
+    whereGte<K extends string>(field: K, value: unknown): this;
+    /**
+     * Add $lte condition
+     */
+    whereLte<K extends string>(field: K, value: unknown): this;
+    /**
+     * Add $gt condition
+     */
+    whereGt<K extends string>(field: K, value: unknown): this;
+    /**
+     * Add $lt condition
+     */
+    whereLt<K extends string>(field: K, value: unknown): this;
+    /**
+     * Add between condition
+     */
+    whereBetween<K extends string>(field: K, start: unknown, end: unknown): this;
+    /**
+     * Add $exists condition
+     */
+    whereExists<K extends string>(field: K): this;
+    /**
+     * Add $exists: false condition
+     */
+    whereNotExists<K extends string>(field: K): this;
+    /**
+     * Add $ne condition
+     */
+    whereNot<K extends string>(field: K, value: unknown): this;
+    /**
+     * Add regex condition
+     */
+    whereRegex<K extends string>(field: K, pattern: string, flags?: string): this;
+    /**
+     * Merge another query
+     */
+    merge(otherQuery: Record<string, unknown>): this;
+    /**
+     * Build and return the query
+     */
+    build(): T;
+}
+declare class EmployeeQueryBuilder extends QueryBuilder {
+    /**
+     * Filter by organization
+     */
+    forOrganization(organizationId: ObjectIdLike): this;
+    /**
+     * Filter by user
+     */
+    forUser(userId: ObjectIdLike): this;
+    /**
+     * Filter by status(es)
+     */
+    withStatus(...statuses: EmployeeStatus[]): this;
+    /**
+     * Filter active employees
+     */
+    active(): this;
+    /**
+     * Filter employed employees (not terminated)
+     */
+    employed(): this;
+    /**
+     * Filter terminated employees
+     */
+    terminated(): this;
+    /**
+     * Filter by department
+     */
+    inDepartment(department: Department | string): this;
+    /**
+     * Filter by position
+     */
+    inPosition(position: string): this;
+    /**
+     * Filter by employment type
+     */
+    withEmploymentType(type: EmploymentType | string): this;
+    /**
+     * Filter by hire date (after)
+     */
+    hiredAfter(date: Date): this;
+    /**
+     * Filter by hire date (before)
+     */
+    hiredBefore(date: Date): this;
+    /**
+     * Filter by minimum salary
+     */
+    withMinSalary(amount: number): this;
+    /**
+     * Filter by maximum salary
+     */
+    withMaxSalary(amount: number): this;
+    /**
+     * Filter by salary range
+     */
+    withSalaryRange(min: number, max: number): this;
+}
+declare class PayrollQueryBuilder extends QueryBuilder {
+    /**
+     * Filter by organization
+     */
+    forOrganization(organizationId: ObjectIdLike): this;
+    /**
+     * Filter by employee
+     */
+    forEmployee(employeeId: ObjectIdLike): this;
+    /**
+     * Filter by period
+     */
+    forPeriod(month?: number, year?: number): this;
+    /**
+     * Filter by status(es)
+     */
+    withStatus(...statuses: PayrollStatus[]): this;
+    /**
+     * Filter paid records
+     */
+    paid(): this;
+    /**
+     * Filter pending records
+     */
+    pending(): this;
+    /**
+     * Filter by date range
+     */
+    inDateRange(start: Date, end: Date): this;
+    /**
+     * Filter exported records
+     */
+    exported(): this;
+    /**
+     * Filter not exported records
+     */
+    notExported(): this;
+}
+/**
+ * Create employee query builder
+ */
+declare function employee(): EmployeeQueryBuilder;
+/**
+ * Create payroll query builder
+ */
+declare function payroll(): PayrollQueryBuilder;
+/**
+ * Create generic query builder
+ */
+declare function createQueryBuilder<T extends Record<string, unknown> = Record<string, unknown>>(initialQuery?: T): QueryBuilder<T>;
+/**
+ * Build employee query from options
+ */
+declare function buildEmployeeQuery(options: {
+    organizationId: ObjectIdLike;
+    userId?: ObjectIdLike;
+    statuses?: EmployeeStatus[];
+    department?: Department | string;
+    employmentType?: EmploymentType | string;
+}): Record<string, unknown>;
+/**
+ * Build payroll query from options
+ */
+declare function buildPayrollQuery(options: {
+    employeeId?: ObjectIdLike;
+    organizationId?: ObjectIdLike;
+    month?: number;
+    year?: number;
+    statuses?: PayrollStatus[];
+}): Record<string, unknown>;
+/**
+ * Build aggregation pipeline from stages
+ */
+declare function buildAggregationPipeline(...stages: Array<Record<string, unknown> | undefined | null>): Record<string, unknown>[];
+/**
+ * Match stage
+ */
+declare function matchStage(query: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Group stage
+ */
+declare function groupStage(groupBy: string | null, aggregations: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Sort stage
+ */
+declare function sortStage(sortBy: Record<string, 1 | -1>): Record<string, unknown>;
+/**
+ * Limit stage
+ */
+declare function limitStage(limit: number): Record<string, unknown>;
+/**
+ * Skip stage
+ */
+declare function skipStage(skip: number): Record<string, unknown>;
+/**
+ * Project stage
+ */
+declare function projectStage(fields: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Lookup stage
+ */
+declare function lookupStage(options: {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as: string;
+}): Record<string, unknown>;
+/**
+ * Unwind stage
+ */
+declare function unwindStage(path: string, options?: {
+    preserveNullAndEmptyArrays?: boolean;
+}): Record<string, unknown>;
+declare const _default: {
+    toObjectId: typeof toObjectId;
+    safeToObjectId: typeof safeToObjectId;
+    isValidObjectId: typeof isValidObjectId;
+    QueryBuilder: typeof QueryBuilder;
+    EmployeeQueryBuilder: typeof EmployeeQueryBuilder;
+    PayrollQueryBuilder: typeof PayrollQueryBuilder;
+    employee: typeof employee;
+    payroll: typeof payroll;
+    createQueryBuilder: typeof createQueryBuilder;
+    buildEmployeeQuery: typeof buildEmployeeQuery;
+    buildPayrollQuery: typeof buildPayrollQuery;
+    buildAggregationPipeline: typeof buildAggregationPipeline;
+    matchStage: typeof matchStage;
+    groupStage: typeof groupStage;
+    sortStage: typeof sortStage;
+    limitStage: typeof limitStage;
+    skipStage: typeof skipStage;
+    projectStage: typeof projectStage;
+    lookupStage: typeof lookupStage;
+    unwindStage: typeof 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, _default$2 as calculationUtils, canReceiveSalary, canUpdateEmployment, compose, composeValidators, createAllowanceCalculator, createChildLogger, createDeductionCalculator, createQueryBuilder, createSilentLogger, createValidator, _default$3 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, _default as queryBuilders, required, resetLogger, roundTo, safeToObjectId, setLogger, skipStage, sortStage, startOfDay, startOfMonth, startOfYear, subDays, subMonths, sum, sumAllowances, sumBy, sumDeductions, toObjectId, unwindStage, _default$1 as validationUtils };