@classytic/payroll 2.7.5 → 2.8.0

package/dist/core/index.d.ts

@@ -0,0 +1,321 @@
+import { E as EmployeeDocument, P as PayrollRecordDocument, A as AnyDocument, L as LeaveRequestDocument, T as TaxWithholdingDocument, H as HRMConfig, S as SingleTenantConfig, a as Logger } from '../types-bZdAJueH.js';
+export { b as AttendanceInput, C as CompensationChangedEventPayload, D as DEFAULT_WORK_SCHEDULE, c as EmployeeHiredEventPayload, d as EmployeeRehiredEventPayload, e as EmployeeTerminatedEventPayload, f as EventBus, M as MilestoneAchievedEventPayload, N as NotificationPluginOptions, g as PayrollCompletedEventPayload, h as PayrollEventHandler, i as PayrollEventMap, j as PayrollEventType, k as PayrollExportedEventPayload, l as PayrollPluginDefinition, m as PayrollProcessingOptions, n as PluginContext, o as PluginHooks, p as PluginLogger, q as PluginManager, r as ProrationResult, s as SalaryFailedEventPayload, t as SalaryProcessedEventPayload, u as SalaryUpdatedEventPayload, W as WebhookConfig, v as WebhookDelivery, w as WebhookManager, x as WorkSchedule, y as WorkingDaysResult, z as calculateProration, B as countWorkingDays, F as createEventBus, G as createNotificationPlugin, I as definePlugin, J as getEventBus, K as getPayPeriod, O as loggingPlugin, Q as metricsPlugin, R as notificationPlugin, U as onEmployeeHired, V as onMilestoneAchieved, X as onPayrollCompleted, Y as onSalaryProcessed, Z as resetEventBus } from '../types-bZdAJueH.js';
+export { E as EMPLOYEE_TIMELINE_CONFIG, a as EmployeeStatusMachine, b as EmployeeStatusState, I as IdempotencyManager, c as IdempotentResult, L as LEAVE_REQUEST_TIMELINE_CONFIG, d as LeaveRequestStatusMachine, e as LeaveRequestStatusState, P as PAYROLL_EVENTS, f as PAYROLL_RECORD_TIMELINE_CONFIG, g as PayrollStatusMachine, h as PayrollStatusState, i as PayrollTimelineEvent, S as StateMachine, j as StateMachineConfig, k as StateTransition, T as TaxStatusMachine, l as TaxStatusState, m as TransitionResult, n as buildRequestContext, o as buildTimelineMetadata, p as createStateMachine, q as generatePayrollIdempotencyKey, r as multiTenantPlugin } from '../payroll-states-DBt0XVm-.js';
+import { Model, ClientSession } from 'mongoose';
+export { c as calculateAttendanceDeduction, g as calculateSalaryBreakdown } from '../attendance.calculator-BZcv2iii.js';
+import '@classytic/mongokit';
+
+/**
+ * @classytic/payroll - Result Type
+ *
+ * Rust-inspired Result type for type-safe error handling
+ * No more try/catch everywhere - explicit error handling
+ */
+/** Success result */
+interface Ok<T> {
+    readonly ok: true;
+    readonly value: T;
+}
+/** Error result */
+interface Err<E> {
+    readonly ok: false;
+    readonly error: E;
+}
+/**
+ * Create a success result
+ */
+declare function ok<T>(value: T): Ok<T>;
+/**
+ * Create an error result
+ */
+declare function err<E>(error: E): Err<E>;
+/**
+ * Check if result is success
+ */
+declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+/**
+ * Check if result is error
+ */
+declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+/**
+ * Unwrap result value or throw error
+ */
+declare function unwrap<T, E>(result: Result<T, E>): T;
+/**
+ * Unwrap result value or return default
+ */
+declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+/**
+ * Unwrap result value or compute default
+ */
+declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
+/**
+ * Map success value
+ */
+declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Map error value
+ */
+declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+/**
+ * FlatMap (chain) success value
+ */
+declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/**
+ * Try/catch wrapper for async functions
+ */
+declare function tryCatch<T, E = Error>(fn: () => Promise<T>, errorTransform?: (error: unknown) => E): Promise<Result<T, E>>;
+/**
+ * Try/catch wrapper for sync functions
+ */
+declare function tryCatchSync<T, E = Error>(fn: () => T, errorTransform?: (error: unknown) => E): Result<T, E>;
+/**
+ * Combine multiple results into one
+ */
+declare function all<T, E>(results: Result<T, E>[]): Result<T[], E>;
+/**
+ * Pattern match on result
+ */
+declare function match<T, E, R>(result: Result<T, E>, handlers: {
+    ok: (value: T) => R;
+    err: (error: E) => R;
+}): R;
+/**
+ * Convert Promise<Result> to Result<Promise>
+ */
+declare function fromPromise<T, E = Error>(promise: Promise<T>, errorTransform?: (error: unknown) => E): Promise<Result<T, E>>;
+/**
+ * Create Result from nullable value
+ */
+declare function fromNullable<T, E>(value: T | null | undefined, error: E): Result<T, E>;
+declare class ResultClass<T, E = Error> {
+    private readonly result;
+    private constructor();
+    static ok<T>(value: T): ResultClass<T, never>;
+    static err<E>(error: E): ResultClass<never, E>;
+    static fromAsync<T, E = Error>(fn: () => Promise<T>, errorTransform?: (error: unknown) => E): Promise<ResultClass<T, E>>;
+    isOk(): boolean;
+    isErr(): boolean;
+    unwrap(): T;
+    unwrapOr(defaultValue: T): T;
+    map<U>(fn: (value: T) => U): ResultClass<U, E>;
+    mapErr<F>(fn: (error: E) => F): ResultClass<T, F>;
+    flatMap<U>(fn: (value: T) => Result<U, E>): ResultClass<U, E>;
+    match<R>(handlers: {
+        ok: (value: T) => R;
+        err: (error: E) => R;
+    }): R;
+    toResult(): Result<T, E>;
+}
+/** Result type - either success or error */
+type Result<T, E = Error> = Ok<T> | Err<E>;
+declare const Result: {
+    ok: typeof ok;
+    err: typeof err;
+    isOk: typeof isOk;
+    isErr: typeof isErr;
+    unwrap: typeof unwrap;
+    unwrapOr: typeof unwrapOr;
+    unwrapOrElse: typeof unwrapOrElse;
+    map: typeof map;
+    mapErr: typeof mapErr;
+    flatMap: typeof flatMap;
+    tryCatch: typeof tryCatch;
+    tryCatchSync: typeof tryCatchSync;
+    all: typeof all;
+    match: typeof match;
+    fromPromise: typeof fromPromise;
+    fromNullable: typeof fromNullable;
+};
+
+/**
+ * @classytic/payroll - Dependency Container
+ *
+ * Per-instance dependency injection container for service management.
+ * Enables clean dependency injection and testing without global state.
+ *
+ * IMPORTANT: This container is instance-based (not a singleton) to support:
+ * - Serverless/Lambda environments
+ * - Multi-app runtimes
+ * - Parallel testing
+ * - Multiple Payroll instances in the same process
+ */
+
+/**
+ * Strongly-typed models container
+ * Uses specific document types instead of Model<any> for better DX
+ */
+interface ModelsContainer<TEmployee extends EmployeeDocument = EmployeeDocument, TPayrollRecord extends PayrollRecordDocument = PayrollRecordDocument, TTransaction extends AnyDocument = AnyDocument, TAttendance extends AnyDocument = AnyDocument, TLeaveRequest extends LeaveRequestDocument = LeaveRequestDocument, TTaxWithholding extends TaxWithholdingDocument = TaxWithholdingDocument> {
+    EmployeeModel: Model<TEmployee>;
+    PayrollRecordModel: Model<TPayrollRecord>;
+    TransactionModel: Model<TTransaction>;
+    AttendanceModel?: Model<TAttendance> | null;
+    LeaveRequestModel?: Model<TLeaveRequest> | null;
+    TaxWithholdingModel?: Model<TTaxWithholding> | null;
+}
+/**
+ * Container configuration with generic model types
+ */
+interface ContainerConfig<TEmployee extends EmployeeDocument = EmployeeDocument, TPayrollRecord extends PayrollRecordDocument = PayrollRecordDocument, TTransaction extends AnyDocument = AnyDocument, TAttendance extends AnyDocument = AnyDocument, TLeaveRequest extends LeaveRequestDocument = LeaveRequestDocument, TTaxWithholding extends TaxWithholdingDocument = TaxWithholdingDocument> {
+    models: ModelsContainer<TEmployee, TPayrollRecord, TTransaction, TAttendance, TLeaveRequest, TTaxWithholding>;
+    config?: Partial<HRMConfig>;
+    singleTenant?: SingleTenantConfig | null;
+    logger?: Logger;
+}
+/**
+ * Per-instance DI Container for Payroll
+ *
+ * Each Payroll instance creates its own Container, avoiding global state issues
+ * in serverless and multi-app environments.
+ *
+ * @example
+ * ```typescript
+ * // Each Payroll instance has its own container
+ * const payroll1 = createPayrollInstance()
+ *   .withModels({ EmployeeModel, PayrollRecordModel, TransactionModel })
+ *   .build();
+ *
+ * const payroll2 = createPayrollInstance()
+ *   .withModels({ OtherEmployeeModel, OtherPayrollModel, OtherTransactionModel })
+ *   .build();
+ *
+ * // They don't share state - perfect for multi-tenant or testing
+ * ```
+ */
+declare class Container<TEmployee extends EmployeeDocument = EmployeeDocument, TPayrollRecord extends PayrollRecordDocument = PayrollRecordDocument, TTransaction extends AnyDocument = AnyDocument, TAttendance extends AnyDocument = AnyDocument, TLeaveRequest extends LeaveRequestDocument = LeaveRequestDocument, TTaxWithholding extends TaxWithholdingDocument = TaxWithholdingDocument> {
+    private _models;
+    private _config;
+    private _singleTenant;
+    private _logger;
+    private _initialized;
+    constructor();
+    /**
+     * Initialize container with configuration
+     */
+    initialize(config: ContainerConfig<TEmployee, TPayrollRecord, TTransaction, TAttendance, TLeaveRequest, TTaxWithholding>): void;
+    /**
+     * Check if container is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Reset container (useful for testing)
+     */
+    reset(): void;
+    /**
+     * Ensure container is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Get models container (strongly typed)
+     */
+    getModels(): ModelsContainer<TEmployee, TPayrollRecord, TTransaction, TAttendance, TLeaveRequest, TTaxWithholding>;
+    /**
+     * Get Employee model (strongly typed)
+     */
+    getEmployeeModel(): Model<TEmployee>;
+    /**
+     * Get PayrollRecord model (strongly typed)
+     */
+    getPayrollRecordModel(): Model<TPayrollRecord>;
+    /**
+     * Get Transaction model (strongly typed)
+     */
+    getTransactionModel(): Model<TTransaction>;
+    /**
+     * Get Attendance model (optional, strongly typed)
+     */
+    getAttendanceModel(): Model<TAttendance> | null;
+    /**
+     * Get LeaveRequest model (optional, strongly typed)
+     */
+    getLeaveRequestModel(): Model<TLeaveRequest> | null;
+    /**
+     * Get TaxWithholding model (optional, strongly typed)
+     */
+    getTaxWithholdingModel(): Model<TTaxWithholding> | null;
+    /**
+     * Get configuration
+     */
+    getConfig(): HRMConfig;
+    /**
+     * Get specific config section
+     */
+    getConfigSection<K extends keyof HRMConfig>(section: K): HRMConfig[K];
+    /**
+     * Check if single-tenant mode
+     */
+    isSingleTenant(): boolean;
+    /**
+     * Get single-tenant config
+     */
+    getSingleTenantConfig(): SingleTenantConfig | null;
+    /**
+     * Get organization ID (for single-tenant mode)
+     */
+    getOrganizationId(): string | null;
+    /**
+     * Get logger
+     */
+    getLogger(): Logger;
+    /**
+     * Set logger
+     */
+    setLogger(logger: Logger): void;
+    /**
+     * Has attendance integration
+     */
+    hasAttendanceIntegration(): boolean;
+    /**
+     * Create operation context with defaults
+     *
+     * In single-tenant mode with autoInject enabled (default), automatically
+     * injects the configured organizationId into the context.
+     *
+     * @throws Error if autoInject is enabled but no organizationId is configured
+     */
+    createOperationContext(overrides?: Partial<{
+        userId: string;
+        userName: string;
+        userRole: string;
+        organizationId: string;
+        session: ClientSession;
+    }>): {
+        userId?: string;
+        userName?: string;
+        userRole?: string;
+        organizationId?: string;
+        session?: ClientSession;
+    };
+}
+/**
+ * @deprecated Use createPayrollInstance() instead.
+ * Get or create the default container instance.
+ */
+declare function getContainer(): Container;
+/**
+ * @deprecated Use createPayrollInstance() instead.
+ * Initialize the default container.
+ */
+declare function initializeContainer(config: ContainerConfig): void;
+/**
+ * @deprecated Use container.isInitialized() instead.
+ * Check if the default container is initialized.
+ */
+declare function isContainerInitialized(): boolean;
+/**
+ * @deprecated Use container.getModels() instead.
+ * Get models from the default container.
+ */
+declare function getModels(): ModelsContainer;
+/**
+ * @deprecated Use container.getConfig() instead.
+ * Get config from the default container.
+ */
+declare function getConfig(): HRMConfig;
+/**
+ * @deprecated Use container.isSingleTenant() instead.
+ * Check if single-tenant mode.
+ */
+declare function isSingleTenant(): boolean;
+
+export { Container, type ContainerConfig, type Err, type ModelsContainer, type Ok, Result, ResultClass, all, err, flatMap, fromNullable, fromPromise, getConfig, getContainer, getModels, initializeContainer, isContainerInitialized, isErr, isOk, isSingleTenant, map, mapErr, match, ok, tryCatch, tryCatchSync, unwrap, unwrapOr, unwrapOrElse };