@classytic/payroll 1.0.2 → 2.3.0

package/dist/index.d.ts

@@ -0,0 +1,902 @@
+export { Payroll, PayrollBuilder, createPayrollInstance } from './payroll.js';
+import { O as ObjectIdLike, aM as PayrollBreakdown, aF as LeaveType, aY as LeaveRequestStatus, aR as TaxType, aS as TaxStatus, z as HRMConfig, D as DeepPartial, I as Department, F as EmploymentType, aZ as OrgRole, aJ as LeaveInitConfig, a_ as HttpError, a$ as ErrorCode, aw as AttendanceInput, y as LeaveRequestDocument, v as TaxWithholdingDocument } from './types-BN3K_Uhr.js';
+export { bm as AccrueLeaveOptions, j as AddAllowanceParams, l as AddDeductionParams, N as Allowance, bf as AllowanceType, A as AnyDocument, aP as AnyModel, V as BankDetails, bp as BulkPayrollProgress, B as BulkPayrollResult, X as Compensation, aO as CompensationBreakdownResult, b2 as DataRetentionConfig, Q as Deduction, bg as DeductionType, E as EmployeeDocument, bv as EmployeeHiredEvent, b7 as EmployeeIdMode, h as EmployeeIdentityMode, bo as EmployeeOperationParams, aK as EmployeeStatus, aW as EmployeeValidationResult, b5 as EmploymentConfig, bd as EmploymentHistoryEntry, bx as EventPayload, bu as EventPayloadBase, u as ExportPayrollParams, b1 as FilterQuery, G as GetPendingTaxParams, bi as HRMTransactionCategory, H as HireEmployeeParams, aH as LeaveBalance, bl as LeaveHistoryFilters, aI as LeaveSummaryResult, L as ListEmployeesParams, C as Logger, M as MarkTaxPaidParams, b0 as Nullable, g as OperationContext, aT as PayPeriodInfo, K as PaymentFrequency, aN as PaymentMethod, b3 as PayrollConfig, bc as PayrollCorrection, bz as PayrollEmployee, bt as PayrollEvent, r as PayrollHistoryParams, b as PayrollInitConfig, a as PayrollInstance, aL as PayrollPeriod, bq as PayrollPlugin, P as PayrollRecordDocument, bb as PayrollStats, aX as PayrollStatus, s as PayrollSummaryParams, t as PayrollSummaryResult, br as PluginFunction, bs as PluginType, q as ProcessBulkPayrollParams, o as ProcessSalaryParams, p as ProcessSalaryResult, by as QueryOptions, R as ReHireEmployeeParams, k as RemoveAllowanceParams, m as RemoveDeductionParams, bj as RequestLeaveInput, bn as ResetAnnualLeaveOptions, bk as ReviewLeaveRequestInput, ba as RoleMappingConfig, bh as SalaryBand, b9 as SalaryBandRange, b4 as SalaryConfig, bw as SalaryProcessedEvent, S as SingleTenantConfig, b8 as TaxBracket, aV as TaxCalculationResult, bB as TaxSummaryByType, w as TaxSummaryParams, x as TaxSummaryResult, T as TerminateEmployeeParams, Y as TerminationReason, n as UpdateBankDetailsParams, U as UpdateEmploymentParams, i as UpdateSalaryParams, be as UserReference, b6 as ValidationConfig, W as WebhookConfig, f as WebhookDelivery, ag as WebhookManager, bA as WithPayroll, J as WorkSchedule, aG as WorkingDaysOptions } from './types-BN3K_Uhr.js';
+import { ITransaction, ITransactionCreateInput } from '@classytic/shared-types';
+export { I as IdempotencyManager, a as IdempotentResult, g as generatePayrollIdempotencyKey } from './idempotency-Cw2CWicb.js';
+export { allowanceSchema, applyEmployeeIndexes, applyLeaveRequestIndexes, applyPayrollRecordIndexes, applyTaxWithholdingIndexes, bankDetailsSchema, compensationSchema, createEmployeeSchema, createLeaveRequestSchema, createPayrollRecordSchema, createTaxWithholdingSchema, deductionSchema, employmentFields, employmentHistorySchema, leaveBalanceFields, leaveBalanceSchema, leaveRequestFields, leaveRequestIndexes, payrollStatsSchema, taxWithholdingFields, taxWithholdingIndexes, workScheduleSchema } from './schemas/index.js';
+import mongoose__default, { Schema, Model } from 'mongoose';
+export { C as CreateEmployeeParams, a as EmployeeBuilder, b as EmployeeData, E as EmployeeFactory, T as TerminationData, c as createEmployee } from './employee.factory-BlZqhiCk.js';
+export { C as ContainerLike, a as DEFAULT_CARRY_OVER, D as DEFAULT_LEAVE_ALLOCATIONS, 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, u as normalizeEmployeeId, p as proRateAllocation, r as requireOrganizationId, q as resolveOrganizationId, t as tryResolveOrganizationId, v as validateOrganizationId } from './employee-identity-DXhgOgXE.js';
+export { AttendanceDeductionInput, AttendanceDeductionResult, ProRatingInput, ProRatingResult, ProcessedAllowance, ProcessedDeduction, SalaryCalculationInput, applyProRating, calculateAttendanceDeduction, calculateDailyRate, calculateHourlyRate, calculatePartialDayDeduction, calculateProRating, calculateSalaryBreakdown, calculateTotalAttendanceDeduction, shouldProRate } from './calculators/index.js';
+export { AttendancePolicy, AttendancePolicyBuilder, AttendancePolicyDocument, AttendancePolicyModel, AttendancePolicySchema, AttendancePolicySchemaDefinition, CalculateShiftComplianceInput, ClockRoundingPolicy, ClockRoundingPolicyBuilder, ClockRoundingPolicySchema, ClockRoundingPolicySchemaDefinition, DEFAULT_ATTENDANCE_POLICY, EarlyDeparturePenaltyResult, EarlyDeparturePolicy, EarlyDeparturePolicySchema, EarlyDeparturePolicySchemaDefinition, EarlyOccurrence, HEALTHCARE_POLICY, HOSPITALITY_POLICY, LateArrivalPolicy, LateArrivalPolicySchema, LateArrivalPolicySchemaDefinition, LateOccurrence, LatePenaltyResult, LatePolicyBuilder, MANUFACTURING_POLICY, MaxPenaltiesPerPeriod, MaxPenaltiesSchema, MaxPenaltiesSchemaDefinition, NightShiftDifferential, NightShiftDifferentialSchema, NightShiftDifferentialSchemaDefinition, OFFICE_POLICY, OvertimeBonusResult, OvertimeMode, OvertimeOccurrence, OvertimePolicy, OvertimePolicyBuilder, OvertimePolicySchema, OvertimePolicySchemaDefinition, PenaltyMode, PenaltyOverride, PenaltyTier, PenaltyTierSchema, PenaltyTierSchemaDefinition, RETAIL_POLICY, ResetPeriod, RoundingMode, ShiftComplianceData, ShiftComplianceResult, ShiftDifferentialResult, TieredPenaltyBuilder, WeekendPremium, WeekendPremiumSchema, WeekendPremiumSchemaDefinition, calculateDailyOvertime, calculateFlatPenalty, calculateLatePenalty, calculateMonthlyOvertime, calculateNightShiftDifferential, calculateOvertimeBonus, calculatePerMinutePenalty, calculatePercentagePenalty, calculateShiftCompliance, calculateTieredPenalty, calculateWeekendPremium, calculateWeeklyOvertime, createClockRoundingPolicyBuilder, createLatePolicyBuilder, createOvertimePolicyBuilder, createPolicyFromPreset } from './shift-compliance/index.js';
+
+/**
+ * Transaction Interface
+ * @classytic/payroll
+ *
+ * Payroll uses the unified transaction interface from @classytic/shared-types
+ * so revenue and payroll share a single cashflow event model.
+ */
+
+/**
+ * Core transaction interface expected by payroll package
+ * Apps must provide a Transaction model with AT LEAST these fields
+ */
+type IPayrollTransaction = ITransaction;
+/**
+ * Transaction write input (what payroll package creates)
+ */
+type IPayrollTransactionCreateInput = ITransactionCreateInput;
+/**
+ * Type guard to check if object is a Transaction
+ */
+declare function isPayrollTransaction(obj: unknown): obj is IPayrollTransaction;
+
+/**
+ * @classytic/payroll - Transaction Factory
+ *
+ * Pure functions for building transaction objects aligned with @classytic/shared-types.
+ * Ensures consistency with revenue package for unified cashflow.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Input for creating a payroll transaction
+ */
+interface CreatePayrollTransactionInput {
+    organizationId: ObjectIdLike;
+    employee: {
+        _id: ObjectIdLike;
+        userId?: ObjectIdLike | {
+            _id: ObjectIdLike;
+            name?: string;
+        } | null;
+        employeeId: string;
+        email?: string;
+        compensation: {
+            currency: string;
+        };
+    };
+    payrollRecord: {
+        _id: ObjectIdLike;
+    };
+    breakdown: PayrollBreakdown;
+    period: {
+        month: number;
+        year: number;
+    };
+    paymentDate: Date;
+    paymentMethod?: string;
+    processedBy?: ObjectIdLike;
+    idempotencyKey?: string;
+    jurisdiction?: string;
+}
+/**
+ * Input for creating a tax payment transaction
+ */
+interface CreateTaxPaymentTransactionInput {
+    organizationId: ObjectIdLike;
+    totalAmount: number;
+    currency: string;
+    referenceNumber?: string;
+    notes?: string;
+    withholdingIds: ObjectIdLike[];
+}
+/**
+ * Create payroll transaction aligned with @classytic/shared-types
+ *
+ * This is the SINGLE SOURCE OF TRUTH for payroll transaction structure.
+ * Aligns with revenue package for unified cashflow.
+ *
+ * @param input - Payroll transaction parameters
+ * @returns Transaction data ready for DB creation (ITransactionCreateInput)
+ *
+ * @pure This function has no side effects
+ */
+declare function createPayrollTransaction(input: CreatePayrollTransactionInput): ITransactionCreateInput;
+/**
+ * Create tax payment transaction aligned with @classytic/shared-types
+ *
+ * For government tax payments (withholding remittance).
+ *
+ * @param input - Tax payment parameters
+ * @returns Transaction data ready for DB creation (ITransactionCreateInput)
+ *
+ * @pure This function has no side effects
+ */
+declare function createTaxPaymentTransaction(input: CreateTaxPaymentTransactionInput): ITransactionCreateInput;
+/**
+ * Transaction Factory class (for builder pattern if needed)
+ */
+declare class TransactionFactory {
+    static createPayrollTransaction: typeof createPayrollTransaction;
+    static createTaxPaymentTransaction: typeof createTaxPaymentTransaction;
+}
+
+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 LEAVE_TYPE: {
+    readonly ANNUAL: "annual";
+    readonly SICK: "sick";
+    readonly UNPAID: "unpaid";
+    readonly MATERNITY: "maternity";
+    readonly PATERNITY: "paternity";
+    readonly BEREAVEMENT: "bereavement";
+    readonly COMPENSATORY: "compensatory";
+    readonly OTHER: "other";
+};
+declare function isValidLeaveType(value: string): value is LeaveType;
+declare function isPaidLeaveType(type: LeaveType): boolean;
+declare const LEAVE_REQUEST_STATUS: {
+    readonly PENDING: "pending";
+    readonly APPROVED: "approved";
+    readonly REJECTED: "rejected";
+    readonly CANCELLED: "cancelled";
+};
+declare function isValidLeaveRequestStatus(value: string): value is LeaveRequestStatus;
+declare function isPendingLeaveStatus(status: LeaveRequestStatus): boolean;
+declare function isApprovedLeaveStatus(status: LeaveRequestStatus): boolean;
+declare const TAX_TYPE: {
+    readonly INCOME_TAX: "income_tax";
+    readonly SOCIAL_SECURITY: "social_security";
+    readonly HEALTH_INSURANCE: "health_insurance";
+    readonly PENSION: "pension";
+    readonly EMPLOYMENT_INSURANCE: "employment_insurance";
+    readonly LOCAL_TAX: "local_tax";
+    readonly OTHER: "other";
+};
+declare const TAX_TYPE_VALUES: ("other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax")[];
+declare function isValidTaxType(value: string): value is TaxType;
+declare const TAX_STATUS: {
+    readonly PENDING: "pending";
+    readonly SUBMITTED: "submitted";
+    readonly PAID: "paid";
+};
+declare const TAX_STATUS_VALUES: ("pending" | "paid" | "submitted")[];
+declare function isValidTaxStatus(value: string): value is TaxStatus;
+declare function isPendingTaxStatus(status: TaxStatus): boolean;
+declare function isPaidTaxStatus(status: TaxStatus): boolean;
+
+/**
+ * @classytic/payroll - Configuration
+ *
+ * Centralized configuration with type safety
+ * Configurable defaults for different use cases
+ */
+
+declare const HRM_CONFIG: HRMConfig;
+/**
+ * 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 - 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;
+    /** Create indexes on schema (default: false) */
+    createIndexes?: boolean;
+    /** Enable leave management methods (default: false) */
+    enableLeave?: boolean;
+    /** Leave configuration */
+    leaveConfig?: LeaveInitConfig;
+    /** Field name for leave balances (default: 'leaveBalances') */
+    leaveBalancesField?: string;
+}
+/**
+ * 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;
+    /**
+     * Create a PayrollError.
+     *
+     * Supports BOTH constructor styles for backwards compatibility:
+     * - new PayrollError(message, code?, status?, context?)
+     * - new PayrollError(code, status, message, context?)
+     */
+    constructor(messageOrCode: string | ErrorCode, codeOrStatus?: ErrorCode | number, statusOrMessage?: number | string, context?: Record<string, unknown>);
+    /**
+     * Convert error to JSON for API responses (ClockIn-compatible shape)
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Check if error is operational (expected) vs programmer error
+     */
+    isOperational(): boolean;
+}
+/**
+ * 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>);
+}
+/**
+ * Invalid employee error
+ */
+declare class InvalidEmployeeError extends PayrollError {
+    constructor(message: 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>);
+}
+/**
+ * Already processed error
+ */
+declare class AlreadyProcessedError extends PayrollError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Not eligible error
+ */
+declare class NotEligibleError extends PayrollError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Create error from code
+ */
+declare function createError(code: ErrorCode, message: string, context?: Record<string, unknown>): PayrollError;
+/**
+ * Check if error is PayrollError
+ */
+declare function isPayrollError(error: unknown): error is PayrollError;
+/**
+ * Extract error info for logging
+ */
+declare function extractErrorInfo(error: unknown): {
+    code: string;
+    status: number;
+    message: string;
+    context?: Record<string, unknown>;
+};
+/**
+ * Convert unknown error to PayrollError
+ */
+declare function toPayrollError(error: unknown): PayrollError;
+
+/**
+ * @classytic/payroll - Attendance Integration
+ *
+ * Native integration with @classytic/clockin.
+ * ClockIn is an optional peer dependency for attendance-based deductions.
+ */
+
+/**
+ * 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<unknown>, params: {
+    organizationId: ObjectIdLike;
+    employeeId: ObjectIdLike;
+    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<unknown>, params: {
+    organizationId: ObjectIdLike;
+    employeeIds: ObjectIdLike[];
+    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 - LeaveRequest Model
+ *
+ * Mongoose schema for leave requests with TTL support
+ */
+
+declare const leaveRequestSchema: mongoose__default.Schema<any, mongoose__default.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    employeeId: mongoose__default.Types.ObjectId;
+    status: "pending" | "cancelled" | "approved" | "rejected";
+    type: "other" | "annual" | "sick" | "unpaid" | "maternity" | "paternity" | "bereavement" | "compensatory";
+    metadata: any;
+    startDate: NativeDate;
+    endDate: NativeDate;
+    days: number;
+    halfDay: boolean;
+    attachments: string[];
+    reason?: string | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    organizationId?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedBy?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedAt?: NativeDate | null | undefined;
+    reviewNotes?: string | null | undefined;
+} & mongoose__default.DefaultTimestampProps, mongoose__default.Document<unknown, {}, {
+    employeeId: mongoose__default.Types.ObjectId;
+    status: "pending" | "cancelled" | "approved" | "rejected";
+    type: "other" | "annual" | "sick" | "unpaid" | "maternity" | "paternity" | "bereavement" | "compensatory";
+    metadata: any;
+    startDate: NativeDate;
+    endDate: NativeDate;
+    days: number;
+    halfDay: boolean;
+    attachments: string[];
+    reason?: string | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    organizationId?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedBy?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedAt?: NativeDate | null | undefined;
+    reviewNotes?: string | null | undefined;
+} & mongoose__default.DefaultTimestampProps, {
+    id: string;
+}, mongoose__default.ResolveSchemaOptions<{
+    timestamps: true;
+}>> & Omit<{
+    employeeId: mongoose__default.Types.ObjectId;
+    status: "pending" | "cancelled" | "approved" | "rejected";
+    type: "other" | "annual" | "sick" | "unpaid" | "maternity" | "paternity" | "bereavement" | "compensatory";
+    metadata: any;
+    startDate: NativeDate;
+    endDate: NativeDate;
+    days: number;
+    halfDay: boolean;
+    attachments: string[];
+    reason?: string | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    organizationId?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedBy?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedAt?: NativeDate | null | undefined;
+    reviewNotes?: string | null | undefined;
+} & mongoose__default.DefaultTimestampProps & {
+    _id: mongoose__default.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    [path: string]: mongoose__default.SchemaDefinitionProperty<undefined, any, any>;
+} | {
+    [x: string]: mongoose__default.SchemaDefinitionProperty<any, any, mongoose__default.Document<unknown, {}, {
+        employeeId: mongoose__default.Types.ObjectId;
+        status: "pending" | "cancelled" | "approved" | "rejected";
+        type: "other" | "annual" | "sick" | "unpaid" | "maternity" | "paternity" | "bereavement" | "compensatory";
+        metadata: any;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        days: number;
+        halfDay: boolean;
+        attachments: string[];
+        reason?: string | null | undefined;
+        userId?: mongoose__default.Types.ObjectId | null | undefined;
+        organizationId?: mongoose__default.Types.ObjectId | null | undefined;
+        reviewedBy?: mongoose__default.Types.ObjectId | null | undefined;
+        reviewedAt?: NativeDate | null | undefined;
+        reviewNotes?: string | null | undefined;
+    } & mongoose__default.DefaultTimestampProps, {
+        id: string;
+    }, mongoose__default.ResolveSchemaOptions<{
+        timestamps: true;
+    }>> & Omit<{
+        employeeId: mongoose__default.Types.ObjectId;
+        status: "pending" | "cancelled" | "approved" | "rejected";
+        type: "other" | "annual" | "sick" | "unpaid" | "maternity" | "paternity" | "bereavement" | "compensatory";
+        metadata: any;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        days: number;
+        halfDay: boolean;
+        attachments: string[];
+        reason?: string | null | undefined;
+        userId?: mongoose__default.Types.ObjectId | null | undefined;
+        organizationId?: mongoose__default.Types.ObjectId | null | undefined;
+        reviewedBy?: mongoose__default.Types.ObjectId | null | undefined;
+        reviewedAt?: NativeDate | null | undefined;
+        reviewNotes?: string | null | undefined;
+    } & mongoose__default.DefaultTimestampProps & {
+        _id: mongoose__default.Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, {
+    employeeId: mongoose__default.Types.ObjectId;
+    status: "pending" | "cancelled" | "approved" | "rejected";
+    type: "other" | "annual" | "sick" | "unpaid" | "maternity" | "paternity" | "bereavement" | "compensatory";
+    metadata: any;
+    startDate: NativeDate;
+    endDate: NativeDate;
+    days: number;
+    halfDay: boolean;
+    attachments: string[];
+    reason?: string | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    organizationId?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedBy?: mongoose__default.Types.ObjectId | null | undefined;
+    reviewedAt?: NativeDate | null | undefined;
+    reviewNotes?: string | null | undefined;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose__default.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+interface LeaveRequestModel extends Model<LeaveRequestDocument> {
+    findByEmployee(employeeId: mongoose__default.Types.ObjectId, options?: {
+        status?: LeaveRequestStatus;
+        year?: number;
+        limit?: number;
+    }): ReturnType<Model<LeaveRequestDocument>['find']>;
+    findPendingByOrganization(organizationId?: mongoose__default.Types.ObjectId): ReturnType<Model<LeaveRequestDocument>['find']>;
+    findByPeriod(organizationId: mongoose__default.Types.ObjectId | undefined, startDate: Date, endDate: Date, options?: {
+        status?: LeaveRequestStatus;
+        type?: LeaveType;
+    }): ReturnType<Model<LeaveRequestDocument>['find']>;
+    getLeaveStats(employeeId: mongoose__default.Types.ObjectId, year: number): Promise<Array<{
+        _id: LeaveType;
+        totalDays: number;
+        count: number;
+    }>>;
+    getOrganizationSummary(organizationId: mongoose__default.Types.ObjectId | undefined, year: number): Promise<Array<{
+        _id: {
+            status: LeaveRequestStatus;
+            type: LeaveType;
+        };
+        totalDays: number;
+        count: number;
+    }>>;
+    findOverlapping(employeeId: mongoose__default.Types.ObjectId, startDate: Date, endDate: Date, excludeRequestId?: mongoose__default.Types.ObjectId): ReturnType<Model<LeaveRequestDocument>['find']>;
+    hasOverlap(employeeId: mongoose__default.Types.ObjectId, startDate: Date, endDate: Date, excludeRequestId?: mongoose__default.Types.ObjectId): Promise<boolean>;
+}
+/**
+ * Get or create LeaveRequest model
+ *
+ * @example
+ * const LeaveRequest = getLeaveRequestModel();
+ *
+ * // With custom connection
+ * const LeaveRequest = getLeaveRequestModel(customConnection);
+ */
+declare function getLeaveRequestModel(connection?: mongoose__default.Connection): LeaveRequestModel;
+
+/**
+ * @classytic/payroll - TaxWithholding Model
+ *
+ * Mongoose schema for tax withholding tracking with aggregation support
+ */
+
+declare const taxWithholdingSchema: mongoose__default.Schema<any, mongoose__default.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    employeeId: mongoose__default.Types.ObjectId;
+    amount: number;
+    status: "pending" | "paid" | "submitted";
+    organizationId: mongoose__default.Types.ObjectId;
+    currency: string;
+    payrollRecordId: mongoose__default.Types.ObjectId;
+    metadata: any;
+    transactionId: mongoose__default.Types.ObjectId;
+    taxableAmount: number;
+    taxType: "other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax";
+    taxRate: number;
+    period?: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate: NativeDate;
+    } | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    referenceNumber?: string | null | undefined;
+    notes?: string | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+    submittedAt?: NativeDate | null | undefined;
+    governmentTransactionId?: mongoose__default.Types.ObjectId | null | undefined;
+} & mongoose__default.DefaultTimestampProps, mongoose__default.Document<unknown, {}, {
+    employeeId: mongoose__default.Types.ObjectId;
+    amount: number;
+    status: "pending" | "paid" | "submitted";
+    organizationId: mongoose__default.Types.ObjectId;
+    currency: string;
+    payrollRecordId: mongoose__default.Types.ObjectId;
+    metadata: any;
+    transactionId: mongoose__default.Types.ObjectId;
+    taxableAmount: number;
+    taxType: "other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax";
+    taxRate: number;
+    period?: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate: NativeDate;
+    } | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    referenceNumber?: string | null | undefined;
+    notes?: string | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+    submittedAt?: NativeDate | null | undefined;
+    governmentTransactionId?: mongoose__default.Types.ObjectId | null | undefined;
+} & mongoose__default.DefaultTimestampProps, {
+    id: string;
+}, mongoose__default.ResolveSchemaOptions<{
+    timestamps: true;
+}>> & Omit<{
+    employeeId: mongoose__default.Types.ObjectId;
+    amount: number;
+    status: "pending" | "paid" | "submitted";
+    organizationId: mongoose__default.Types.ObjectId;
+    currency: string;
+    payrollRecordId: mongoose__default.Types.ObjectId;
+    metadata: any;
+    transactionId: mongoose__default.Types.ObjectId;
+    taxableAmount: number;
+    taxType: "other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax";
+    taxRate: number;
+    period?: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate: NativeDate;
+    } | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    referenceNumber?: string | null | undefined;
+    notes?: string | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+    submittedAt?: NativeDate | null | undefined;
+    governmentTransactionId?: mongoose__default.Types.ObjectId | null | undefined;
+} & mongoose__default.DefaultTimestampProps & {
+    _id: mongoose__default.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    [path: string]: mongoose__default.SchemaDefinitionProperty<undefined, any, any>;
+} | {
+    [x: string]: mongoose__default.SchemaDefinitionProperty<any, any, mongoose__default.Document<unknown, {}, {
+        employeeId: mongoose__default.Types.ObjectId;
+        amount: number;
+        status: "pending" | "paid" | "submitted";
+        organizationId: mongoose__default.Types.ObjectId;
+        currency: string;
+        payrollRecordId: mongoose__default.Types.ObjectId;
+        metadata: any;
+        transactionId: mongoose__default.Types.ObjectId;
+        taxableAmount: number;
+        taxType: "other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax";
+        taxRate: number;
+        period?: {
+            month: number;
+            year: number;
+            startDate: NativeDate;
+            endDate: NativeDate;
+            payDate: NativeDate;
+        } | null | undefined;
+        userId?: mongoose__default.Types.ObjectId | null | undefined;
+        referenceNumber?: string | null | undefined;
+        notes?: string | null | undefined;
+        paidAt?: NativeDate | null | undefined;
+        submittedAt?: NativeDate | null | undefined;
+        governmentTransactionId?: mongoose__default.Types.ObjectId | null | undefined;
+    } & mongoose__default.DefaultTimestampProps, {
+        id: string;
+    }, mongoose__default.ResolveSchemaOptions<{
+        timestamps: true;
+    }>> & Omit<{
+        employeeId: mongoose__default.Types.ObjectId;
+        amount: number;
+        status: "pending" | "paid" | "submitted";
+        organizationId: mongoose__default.Types.ObjectId;
+        currency: string;
+        payrollRecordId: mongoose__default.Types.ObjectId;
+        metadata: any;
+        transactionId: mongoose__default.Types.ObjectId;
+        taxableAmount: number;
+        taxType: "other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax";
+        taxRate: number;
+        period?: {
+            month: number;
+            year: number;
+            startDate: NativeDate;
+            endDate: NativeDate;
+            payDate: NativeDate;
+        } | null | undefined;
+        userId?: mongoose__default.Types.ObjectId | null | undefined;
+        referenceNumber?: string | null | undefined;
+        notes?: string | null | undefined;
+        paidAt?: NativeDate | null | undefined;
+        submittedAt?: NativeDate | null | undefined;
+        governmentTransactionId?: mongoose__default.Types.ObjectId | null | undefined;
+    } & mongoose__default.DefaultTimestampProps & {
+        _id: mongoose__default.Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, {
+    employeeId: mongoose__default.Types.ObjectId;
+    amount: number;
+    status: "pending" | "paid" | "submitted";
+    organizationId: mongoose__default.Types.ObjectId;
+    currency: string;
+    payrollRecordId: mongoose__default.Types.ObjectId;
+    metadata: any;
+    transactionId: mongoose__default.Types.ObjectId;
+    taxableAmount: number;
+    taxType: "other" | "income_tax" | "social_security" | "health_insurance" | "pension" | "employment_insurance" | "local_tax";
+    taxRate: number;
+    period?: {
+        month: number;
+        year: number;
+        startDate: NativeDate;
+        endDate: NativeDate;
+        payDate: NativeDate;
+    } | null | undefined;
+    userId?: mongoose__default.Types.ObjectId | null | undefined;
+    referenceNumber?: string | null | undefined;
+    notes?: string | null | undefined;
+    paidAt?: NativeDate | null | undefined;
+    submittedAt?: NativeDate | null | undefined;
+    governmentTransactionId?: mongoose__default.Types.ObjectId | null | undefined;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose__default.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+interface TaxWithholdingModel extends Model<TaxWithholdingDocument> {
+    findByPeriod(organizationId: mongoose__default.Types.ObjectId, month: number, year: number): ReturnType<Model<TaxWithholdingDocument>['find']>;
+    findByEmployee(employeeId: mongoose__default.Types.ObjectId, options?: {
+        year?: number;
+        taxType?: TaxType;
+        status?: TaxStatus;
+        limit?: number;
+    }): ReturnType<Model<TaxWithholdingDocument>['find']>;
+    findPending(organizationId: mongoose__default.Types.ObjectId, options?: {
+        fromMonth?: number;
+        fromYear?: number;
+        toMonth?: number;
+        toYear?: number;
+        taxType?: TaxType;
+    }): ReturnType<Model<TaxWithholdingDocument>['find']>;
+    getSummaryByType(organizationId: mongoose__default.Types.ObjectId, fromPeriod: {
+        month: number;
+        year: number;
+    }, toPeriod: {
+        month: number;
+        year: number;
+    }): Promise<Array<{
+        taxType: TaxType;
+        totalAmount: number;
+        count: number;
+        withholdingIds: mongoose__default.Types.ObjectId[];
+    }>>;
+    getByPayrollRecord(payrollRecordId: mongoose__default.Types.ObjectId): ReturnType<Model<TaxWithholdingDocument>['find']>;
+    getTotalByOrganization(organizationId: mongoose__default.Types.ObjectId, options?: {
+        status?: TaxStatus;
+        year?: number;
+    }): Promise<{
+        totalAmount: number;
+        count: number;
+    }>;
+}
+/**
+ * Get or create TaxWithholding model
+ *
+ * @example
+ * const TaxWithholding = getTaxWithholdingModel();
+ *
+ * // With custom connection
+ * const TaxWithholding = getTaxWithholdingModel(customConnection);
+ */
+declare function getTaxWithholdingModel(connection?: mongoose__default.Connection): TaxWithholdingModel;
+
+export { ALLOWANCE_TYPE, AlreadyProcessedError, type CreatePayrollTransactionInput, type CreateTaxPaymentTransactionInput, DEDUCTION_TYPE, DEPARTMENT, DeepPartial, Department, DuplicatePayrollError, EMPLOYEE_STATUS, EMPLOYMENT_TYPE, EmployeeNotFoundError, type EmployeePluginOptions, EmployeeTerminatedError, EmploymentType, ErrorCode, HRMConfig, HRM_CONFIG, type Holiday, HttpError, type IPayrollTransaction, type IPayrollTransactionCreateInput, InvalidEmployeeError, LEAVE_REQUEST_STATUS, LEAVE_TYPE, LeaveInitConfig, LeaveRequestDocument, type LeaveRequestModel, LeaveRequestStatus, LeaveType, NotEligibleError, NotInitializedError, ObjectIdLike, OrgRole, PAYMENT_FREQUENCY, PAYROLL_STATUS, PayrollBreakdown, PayrollError, TAX_STATUS, TAX_STATUS_VALUES, TAX_TYPE, TAX_TYPE_VALUES, TERMINATION_REASON, TaxStatus, TaxType, TaxWithholdingDocument, type TaxWithholdingModel, TransactionFactory, ValidationError, batchGetAttendance, createError, createHolidaySchema, createPayrollTransaction, createTaxPaymentTransaction, determineOrgRole, employeePlugin, extractErrorInfo, getAttendance, getHolidays, getLeaveRequestModel, getTaxWithholdingModel, isApprovedLeaveStatus, isPaidLeaveType, isPaidTaxStatus, isPayrollError, isPayrollTransaction, isPendingLeaveStatus, isPendingTaxStatus, isValidLeaveRequestStatus, isValidLeaveType, isValidTaxStatus, isValidTaxType, leaveRequestSchema, mergeConfig, taxWithholdingSchema, toPayrollError };