@classytic/payroll 1.0.2 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,967 @@
+import payroll from './payroll.js';
+export { Payroll, PayrollBuilder, createPayrollInstance, getPayroll, resetPayroll } from './payroll.js';
+import { n as HRMConfig, D as DeepPartial, s as Department, t as EmploymentType, u as OrgRole, j as PayrollRecordDocument, v as HttpError, w as ErrorCode, x as PaymentFrequency, y as Allowance, z as Deduction, C as Compensation, F as CompensationBreakdownResult } from './types-BSYyX2KJ.js';
+export { A as AddAllowanceParams, c as AddDeductionParams, I as AllowanceType, Q as BankDetails, B as BulkPayrollResult, J as DeductionType, E as EmployeeDocument, G as EmployeeStatus, V as EmploymentHistoryEntry, m as ExportPayrollParams, N as HRMTransactionCategory, H as HireEmployeeParams, L as ListEmployeesParams, o as Logger, O as ObjectIdLike, q as OperationContext, Z as PayrollBreakdown, i as PayrollHistoryParams, P as PayrollInitConfig, r as PayrollInstance, Y as PayrollPeriod, X as PayrollStats, K as PayrollStatus, k as PayrollSummaryParams, l as PayrollSummaryResult, h as ProcessBulkPayrollParams, f as ProcessSalaryParams, g as ProcessSalaryResult, R as ReHireEmployeeParams, b as RemoveAllowanceParams, d as RemoveDeductionParams, S as SingleTenantConfig, T as TerminateEmployeeParams, M as TerminationReason, e as UpdateBankDetailsParams, U as UpdateEmploymentParams, a as UpdateSalaryParams, W as WorkSchedule } from './types-BSYyX2KJ.js';
+export { allowanceSchema, bankDetailsSchema, compensationSchema, deductionSchema, employmentFields, employmentHistorySchema, payrollStatsSchema, workScheduleSchema } from './schemas/index.js';
+import mongoose, { Model, Schema } from 'mongoose';
+import { AttendanceInput } from './core/index.js';
+export { Container, ContainerConfig, Err, ModelsContainer, Ok, Result, err, initializeContainer, isErr, isOk, map, mapErr, ok, unwrap, unwrapOr } from './core/index.js';
+export { E as EventBus, a as PayrollEventMap, P as PayrollPluginDefinition, d as PluginContext, b as PluginManager, c as createEventBus } from './plugin-D9mOr3_d.js';
+export { B as BatchPayrollFactory, C as CompensationService, a as EmployeeBuilder, E as EmployeeFactory, b as EmployeeService, P as PayrollFactory, c as PayrollService } from './index-CTjHlCzz.js';
+export { EmployeeQueryBuilder, PayrollQueryBuilder, QueryBuilder, addDays, addMonths, addYears, applyPercentage, calculateGross, calculateNet, calculateProRating, canReceiveSalary, compose, createValidator, diffInDays, diffInMonths, disableLogging, employee, enableLogging, endOfMonth, endOfYear, formatDateForDB, getCurrentPeriod, getLogger, getPayPeriod, getWorkingDaysInMonth, inRange, isActive, isDateInRange, isEmployed, isLoggingEnabled, isOnProbation, isTerminated, logger, max, min, oneOf, payroll, pipe, required, setLogger, startOfMonth, startOfYear, sum, sumAllowances, sumBy, sumDeductions, toObjectId } from './utils/index.js';
+
+/**
+ * @classytic/payroll - Enums
+ *
+ * Type-safe enum definitions with const assertions
+ * Single source of truth for all enum values
+ */
+
+declare const EMPLOYMENT_TYPE: {
+    readonly FULL_TIME: "full_time";
+    readonly PART_TIME: "part_time";
+    readonly CONTRACT: "contract";
+    readonly INTERN: "intern";
+    readonly CONSULTANT: "consultant";
+};
+declare const EMPLOYEE_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ON_LEAVE: "on_leave";
+    readonly SUSPENDED: "suspended";
+    readonly TERMINATED: "terminated";
+};
+declare const DEPARTMENT: {
+    readonly MANAGEMENT: "management";
+    readonly TRAINING: "training";
+    readonly SALES: "sales";
+    readonly OPERATIONS: "operations";
+    readonly SUPPORT: "support";
+    readonly HR: "hr";
+    readonly MAINTENANCE: "maintenance";
+    readonly MARKETING: "marketing";
+    readonly FINANCE: "finance";
+    readonly IT: "it";
+};
+declare const PAYMENT_FREQUENCY: {
+    readonly MONTHLY: "monthly";
+    readonly BI_WEEKLY: "bi_weekly";
+    readonly WEEKLY: "weekly";
+    readonly HOURLY: "hourly";
+    readonly DAILY: "daily";
+};
+declare const ALLOWANCE_TYPE: {
+    readonly HOUSING: "housing";
+    readonly TRANSPORT: "transport";
+    readonly MEAL: "meal";
+    readonly MOBILE: "mobile";
+    readonly MEDICAL: "medical";
+    readonly EDUCATION: "education";
+    readonly BONUS: "bonus";
+    readonly OTHER: "other";
+};
+declare const DEDUCTION_TYPE: {
+    readonly TAX: "tax";
+    readonly LOAN: "loan";
+    readonly ADVANCE: "advance";
+    readonly PROVIDENT_FUND: "provident_fund";
+    readonly INSURANCE: "insurance";
+    readonly ABSENCE: "absence";
+    readonly OTHER: "other";
+};
+declare const PAYROLL_STATUS: {
+    readonly PENDING: "pending";
+    readonly PROCESSING: "processing";
+    readonly PAID: "paid";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+declare const TERMINATION_REASON: {
+    readonly RESIGNATION: "resignation";
+    readonly RETIREMENT: "retirement";
+    readonly TERMINATION: "termination";
+    readonly CONTRACT_END: "contract_end";
+    readonly MUTUAL_AGREEMENT: "mutual_agreement";
+    readonly OTHER: "other";
+};
+declare const HRM_TRANSACTION_CATEGORIES: {
+    readonly SALARY: "salary";
+    readonly BONUS: "bonus";
+    readonly COMMISSION: "commission";
+    readonly OVERTIME: "overtime";
+    readonly SEVERANCE: "severance";
+};
+
+/**
+ * @classytic/payroll - Configuration
+ *
+ * Centralized configuration with type safety
+ * Configurable defaults for different use cases
+ */
+
+declare const HRM_CONFIG: HRMConfig;
+/**
+ * Calculate tax based on annual income
+ */
+declare function calculateTax(annualIncome: number, currency?: string): number;
+/**
+ * Determine the appropriate organization role for an employee
+ */
+declare function determineOrgRole(employmentData: {
+    department?: Department | string;
+    type?: EmploymentType | string;
+    position?: string;
+}): OrgRole;
+/**
+ * Merge configuration with defaults
+ */
+declare function mergeConfig(customConfig: Partial<HRMConfig> | DeepPartial<HRMConfig> | undefined): HRMConfig;
+
+/**
+ * @classytic/payroll - PayrollRecord Model
+ *
+ * Mongoose schema for payroll records with TTL and auto-export
+ */
+
+declare const payrollRecordSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    organizationId: mongoose.Types.ObjectId;
+    userId: mongoose.Types.ObjectId;
+    employeeId: mongoose.Types.ObjectId;
+    period: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate?: NativeDate | null | undefined;
+    };
+    status: "pending" | "processing" | "paid" | "failed" | "cancelled";
+    exported: boolean;
+    paymentMethod: "bank" | "cash" | "check" | "mobile" | "bkash" | "nagad" | "rocket";
+    breakdown: {
+        baseAmount: number;
+        allowances: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }> & {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }>;
+        deductions: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }> & {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }>;
+        grossSalary: number;
+        netSalary: number;
+        taxableAmount: number;
+        taxAmount: number;
+        attendanceDeduction: number;
+        proRatedAmount: number;
+        workingDays?: number | null | undefined;
+        actualDays?: number | null | undefined;
+    };
+    metadata: any;
+    corrections: mongoose.Types.DocumentArray<{
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }> & {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }>;
+    notes?: string | null | undefined;
+    processedAt?: NativeDate | null | undefined;
+    processedBy?: mongoose.Types.ObjectId | null | undefined;
+    transactionId?: mongoose.Types.ObjectId | null | undefined;
+    exportedAt?: NativeDate | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
+    organizationId: mongoose.Types.ObjectId;
+    userId: mongoose.Types.ObjectId;
+    employeeId: mongoose.Types.ObjectId;
+    period: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate?: NativeDate | null | undefined;
+    };
+    status: "pending" | "processing" | "paid" | "failed" | "cancelled";
+    exported: boolean;
+    paymentMethod: "bank" | "cash" | "check" | "mobile" | "bkash" | "nagad" | "rocket";
+    breakdown: {
+        baseAmount: number;
+        allowances: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }> & {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }>;
+        deductions: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }> & {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }>;
+        grossSalary: number;
+        netSalary: number;
+        taxableAmount: number;
+        taxAmount: number;
+        attendanceDeduction: number;
+        proRatedAmount: number;
+        workingDays?: number | null | undefined;
+        actualDays?: number | null | undefined;
+    };
+    metadata: any;
+    corrections: mongoose.Types.DocumentArray<{
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }> & {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }>;
+    notes?: string | null | undefined;
+    processedAt?: NativeDate | null | undefined;
+    processedBy?: mongoose.Types.ObjectId | null | undefined;
+    transactionId?: mongoose.Types.ObjectId | null | undefined;
+    exportedAt?: NativeDate | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, mongoose.ResolveSchemaOptions<{
+    timestamps: true;
+}>> & Omit<{
+    organizationId: mongoose.Types.ObjectId;
+    userId: mongoose.Types.ObjectId;
+    employeeId: mongoose.Types.ObjectId;
+    period: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate?: NativeDate | null | undefined;
+    };
+    status: "pending" | "processing" | "paid" | "failed" | "cancelled";
+    exported: boolean;
+    paymentMethod: "bank" | "cash" | "check" | "mobile" | "bkash" | "nagad" | "rocket";
+    breakdown: {
+        baseAmount: number;
+        allowances: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }> & {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }>;
+        deductions: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }> & {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }>;
+        grossSalary: number;
+        netSalary: number;
+        taxableAmount: number;
+        taxAmount: number;
+        attendanceDeduction: number;
+        proRatedAmount: number;
+        workingDays?: number | null | undefined;
+        actualDays?: number | null | undefined;
+    };
+    metadata: any;
+    corrections: mongoose.Types.DocumentArray<{
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }> & {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    }>;
+    notes?: string | null | undefined;
+    processedAt?: NativeDate | null | undefined;
+    processedBy?: mongoose.Types.ObjectId | null | undefined;
+    transactionId?: mongoose.Types.ObjectId | null | undefined;
+    exportedAt?: NativeDate | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    [path: string]: mongoose.SchemaDefinitionProperty<undefined, any, any>;
+} | {
+    [x: string]: mongoose.SchemaDefinitionProperty<any, any, mongoose.Document<unknown, {}, {
+        organizationId: mongoose.Types.ObjectId;
+        userId: mongoose.Types.ObjectId;
+        employeeId: mongoose.Types.ObjectId;
+        period: {
+            month: number;
+            year: number;
+            startDate: NativeDate;
+            endDate: NativeDate;
+            payDate?: NativeDate | null | undefined;
+        };
+        status: "pending" | "processing" | "paid" | "failed" | "cancelled";
+        exported: boolean;
+        paymentMethod: "bank" | "cash" | "check" | "mobile" | "bkash" | "nagad" | "rocket";
+        breakdown: {
+            baseAmount: number;
+            allowances: mongoose.Types.DocumentArray<{
+                type: string;
+                amount: number;
+                taxable: boolean;
+            }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+                type: string;
+                amount: number;
+                taxable: boolean;
+            }> & {
+                type: string;
+                amount: number;
+                taxable: boolean;
+            }>;
+            deductions: mongoose.Types.DocumentArray<{
+                type: string;
+                amount: number;
+                description?: string | null | undefined;
+            }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+                type: string;
+                amount: number;
+                description?: string | null | undefined;
+            }> & {
+                type: string;
+                amount: number;
+                description?: string | null | undefined;
+            }>;
+            grossSalary: number;
+            netSalary: number;
+            taxableAmount: number;
+            taxAmount: number;
+            attendanceDeduction: number;
+            proRatedAmount: number;
+            workingDays?: number | null | undefined;
+            actualDays?: number | null | undefined;
+        };
+        metadata: any;
+        corrections: mongoose.Types.DocumentArray<{
+            correctedAt: NativeDate;
+            reason?: string | null | undefined;
+            previousAmount?: number | null | undefined;
+            newAmount?: number | null | undefined;
+            correctedBy?: mongoose.Types.ObjectId | null | undefined;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            correctedAt: NativeDate;
+            reason?: string | null | undefined;
+            previousAmount?: number | null | undefined;
+            newAmount?: number | null | undefined;
+            correctedBy?: mongoose.Types.ObjectId | null | undefined;
+        }> & {
+            correctedAt: NativeDate;
+            reason?: string | null | undefined;
+            previousAmount?: number | null | undefined;
+            newAmount?: number | null | undefined;
+            correctedBy?: mongoose.Types.ObjectId | null | undefined;
+        }>;
+        notes?: string | null | undefined;
+        processedAt?: NativeDate | null | undefined;
+        processedBy?: mongoose.Types.ObjectId | null | undefined;
+        transactionId?: mongoose.Types.ObjectId | null | undefined;
+        exportedAt?: NativeDate | null | undefined;
+        paidAt?: NativeDate | null | undefined;
+    } & mongoose.DefaultTimestampProps, {
+        id: string;
+    }, mongoose.ResolveSchemaOptions<{
+        timestamps: true;
+    }>> & Omit<{
+        organizationId: mongoose.Types.ObjectId;
+        userId: mongoose.Types.ObjectId;
+        employeeId: mongoose.Types.ObjectId;
+        period: {
+            month: number;
+            year: number;
+            startDate: NativeDate;
+            endDate: NativeDate;
+            payDate?: NativeDate | null | undefined;
+        };
+        status: "pending" | "processing" | "paid" | "failed" | "cancelled";
+        exported: boolean;
+        paymentMethod: "bank" | "cash" | "check" | "mobile" | "bkash" | "nagad" | "rocket";
+        breakdown: {
+            baseAmount: number;
+            allowances: mongoose.Types.DocumentArray<{
+                type: string;
+                amount: number;
+                taxable: boolean;
+            }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+                type: string;
+                amount: number;
+                taxable: boolean;
+            }> & {
+                type: string;
+                amount: number;
+                taxable: boolean;
+            }>;
+            deductions: mongoose.Types.DocumentArray<{
+                type: string;
+                amount: number;
+                description?: string | null | undefined;
+            }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+                type: string;
+                amount: number;
+                description?: string | null | undefined;
+            }> & {
+                type: string;
+                amount: number;
+                description?: string | null | undefined;
+            }>;
+            grossSalary: number;
+            netSalary: number;
+            taxableAmount: number;
+            taxAmount: number;
+            attendanceDeduction: number;
+            proRatedAmount: number;
+            workingDays?: number | null | undefined;
+            actualDays?: number | null | undefined;
+        };
+        metadata: any;
+        corrections: mongoose.Types.DocumentArray<{
+            correctedAt: NativeDate;
+            reason?: string | null | undefined;
+            previousAmount?: number | null | undefined;
+            newAmount?: number | null | undefined;
+            correctedBy?: mongoose.Types.ObjectId | null | undefined;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            correctedAt: NativeDate;
+            reason?: string | null | undefined;
+            previousAmount?: number | null | undefined;
+            newAmount?: number | null | undefined;
+            correctedBy?: mongoose.Types.ObjectId | null | undefined;
+        }> & {
+            correctedAt: NativeDate;
+            reason?: string | null | undefined;
+            previousAmount?: number | null | undefined;
+            newAmount?: number | null | undefined;
+            correctedBy?: mongoose.Types.ObjectId | null | undefined;
+        }>;
+        notes?: string | null | undefined;
+        processedAt?: NativeDate | null | undefined;
+        processedBy?: mongoose.Types.ObjectId | null | undefined;
+        transactionId?: mongoose.Types.ObjectId | null | undefined;
+        exportedAt?: NativeDate | null | undefined;
+        paidAt?: NativeDate | null | undefined;
+    } & mongoose.DefaultTimestampProps & {
+        _id: mongoose.Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, {
+    organizationId: mongoose.Types.ObjectId;
+    userId: mongoose.Types.ObjectId;
+    employeeId: mongoose.Types.ObjectId;
+    period: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate?: NativeDate | null | undefined;
+    };
+    status: "pending" | "processing" | "paid" | "failed" | "cancelled";
+    exported: boolean;
+    paymentMethod: "bank" | "cash" | "check" | "mobile" | "bkash" | "nagad" | "rocket";
+    breakdown: {
+        baseAmount: number;
+        allowances: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }> & {
+            type: string;
+            amount: number;
+            taxable: boolean;
+        }>;
+        deductions: mongoose.Types.DocumentArray<{
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }> & {
+            type: string;
+            amount: number;
+            description?: string | null | undefined;
+        }>;
+        grossSalary: number;
+        netSalary: number;
+        taxableAmount: number;
+        taxAmount: number;
+        attendanceDeduction: number;
+        proRatedAmount: number;
+        workingDays?: number | null | undefined;
+        actualDays?: number | null | undefined;
+    };
+    metadata: any;
+    corrections: mongoose.Types.DocumentArray<{
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    } | {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: string | null | undefined;
+        _id: string;
+    }, mongoose.Types.Subdocument<string | mongoose.mongo.BSON.ObjectId, unknown, {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    } | {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: string | null | undefined;
+        _id: string;
+    }> & ({
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: mongoose.Types.ObjectId | null | undefined;
+    } | {
+        correctedAt: NativeDate;
+        reason?: string | null | undefined;
+        previousAmount?: number | null | undefined;
+        newAmount?: number | null | undefined;
+        correctedBy?: string | null | undefined;
+        _id: string;
+    })>;
+    notes?: string | null | undefined;
+    processedAt?: NativeDate | null | undefined;
+    processedBy?: mongoose.Types.ObjectId | null | undefined;
+    transactionId?: mongoose.Types.ObjectId | null | undefined;
+    exportedAt?: NativeDate | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+interface PayrollRecordModel extends Model<PayrollRecordDocument> {
+    findByPeriod(organizationId: mongoose.Types.ObjectId, month: number, year: number): ReturnType<Model<PayrollRecordDocument>['find']>;
+    findByEmployee(employeeId: mongoose.Types.ObjectId, limit?: number): ReturnType<Model<PayrollRecordDocument>['find']>;
+    getSummary(organizationId: mongoose.Types.ObjectId, month?: number, year?: number): Promise<{
+        totalGross: number;
+        totalNet: number;
+        count: number;
+        paidCount: number;
+    }>;
+    getExpiringSoon(organizationId: mongoose.Types.ObjectId, daysBeforeExpiry?: number): ReturnType<Model<PayrollRecordDocument>['find']>;
+}
+/**
+ * Get or create PayrollRecord model
+ */
+declare function getPayrollRecordModel(connection?: mongoose.Connection): PayrollRecordModel;
+
+/**
+ * @classytic/payroll - Employee Plugin
+ *
+ * Mongoose plugin that adds HRM methods and virtuals to Employee schema
+ */
+
+interface EmployeePluginOptions {
+    /** Require bank details for salary payment */
+    requireBankDetails?: boolean;
+    /** Field name for compensation */
+    compensationField?: string;
+    /** Field name for status */
+    statusField?: string;
+    /** Enable auto salary calculation on save */
+    autoCalculateSalary?: boolean;
+}
+/**
+ * Mongoose plugin that adds HRM functionality to Employee schema
+ *
+ * @example
+ * const employeeSchema = new Schema({
+ *   ...employmentFields,
+ *   // Custom fields
+ * });
+ *
+ * employeeSchema.plugin(employeePlugin);
+ */
+declare function employeePlugin(schema: Schema, options?: EmployeePluginOptions): void;
+
+/**
+ * @classytic/payroll - Error Handling
+ *
+ * Custom error classes with error codes and HTTP status
+ */
+
+declare class PayrollError extends Error implements HttpError {
+    readonly code: ErrorCode;
+    readonly status: number;
+    readonly context?: Record<string, unknown>;
+    readonly timestamp: Date;
+    constructor(message: string, code?: ErrorCode, status?: number, context?: Record<string, unknown>);
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Not initialized error
+ */
+declare class NotInitializedError extends PayrollError {
+    constructor(message?: string);
+}
+/**
+ * Employee not found error
+ */
+declare class EmployeeNotFoundError extends PayrollError {
+    constructor(employeeId?: string, context?: Record<string, unknown>);
+}
+/**
+ * Duplicate payroll error
+ */
+declare class DuplicatePayrollError extends PayrollError {
+    constructor(employeeId: string, month: number, year: number, context?: Record<string, unknown>);
+}
+/**
+ * Validation error
+ */
+declare class ValidationError extends PayrollError {
+    readonly errors: string[];
+    constructor(errors: string | string[], context?: Record<string, unknown>);
+}
+/**
+ * Employee terminated error
+ */
+declare class EmployeeTerminatedError extends PayrollError {
+    constructor(employeeId?: string, context?: Record<string, unknown>);
+}
+/**
+ * Not eligible error
+ */
+declare class NotEligibleError extends PayrollError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+
+/**
+ * @classytic/payroll - Compensation Factory
+ *
+ * Clean compensation structure creation
+ * Presets for common compensation packages
+ */
+
+interface CreateCompensationParams {
+    baseAmount: number;
+    frequency?: PaymentFrequency;
+    currency?: string;
+    allowances?: Array<{
+        type: Allowance['type'];
+        value: number;
+        isPercentage?: boolean;
+        name?: string;
+        taxable?: boolean;
+    }>;
+    deductions?: Array<{
+        type: Deduction['type'];
+        value: number;
+        isPercentage?: boolean;
+        name?: string;
+        auto?: boolean;
+    }>;
+    effectiveFrom?: Date;
+}
+declare class CompensationFactory {
+    /**
+     * Create compensation object
+     */
+    static create(params: CreateCompensationParams): Compensation;
+    /**
+     * Create allowance
+     */
+    static createAllowance(params: {
+        type: Allowance['type'];
+        value: number;
+        isPercentage?: boolean;
+        name?: string;
+        taxable?: boolean;
+    }, baseAmount?: number): Allowance;
+    /**
+     * Create deduction
+     */
+    static createDeduction(params: {
+        type: Deduction['type'];
+        value: number;
+        isPercentage?: boolean;
+        name?: string;
+        auto?: boolean;
+    }, baseAmount?: number): Deduction;
+    /**
+     * Update base amount (immutable)
+     */
+    static updateBaseAmount(compensation: Compensation, newAmount: number, effectiveFrom?: Date): Compensation;
+    /**
+     * Add allowance (immutable)
+     */
+    static addAllowance(compensation: Compensation, allowance: Parameters<typeof this.createAllowance>[0]): Compensation;
+    /**
+     * Remove allowance (immutable)
+     */
+    static removeAllowance(compensation: Compensation, allowanceType: Allowance['type']): Compensation;
+    /**
+     * Add deduction (immutable)
+     */
+    static addDeduction(compensation: Compensation, deduction: Parameters<typeof this.createDeduction>[0]): Compensation;
+    /**
+     * Remove deduction (immutable)
+     */
+    static removeDeduction(compensation: Compensation, deductionType: Deduction['type']): Compensation;
+    /**
+     * Calculate compensation breakdown
+     */
+    static calculateBreakdown(compensation: Compensation): CompensationBreakdownResult;
+    /**
+     * Apply salary increment (immutable)
+     */
+    static applyIncrement(compensation: Compensation, params: {
+        percentage?: number;
+        amount?: number;
+        effectiveFrom?: Date;
+    }): Compensation;
+}
+declare class CompensationBuilder {
+    private data;
+    /**
+     * Set base amount
+     */
+    withBase(amount: number, frequency?: PaymentFrequency, currency?: string): this;
+    /**
+     * Add allowance
+     */
+    addAllowance(type: Allowance['type'], value: number, isPercentage?: boolean, name?: string): this;
+    /**
+     * Add deduction
+     */
+    addDeduction(type: Deduction['type'], value: number, isPercentage?: boolean, name?: string): this;
+    /**
+     * Set effective date
+     */
+    effectiveFrom(date: Date): this;
+    /**
+     * Build compensation
+     */
+    build(): Compensation;
+}
+
+/**
+ * @classytic/payroll - Attendance Integration
+ *
+ * Native integration with @classytic/clockin.
+ * ClockIn is a peer dependency - attendance is core to payroll.
+ */
+
+/**
+ * Get attendance for payroll calculation
+ *
+ * @example
+ * ```typescript
+ * import { getAttendance } from '@classytic/payroll';
+ *
+ * const attendance = await getAttendance(Attendance, {
+ *   organizationId: org._id,
+ *   employeeId: emp._id,
+ *   month: 3,
+ *   year: 2024,
+ *   expectedDays: 22,
+ * });
+ *
+ * await payroll.processSalary({ employeeId, month: 3, year: 2024, attendance });
+ * ```
+ */
+declare function getAttendance(AttendanceModel: Model<any>, params: {
+    organizationId: any;
+    employeeId: any;
+    month: number;
+    year: number;
+    expectedDays: number;
+}): Promise<(AttendanceInput & {
+    absentDays: number;
+    overtimeDays: number;
+}) | null>;
+/**
+ * Get attendance for multiple employees (efficient batch operation)
+ *
+ * @example
+ * ```typescript
+ * const attendanceMap = await batchGetAttendance(Attendance, {
+ *   organizationId: org._id,
+ *   employeeIds: [emp1._id, emp2._id, emp3._id],
+ *   month: 3,
+ *   year: 2024,
+ *   expectedDays: 22,
+ * });
+ *
+ * const emp1Attendance = attendanceMap.get(emp1._id.toString());
+ * ```
+ */
+declare function batchGetAttendance(AttendanceModel: Model<any>, params: {
+    organizationId: any;
+    employeeIds: any[];
+    month: number;
+    year: number;
+    expectedDays: number;
+}): Promise<Map<string, AttendanceInput>>;
+
+/**
+ * @classytic/payroll - Holiday Management
+ *
+ * Simple holiday storage and retrieval.
+ * ONE way to manage holidays - no confusion.
+ */
+
+/**
+ * Holiday document
+ */
+interface Holiday {
+    organizationId?: any;
+    date: Date;
+    name: string;
+    type: 'public' | 'company' | 'religious';
+    paid: boolean;
+}
+/**
+ * Create holiday schema
+ *
+ * @example
+ * ```typescript
+ * import { createHolidaySchema } from '@classytic/payroll';
+ *
+ * // Multi-tenant
+ * const Holiday = model('Holiday', createHolidaySchema());
+ *
+ * // Single-tenant
+ * const Holiday = model('Holiday', createHolidaySchema({ singleTenant: true }));
+ * ```
+ */
+declare function createHolidaySchema(options?: {
+    singleTenant?: boolean;
+}): Schema;
+/**
+ * Get holidays for a period
+ *
+ * @example
+ * ```typescript
+ * const holidays = await getHolidays(Holiday, {
+ *   organizationId: org._id, // optional for single-tenant
+ *   startDate: new Date('2024-03-01'),
+ *   endDate: new Date('2024-03-31'),
+ * });
+ * ```
+ */
+declare function getHolidays(HolidayModel: Model<any>, params: {
+    organizationId?: any;
+    startDate: Date;
+    endDate: Date;
+}): Promise<Date[]>;
+
+/**
+ * @classytic/payroll
+ *
+ * Enterprise-grade HRM and Payroll Management for MongoDB/Mongoose
+ * Clean, pluggable, multi-tenant architecture
+ *
+ * @packageDocumentation
+ */
+
+export { ALLOWANCE_TYPE, Allowance, Compensation, CompensationBuilder, CompensationFactory, DEDUCTION_TYPE, DEPARTMENT, Deduction, DeepPartial, Department, DuplicatePayrollError, EMPLOYEE_STATUS, EMPLOYMENT_TYPE, EmployeeNotFoundError, type EmployeePluginOptions, EmployeeTerminatedError, EmploymentType, HRMConfig, HRM_CONFIG, HRM_TRANSACTION_CATEGORIES, type Holiday, NotEligibleError, NotInitializedError, PAYMENT_FREQUENCY, PAYROLL_STATUS, PaymentFrequency, PayrollError, PayrollRecordDocument, type PayrollRecordModel, TERMINATION_REASON, ValidationError, batchGetAttendance, calculateTax, createHolidaySchema, payroll as default, determineOrgRole, employeePlugin, getAttendance, getHolidays, getPayrollRecordModel, mergeConfig, payroll as payrollInstance, payrollRecordSchema };