@classytic/payroll 2.7.5 → 2.8.0

package/dist/payroll-states-DBt0XVm-.d.ts

@@ -0,0 +1,598 @@
+import { a2 as ObjectIdLike, a3 as ObjectId } from './types-bZdAJueH.js';
+import { Plugin } from '@classytic/mongokit';
+
+/**
+ * Idempotency Manager
+ *
+ * Ensures operations are not duplicated when called with the same key.
+ * Uses Stripe-style idempotency pattern for payroll operations.
+ *
+ * ## Key Format (v2.9.0+)
+ *
+ * Idempotency keys support multiple payroll frequencies:
+ *
+ * **Monthly frequency:**
+ * ```
+ * payroll:{organizationId}:{employeeId}:{year}-{month}:{payrollRunType}
+ * ```
+ *
+ * **Non-monthly frequencies (weekly, bi_weekly, daily, hourly):**
+ * ```
+ * payroll:{organizationId}:{employeeId}:{year}-{month}:{startDate}:{payrollRunType}
+ * ```
+ *
+ * This allows:
+ * - Different payroll types (regular, supplemental, retroactive) in the same period
+ * - Multiple weekly/bi-weekly/daily payroll runs within the same calendar month
+ *
+ * ## Important: In-Memory Cache Limitations
+ *
+ * This implementation uses an **in-memory LRU cache** which has the following limitations:
+ *
+ * - **Does NOT persist across server restarts** - cache is lost on restart
+ * - **Does NOT work across multiple server instances** - each instance has its own cache
+ * - **Only prevents duplicates within the same process lifetime**
+ *
+ * For production deployments with horizontal scaling or high availability requirements,
+ * you should implement database-backed idempotency. See the Payroll class documentation
+ * for implementation examples.
+ *
+ * ## Duplicate Protection (v2.9.0+)
+ *
+ * Primary duplicate protection is via **database unique compound index**:
+ * `{ organizationId, employeeId, period.month, period.year, period.startDate, payrollRunType }`
+ *
+ * This prevents race conditions under concurrent load. The partial filter
+ * excludes voided records to allow re-processing after restoration.
+ *
+ * The in-memory cache is a secondary optimization layer, not the primary protection.
+ *
+ * @see https://stripe.com/docs/api/idempotent_requests
+ */
+
+interface IdempotentResult<T = unknown> {
+    value: T;
+    cached: boolean;
+    createdAt: Date;
+}
+/**
+ * In-memory idempotency manager for preventing duplicate operations.
+ *
+ * @warning This is an in-memory cache. For production horizontal scaling,
+ * implement database-backed idempotency instead.
+ */
+declare class IdempotencyManager {
+    private cache;
+    private static hasLoggedWarning;
+    constructor(options?: {
+        max?: number;
+        ttl?: number;
+        suppressWarning?: boolean;
+    });
+    /**
+     * Check if key exists and return cached result
+     */
+    get<T>(key: string): IdempotentResult<T> | null;
+    /**
+     * Store result for idempotency key
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * Execute function with idempotency protection
+     */
+    execute<T>(key: string, fn: () => Promise<T>): Promise<IdempotentResult<T>>;
+    /**
+     * Clear a specific key
+     */
+    delete(key: string): void;
+    /**
+     * Clear all keys
+     */
+    clear(): void;
+    /**
+     * Get cache stats
+     */
+    stats(): {
+        size: number;
+        max: number;
+    };
+}
+/**
+ * Payroll run types for idempotency key generation
+ */
+type PayrollRunType = 'regular' | 'off-cycle' | 'supplemental' | 'retroactive';
+/**
+ * Generate idempotency key for payroll operations
+ *
+ * Includes payrollRunType to allow multiple payroll runs per period
+ * (e.g., regular + supplemental bonus + retroactive adjustment)
+ *
+ * For non-monthly frequencies (weekly, bi_weekly, daily, hourly), the periodStartDate
+ * is included to differentiate multiple runs within the same calendar month.
+ *
+ * @param organizationId - Organization ID
+ * @param employeeId - Employee ID
+ * @param month - Payroll month (1-12)
+ * @param year - Payroll year
+ * @param payrollRunType - Type of payroll run (default: 'regular')
+ * @param periodStartDate - Period start date (required for non-monthly frequencies)
+ */
+declare function generatePayrollIdempotencyKey(organizationId: ObjectIdLike, employeeId: ObjectIdLike, month: number, year: number, payrollRunType?: PayrollRunType, periodStartDate?: Date): string;
+
+/**
+ * Repository plugins for mongokit integration
+ */
+
+/**
+ * Multi-tenant plugin - automatically injects organizationId into all repository operations.
+ *
+ * Hooks into create, getAll, getById, getByQuery, update, and delete operations
+ * to enforce organizational isolation. The organizationId is force-set on creates
+ * (cannot be overridden by caller) and added as a filter on all read/write operations.
+ *
+ * @param organizationId - Organization ID to scope all operations to. If undefined, plugin is a no-op.
+ * @returns Mongokit Plugin instance
+ *
+ * @example
+ * ```typescript
+ * import { multiTenantPlugin } from '@classytic/payroll';
+ * import { Repository } from '@classytic/mongokit';
+ *
+ * const repo = new Repository(EmployeeModel, [
+ *   multiTenantPlugin(organizationId),
+ * ]);
+ *
+ * // All operations auto-scoped to organizationId
+ * await repo.getAll({ filters: { status: 'active' } });
+ * // Executes: { organizationId, status: 'active' }
+ * ```
+ */
+declare function multiTenantPlugin(organizationId?: ObjectId): Plugin;
+
+/**
+ * @classytic/payroll - Timeline Audit Integration
+ *
+ * Integration with @classytic/mongoose-timeline-audit for comprehensive audit trails.
+ * Provides automatic tracking of WHO performed WHAT action and WHEN.
+ *
+ * ## Setup
+ *
+ * 1. Install mongoose-timeline-audit:
+ *    ```bash
+ *    npm install @classytic/mongoose-timeline-audit
+ *    ```
+ *
+ * 2. Apply to your schemas BEFORE registering with Mongoose:
+ *    ```typescript
+ *    import timelineAuditPlugin from '@classytic/mongoose-timeline-audit';
+ *    import { PAYROLL_EVENTS } from '@classytic/payroll';
+ *
+ *    // Apply to Employee schema
+ *    employeeSchema.plugin(timelineAuditPlugin, {
+ *      ownerField: 'organizationId',
+ *      eventLimits: PAYROLL_EVENTS.EMPLOYEE.limits,
+ *    });
+ *
+ *    // Apply to PayrollRecord schema
+ *    payrollRecordSchema.plugin(timelineAuditPlugin, {
+ *      ownerField: 'organizationId',
+ *      eventLimits: PAYROLL_EVENTS.PAYROLL.limits,
+ *    });
+ *    ```
+ *
+ * 3. Use the Payroll events to add timeline entries:
+ *    ```typescript
+ *    payroll.on('employee:hired', async ({ data }) => {
+ *      const employee = await Employee.findById(data.employee.id);
+ *      employee.addTimelineEvent(
+ *        PAYROLL_EVENTS.EMPLOYEE.HIRED,
+ *        `Hired as ${data.employee.position}`,
+ *        request,  // Express request for actor tracking
+ *        { department: data.employee.department }
+ *      );
+ *      await employee.save();
+ *    });
+ *    ```
+ *
+ * @module @classytic/payroll/timeline-audit
+ */
+/**
+ * Standard payroll events for timeline tracking
+ *
+ * Use these constants with mongoose-timeline-audit's addTimelineEvent()
+ * to maintain consistent event naming across your application.
+ */
+declare const PAYROLL_EVENTS: {
+    /**
+     * Employee lifecycle events
+     */
+    readonly EMPLOYEE: {
+        /** Employee was hired */
+        readonly HIRED: "employee.hired";
+        /** Employee was terminated */
+        readonly TERMINATED: "employee.terminated";
+        /** Employee was re-hired after termination */
+        readonly REHIRED: "employee.rehired";
+        /** Employee status changed (active, on_leave, suspended) */
+        readonly STATUS_CHANGED: "employee.status_changed";
+        /** Employee department/position changed */
+        readonly ROLE_CHANGED: "employee.role_changed";
+        /** Employee probation ended */
+        readonly PROBATION_ENDED: "employee.probation_ended";
+        /** Recommended event limits for employee timeline */
+        readonly limits: {
+            readonly 'employee.status_changed': 50;
+            readonly 'employee.role_changed': 20;
+        };
+    };
+    /**
+     * Compensation events
+     */
+    readonly COMPENSATION: {
+        /** Base salary was updated */
+        readonly SALARY_UPDATED: "compensation.salary_updated";
+        /** Allowance was added */
+        readonly ALLOWANCE_ADDED: "compensation.allowance_added";
+        /** Allowance was removed */
+        readonly ALLOWANCE_REMOVED: "compensation.allowance_removed";
+        /** Deduction was added */
+        readonly DEDUCTION_ADDED: "compensation.deduction_added";
+        /** Deduction was removed */
+        readonly DEDUCTION_REMOVED: "compensation.deduction_removed";
+        /** Bank details were updated */
+        readonly BANK_UPDATED: "compensation.bank_updated";
+        /** Recommended event limits */
+        readonly limits: {
+            readonly 'compensation.salary_updated': 24;
+            readonly 'compensation.allowance_added': 20;
+            readonly 'compensation.allowance_removed': 20;
+            readonly 'compensation.deduction_added': 20;
+            readonly 'compensation.deduction_removed': 20;
+            readonly 'compensation.bank_updated': 10;
+        };
+    };
+    /**
+     * Payroll processing events
+     */
+    readonly PAYROLL: {
+        /** Salary was processed */
+        readonly PROCESSED: "payroll.processed";
+        /** Payroll was voided (before payment) */
+        readonly VOIDED: "payroll.voided";
+        /** Payroll was reversed (after payment) */
+        readonly REVERSED: "payroll.reversed";
+        /** Payroll was restored from voided state */
+        readonly RESTORED: "payroll.restored";
+        /** Payroll export was generated */
+        readonly EXPORTED: "payroll.exported";
+        /** Recommended event limits */
+        readonly limits: {
+            readonly 'payroll.processed': 36;
+            readonly 'payroll.voided': 10;
+            readonly 'payroll.reversed': 10;
+            readonly 'payroll.restored': 5;
+            readonly 'payroll.exported': 20;
+        };
+    };
+    /**
+     * Tax withholding events
+     */
+    readonly TAX: {
+        /** Tax was withheld */
+        readonly WITHHELD: "tax.withheld";
+        /** Tax was submitted to authorities */
+        readonly SUBMITTED: "tax.submitted";
+        /** Tax payment was made */
+        readonly PAID: "tax.paid";
+        /** Tax withholding was cancelled */
+        readonly CANCELLED: "tax.cancelled";
+        /** Recommended event limits */
+        readonly limits: {
+            readonly 'tax.withheld': 36;
+            readonly 'tax.submitted': 12;
+            readonly 'tax.paid': 12;
+            readonly 'tax.cancelled': 10;
+        };
+    };
+    /**
+     * Leave management events
+     */
+    readonly LEAVE: {
+        /** Leave was requested */
+        readonly REQUESTED: "leave.requested";
+        /** Leave was approved */
+        readonly APPROVED: "leave.approved";
+        /** Leave was rejected */
+        readonly REJECTED: "leave.rejected";
+        /** Leave was cancelled */
+        readonly CANCELLED: "leave.cancelled";
+        /** Leave balance was accrued */
+        readonly ACCRUED: "leave.accrued";
+        /** Annual leave was reset */
+        readonly RESET: "leave.reset";
+        /** Recommended event limits */
+        readonly limits: {
+            readonly 'leave.requested': 50;
+            readonly 'leave.approved': 50;
+            readonly 'leave.rejected': 20;
+            readonly 'leave.cancelled': 20;
+            readonly 'leave.accrued': 12;
+            readonly 'leave.reset': 5;
+        };
+    };
+};
+/**
+ * All payroll event types (for TypeScript)
+ */
+type PayrollTimelineEvent = typeof PAYROLL_EVENTS.EMPLOYEE[keyof typeof PAYROLL_EVENTS.EMPLOYEE] | typeof PAYROLL_EVENTS.COMPENSATION[keyof typeof PAYROLL_EVENTS.COMPENSATION] | typeof PAYROLL_EVENTS.PAYROLL[keyof typeof PAYROLL_EVENTS.PAYROLL] | typeof PAYROLL_EVENTS.TAX[keyof typeof PAYROLL_EVENTS.TAX] | typeof PAYROLL_EVENTS.LEAVE[keyof typeof PAYROLL_EVENTS.LEAVE];
+/**
+ * Recommended timeline audit configuration for Employee model
+ */
+declare const EMPLOYEE_TIMELINE_CONFIG: {
+    ownerField: string;
+    fieldName: string;
+    hideByDefault: boolean;
+    eventLimits: {
+        'compensation.salary_updated': 24;
+        'compensation.allowance_added': 20;
+        'compensation.allowance_removed': 20;
+        'compensation.deduction_added': 20;
+        'compensation.deduction_removed': 20;
+        'compensation.bank_updated': 10;
+        'employee.status_changed': 50;
+        'employee.role_changed': 20;
+    };
+};
+/**
+ * Recommended timeline audit configuration for PayrollRecord model
+ */
+declare const PAYROLL_RECORD_TIMELINE_CONFIG: {
+    ownerField: string;
+    fieldName: string;
+    hideByDefault: boolean;
+    eventLimits: {
+        readonly 'payroll.processed': 36;
+        readonly 'payroll.voided': 10;
+        readonly 'payroll.reversed': 10;
+        readonly 'payroll.restored': 5;
+        readonly 'payroll.exported': 20;
+    };
+};
+/**
+ * Recommended timeline audit configuration for LeaveRequest model
+ */
+declare const LEAVE_REQUEST_TIMELINE_CONFIG: {
+    ownerField: string;
+    fieldName: string;
+    hideByDefault: boolean;
+    eventLimits: {
+        readonly 'leave.requested': 50;
+        readonly 'leave.approved': 50;
+        readonly 'leave.rejected': 20;
+        readonly 'leave.cancelled': 20;
+        readonly 'leave.accrued': 12;
+        readonly 'leave.reset': 5;
+    };
+};
+/**
+ * Build timeline event metadata from payroll context
+ *
+ * @param context - Operation context from payroll methods
+ * @returns Metadata object for timeline event
+ *
+ * @example
+ * ```typescript
+ * employee.addTimelineEvent(
+ *   PAYROLL_EVENTS.EMPLOYEE.HIRED,
+ *   'Hired as Software Engineer',
+ *   request,
+ *   buildTimelineMetadata(params.context)
+ * );
+ * ```
+ */
+declare function buildTimelineMetadata(context?: {
+    userId?: unknown;
+    userName?: string;
+    userRole?: string;
+    organizationId?: unknown;
+}): Record<string, unknown>;
+/**
+ * Build context object for timeline event (IP, user agent, etc.)
+ *
+ * @param request - Express/Fastify request object
+ * @returns Context object for timeline event
+ *
+ * @example
+ * ```typescript
+ * employee.addTimelineEvent(
+ *   PAYROLL_EVENTS.COMPENSATION.SALARY_UPDATED,
+ *   `Salary updated to ${newSalary}`,
+ *   request,
+ *   { previousSalary, newSalary },
+ *   buildRequestContext(request)
+ * );
+ * ```
+ */
+declare function buildRequestContext(request?: {
+    ip?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    get?: (header: string) => string | undefined;
+}): Record<string, unknown> | undefined;
+
+/**
+ * @classytic/payroll - State Machine
+ *
+ * Minimal state machine implementation for status management.
+ * Enforces valid transitions and provides clear error messages.
+ */
+/**
+ * State transition definition
+ */
+interface StateTransition<TState extends string> {
+    from: TState | TState[];
+    to: TState;
+}
+/**
+ * State machine configuration
+ */
+interface StateMachineConfig<TState extends string> {
+    /** All valid states */
+    states: readonly TState[];
+    /** Initial state */
+    initial: TState;
+    /** Valid transitions */
+    transitions: StateTransition<TState>[];
+    /** Terminal states (no outgoing transitions) */
+    terminal?: TState[];
+}
+/**
+ * Transition result
+ */
+type TransitionResult<TState extends string> = {
+    success: true;
+    from: TState;
+    to: TState;
+} | {
+    success: false;
+    from: TState;
+    to: TState;
+    error: string;
+};
+/**
+ * Minimal state machine for status management
+ *
+ * @example
+ * const machine = new StateMachine({
+ *   states: ['pending', 'processing', 'paid', 'voided'] as const,
+ *   initial: 'pending',
+ *   transitions: [
+ *     { from: 'pending', to: 'processing' },
+ *     { from: 'pending', to: 'voided' },
+ *     { from: 'processing', to: 'paid' },
+ *   ],
+ *   terminal: ['paid', 'voided'],
+ * });
+ *
+ * machine.canTransition('pending', 'processing'); // true
+ * machine.canTransition('paid', 'pending'); // false
+ */
+declare class StateMachine<TState extends string> {
+    private readonly config;
+    private readonly validTransitions;
+    private readonly terminalStates;
+    constructor(config: StateMachineConfig<TState>);
+    /**
+     * Get the initial state
+     */
+    get initial(): TState;
+    /**
+     * Get all valid states
+     */
+    get states(): readonly TState[];
+    /**
+     * Check if a state is valid
+     */
+    isValidState(state: string): state is TState;
+    /**
+     * Check if a state is terminal (no outgoing transitions)
+     */
+    isTerminal(state: TState): boolean;
+    /**
+     * Check if transition from one state to another is valid
+     */
+    canTransition(from: TState, to: TState): boolean;
+    /**
+     * Get all valid next states from current state
+     */
+    getNextStates(from: TState): TState[];
+    /**
+     * Validate a transition and return result
+     */
+    validateTransition(from: TState, to: TState): TransitionResult<TState>;
+    /**
+     * Assert a transition is valid, throw if not
+     */
+    assertTransition(from: TState, to: TState): void;
+}
+/**
+ * Create a state machine instance
+ */
+declare function createStateMachine<TState extends string>(config: StateMachineConfig<TState>): StateMachine<TState>;
+
+/**
+ * @classytic/payroll - Payroll State Machines
+ *
+ * Defines valid state transitions for all status types.
+ * Single source of truth for status management.
+ */
+
+/**
+ * PayrollStatus state machine
+ *
+ * State diagram:
+ * ```
+ * PENDING ──┬──> PROCESSING ──┬──> PAID ──> REVERSED
+ *           │        │        │
+ *           │        │        └──> FAILED ──┐
+ *           │        │                      │
+ *           │        └──> VOIDED <──────────┘
+ *           │              ↑
+ *           └──────────────┘
+ * ```
+ *
+ * - PENDING: Initial state, payroll created but not processed
+ * - PROCESSING: Currently being processed (bulk operations)
+ * - PAID: Payment completed successfully
+ * - FAILED: Processing failed (can retry → pending, or void)
+ * - VOIDED: Cancelled before payment (can restore → pending)
+ * - REVERSED: Payment reversed after completion (terminal)
+ */
+declare const PayrollStatusMachine: StateMachine<"pending" | "processing" | "paid" | "failed" | "voided" | "reversed">;
+type PayrollStatusState = typeof PayrollStatusMachine.states[number];
+/**
+ * TaxStatus state machine
+ *
+ * State diagram:
+ * ```
+ * PENDING ──┬──> SUBMITTED ──> PAID
+ *           │
+ *           └──> CANCELLED
+ * ```
+ *
+ * - PENDING: Tax withheld, not yet submitted to government
+ * - SUBMITTED: Submitted to tax authority, awaiting confirmation
+ * - PAID: Payment confirmed by tax authority
+ * - CANCELLED: Invalidated (payroll voided/reversed)
+ */
+declare const TaxStatusMachine: StateMachine<"pending" | "paid" | "cancelled" | "submitted">;
+type TaxStatusState = typeof TaxStatusMachine.states[number];
+/**
+ * LeaveRequestStatus state machine
+ *
+ * State diagram:
+ * ```
+ * PENDING ──┬──> APPROVED
+ *           │
+ *           ├──> REJECTED
+ *           │
+ *           └──> CANCELLED
+ * ```
+ */
+declare const LeaveRequestStatusMachine: StateMachine<"pending" | "approved" | "rejected" | "cancelled">;
+type LeaveRequestStatusState = typeof LeaveRequestStatusMachine.states[number];
+/**
+ * EmployeeStatus state machine
+ *
+ * State diagram:
+ * ```
+ * ACTIVE ←──┬──→ ON_LEAVE
+ *           │
+ *           ├──→ SUSPENDED ──→ ACTIVE
+ *           │
+ *           └──→ TERMINATED
+ * ```
+ */
+declare const EmployeeStatusMachine: StateMachine<"active" | "on_leave" | "suspended" | "terminated">;
+type EmployeeStatusState = typeof EmployeeStatusMachine.states[number];
+
+export { EMPLOYEE_TIMELINE_CONFIG as E, IdempotencyManager as I, LEAVE_REQUEST_TIMELINE_CONFIG as L, PAYROLL_EVENTS as P, StateMachine as S, TaxStatusMachine as T, EmployeeStatusMachine as a, type EmployeeStatusState as b, type IdempotentResult as c, LeaveRequestStatusMachine as d, type LeaveRequestStatusState as e, PAYROLL_RECORD_TIMELINE_CONFIG as f, PayrollStatusMachine as g, type PayrollStatusState as h, type PayrollTimelineEvent as i, type StateMachineConfig as j, type StateTransition as k, type TaxStatusState as l, type TransitionResult as m, buildRequestContext as n, buildTimelineMetadata as o, createStateMachine as p, generatePayrollIdempotencyKey as q, multiTenantPlugin as r };

package/dist/{prorating.calculator-C7sdFiG2.d.ts → prorating.calculator-C33fWBQf.d.ts}

@@ -33,7 +33,7 @@ interface ProRatingInput {
      */
     periodEnd: Date;
     /**
-     * Working days of the week (1=Monday, 7=Sunday)
+     * Working days of the week using Date.getDay() convention (0=Sunday, 1=Monday, ..., 6=Saturday)
      * @default [1, 2, 3, 4, 5] (Monday-Friday)
      */
     workingDays: number[];
@@ -132,4 +132,4 @@ declare function applyProRating(baseAmount: number, ratio: number): number;
  */
 declare function shouldProRate(hireDate: Date, terminationDate: Date | null, periodStart: Date, periodEnd: Date): boolean;
 
-export { type ProRatingInput as P, applyProRating as a, type ProRatingResult as b, calculateProRating as c, shouldProRate as s };
+export { type ProRatingInput as P, type ProRatingResult as a, applyProRating as b, calculateProRating as c, shouldProRate as s };

package/dist/schemas/index.d.ts

@@ -1,4 +1,4 @@
 import 'bson';
 import 'mongoose';
-export { P as PayrollSchemaOptions, a as allowanceSchema, b as applyEmployeeIndexes, c as applyLeaveRequestIndexes, d as applyPayrollRecordIndexes, e as applyTaxWithholdingIndexes, f as bankDetailsSchema, g as compensationSchema, h as createEmployeeSchema, i as createEmploymentFields, j as createPayrollRecordFields, k as createPayrollRecordSchema, l as deductionSchema, _ as default, z as employeeIndexes, m as employmentHistorySchema, n as getLeaveRequestFields, o as getLeaveRequestModel, p as getTaxWithholdingFields, q as getTaxWithholdingModel, r as leaveBalanceFields, s as leaveBalanceSchema, t as leaveRequestIndexes, u as leaveRequestSchema, A as leaveRequestTTLIndex, B as payrollBreakdownSchema, C as payrollRecordIndexes, v as payrollStatsSchema, D as periodSchema, w as taxWithholdingIndexes, x as taxWithholdingSchema, y as workScheduleSchema } from '../index-DjB72l6e.js';
-import '../types-BVDjiVGS.js';
+export { P as PayrollSchemaOptions, a as allowanceSchema, b as applyEmployeeIndexes, c as applyLeaveRequestIndexes, d as applyPayrollRecordIndexes, e as applyTaxWithholdingIndexes, f as bankDetailsSchema, g as compensationSchema, h as createEmployeeSchema, i as createEmploymentFields, j as createPayrollRecordFields, k as createPayrollRecordSchema, l as deductionSchema, _ as default, m as employeeIndexes, n as employmentHistorySchema, o as getLeaveRequestFields, p as getLeaveRequestModel, q as getTaxWithholdingFields, r as getTaxWithholdingModel, s as leaveBalanceFields, t as leaveBalanceSchema, u as leaveRequestIndexes, v as leaveRequestSchema, B as leaveRequestTTLIndex, C as payrollBreakdownSchema, w as payrollRecordIndexes, x as payrollStatsSchema, D as periodSchema, y as taxWithholdingIndexes, z as taxWithholdingSchema, A as workScheduleSchema } from '../index-BKLkuSAs.js';
+import '../types-bZdAJueH.js';