@t4dhg/mcp-factorial 7.0.1 → 8.2.0

package/dist/api.js

@@ -2,1160 +2,9 @@
  * FactorialHR API Client
  *
  * Provides access to FactorialHR API endpoints with caching, pagination, and retry logic.
- */
-import { fetchList, fetchOne, postOne, patchOne, deleteOne, postAction } from './http-client.js';
-import { cache, cached, CACHE_TTL, CacheManager } from './cache.js';
-import { debug } from './config.js';
-import { buildPaginationParams, paginateResponse, sliceForPagination, } from './pagination.js';
-import { AuditAction, auditedOperation } from './audit.js';
-import { validateId } from './utils.js';
-import { ENDPOINTS, endpointWithId, endpointWithAction } from './endpoints.js';
-import { NotFoundError } from './errors.js';
-// ============================================================================
-// Employee endpoints
-// ============================================================================
-/**
- * List all employees with optional filtering and pagination
- */
-export async function listEmployees(options) {
-    const params = buildPaginationParams(options);
-    const cacheKey = CacheManager.key('employees', options);
-    // For filtered requests, we need to fetch all and filter client-side
-    // because the API doesn't reliably filter
-    if (options?.team_id || options?.location_id) {
-        const allEmployees = await cached('employees:all', () => fetchList(ENDPOINTS.employees), CACHE_TTL.employees);
-        let filtered = allEmployees;
-        // Note: team_id filtering requires fetching teams separately (not on Employee object)
-        // TODO: Implement team filtering via teams endpoint if needed
-        if (options.location_id) {
-            filtered = filtered.filter(e => e.location_id === options.location_id);
-        }
-        return sliceForPagination(filtered, params);
-    }
-    // Without filters, use pagination directly
-    const employees = await cached(cacheKey, () => fetchList(ENDPOINTS.employees, { params }), CACHE_TTL.employees);
-    return paginateResponse(employees, params.page, params.limit);
-}
-/**
- * Get a specific employee by ID
  *
- * Note: The Factorial API's individual employee endpoint (/employees/employees/{id})
- * can be unreliable. This function falls back to fetching all employees and filtering
- * if the direct endpoint fails or returns no data.
- */
-export async function getEmployee(id) {
-    validateId(id, 'employee');
-    // Try the direct endpoint first
-    try {
-        const employee = await cached(`employee:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.employees, id)), CACHE_TTL.employees);
-        // If we got a valid employee, return it
-        if (employee) {
-            return employee;
-        }
-    }
-    catch (error) {
-        // If direct fetch fails with NotFoundError, try fallback
-        // (other errors will be re-thrown below)
-        if (!(error instanceof NotFoundError)) {
-            throw error;
-        }
-    }
-    // Fallback: Fetch all employees and filter (same approach as searchEmployees)
-    // This works around Factorial API limitations with the individual employee endpoint
-    const allEmployees = await cached('employees:all', () => fetchList(ENDPOINTS.employees), CACHE_TTL.employees);
-    const employee = allEmployees.find(emp => emp.id === id);
-    if (!employee) {
-        throw new Error(`Employee with ID ${id} not found.`);
-    }
-    return employee;
-}
-/**
- * Search employees by name or email
- */
-export async function searchEmployees(query) {
-    if (!query || query.trim().length < 2) {
-        throw new Error('Search query must be at least 2 characters long.');
-    }
-    const allEmployees = await cached('employees:all', () => fetchList(ENDPOINTS.employees), CACHE_TTL.employees);
-    const lowerQuery = query.toLowerCase().trim();
-    return allEmployees.filter(emp => emp.full_name?.toLowerCase().includes(lowerQuery) ||
-        emp.email?.toLowerCase().includes(lowerQuery) ||
-        emp.first_name?.toLowerCase().includes(lowerQuery) ||
-        emp.last_name?.toLowerCase().includes(lowerQuery));
-}
-// ============================================================================
-// Team endpoints
-// ============================================================================
-/**
- * List all teams
- */
-export async function listTeams(options) {
-    const params = buildPaginationParams(options);
-    const cacheKey = CacheManager.key('teams', options);
-    const teams = await cached(cacheKey, () => fetchList(ENDPOINTS.teams), CACHE_TTL.teams);
-    return sliceForPagination(teams, params);
-}
-/**
- * Get a specific team by ID
- */
-export async function getTeam(id) {
-    validateId(id, 'team');
-    return cached(`team:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.teams, id)), CACHE_TTL.teams);
-}
-// ============================================================================
-// Location endpoints
-// ============================================================================
-/**
- * List all locations
- */
-export async function listLocations(options) {
-    const params = buildPaginationParams(options);
-    const cacheKey = CacheManager.key('locations', options);
-    const locations = await cached(cacheKey, () => fetchList(ENDPOINTS.locations), CACHE_TTL.locations);
-    return sliceForPagination(locations, params);
-}
-/**
- * Get a specific location by ID
- */
-export async function getLocation(id) {
-    validateId(id, 'location');
-    return cached(`location:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.locations, id)), CACHE_TTL.locations);
-}
-// ============================================================================
-// Contract endpoints
-// ============================================================================
-/**
- * List contracts, optionally filtered by employee ID
- */
-export async function listContracts(employeeId, options) {
-    if (employeeId !== undefined) {
-        validateId(employeeId, 'employee');
-    }
-    const params = buildPaginationParams(options);
-    // Note: The API doesn't reliably filter by employee_id query param,
-    // so we fetch all contracts and filter client-side
-    const allContracts = await cached('contracts:all', () => fetchList(ENDPOINTS.contracts), CACHE_TTL.contracts);
-    const filtered = employeeId !== undefined
-        ? allContracts.filter(c => c.employee_id === employeeId)
-        : allContracts;
-    return sliceForPagination(filtered, params);
-}
-// ============================================================================
-// Time Off / Leave endpoints
-// ============================================================================
-/**
- * List leaves with optional filtering
- */
-export async function listLeaves(options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {
-        page: params.page,
-        limit: params.limit,
-    };
-    if (options?.employee_id)
-        queryParams.employee_id = options.employee_id;
-    if (options?.status)
-        queryParams.status = options.status;
-    if (options?.start_on_gte)
-        queryParams.start_on_gte = options.start_on_gte;
-    if (options?.start_on_lte)
-        queryParams.start_on_lte = options.start_on_lte;
-    const leaves = await fetchList(ENDPOINTS.leaves, { params: queryParams });
-    return paginateResponse(leaves, params.page, params.limit);
-}
-/**
- * Get a specific leave by ID
- */
-export async function getLeave(id) {
-    validateId(id, 'leave');
-    return fetchOne(endpointWithId(ENDPOINTS.leaves, id));
-}
-/**
- * List all leave types
- */
-export async function listLeaveTypes() {
-    return cached('leave-types:all', () => fetchList(ENDPOINTS.leaveTypes), CACHE_TTL.leaves);
-}
-/**
- * Get a specific leave type by ID
- */
-export async function getLeaveType(id) {
-    validateId(id, 'leave type');
-    return fetchOne(endpointWithId(ENDPOINTS.leaveTypes, id));
-}
-/**
- * List allowances with optional filtering by employee
- */
-export async function listAllowances(options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {
-        page: params.page,
-        limit: params.limit,
-    };
-    if (options?.employee_id)
-        queryParams.employee_id = options.employee_id;
-    const allowances = await fetchList(ENDPOINTS.allowances, { params: queryParams });
-    return paginateResponse(allowances, params.page, params.limit);
-}
-// ============================================================================
-// Attendance / Shifts endpoints
-// ============================================================================
-/**
- * List shifts with optional filtering
- */
-export async function listShifts(options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {
-        page: params.page,
-        limit: params.limit,
-    };
-    if (options?.employee_id)
-        queryParams.employee_id = options.employee_id;
-    if (options?.clock_in_gte)
-        queryParams.clock_in_gte = options.clock_in_gte;
-    if (options?.clock_in_lte)
-        queryParams.clock_in_lte = options.clock_in_lte;
-    const shifts = await fetchList(ENDPOINTS.shifts, { params: queryParams });
-    return paginateResponse(shifts, params.page, params.limit);
-}
-/**
- * Get a specific shift by ID
- */
-export async function getShift(id) {
-    validateId(id, 'shift');
-    return fetchOne(endpointWithId(ENDPOINTS.shifts, id));
-}
-// ============================================================================
-// Document endpoints (Read-only)
-// ============================================================================
-/**
- * List all folders
- */
-export async function listFolders() {
-    return cached('folders:all', () => fetchList(ENDPOINTS.folders), CACHE_TTL.default);
-}
-/**
- * Get a specific folder by ID
- */
-export async function getFolder(id) {
-    validateId(id, 'folder');
-    return fetchOne(endpointWithId(ENDPOINTS.folders, id));
-}
-/**
- * List documents with optional filtering by folder
- */
-export async function listDocuments(options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {
-        page: params.page,
-        limit: params.limit,
-    };
-    if (options?.folder_id)
-        queryParams.folder_id = options.folder_id;
-    // Handle employee_ids array parameter
-    // Factorial API expects: employee_ids[]=123&employee_ids[]=456
-    if (options?.employee_ids && options.employee_ids.length > 0) {
-        // We'll need to build the query string manually for array parameters
-        const employeeIdsParam = options.employee_ids.map(id => `employee_ids[]=${id}`).join('&');
-        const baseParams = new URLSearchParams(queryParams).toString();
-        const fullParams = baseParams ? `${baseParams}&${employeeIdsParam}` : employeeIdsParam;
-        // Make request with custom query string
-        const documents = await fetchList(`${ENDPOINTS.documents}?${fullParams}`);
-        debug(`listDocuments returned ${documents.length} documents`, {
-            sampleDocument: documents[0],
-            missingNames: documents.filter(d => !d.name).length,
-        });
-        return paginateResponse(documents, params.page, params.limit);
-    }
-    const documents = await fetchList(ENDPOINTS.documents, { params: queryParams });
-    debug(`listDocuments returned ${documents.length} documents`, {
-        sampleDocument: documents[0],
-        missingNames: documents.filter(d => !d.name).length,
-    });
-    return paginateResponse(documents, params.page, params.limit);
-}
-/**
- * Get a specific document by ID
- *
- * Note: The Factorial API's individual document endpoint (/documents/documents/{id})
- * can be unreliable, similar to the employee endpoint. This function implements a fallback
- * to listing all documents and filtering if the direct endpoint fails or returns no data.
- *
- * @param id - The document ID
- * @returns The document object
- * @throws Error if document is not found
- */
-export async function getDocument(id) {
-    validateId(id, 'document');
-    // Try the direct endpoint first
-    try {
-        const document = await fetchOne(endpointWithId(ENDPOINTS.documents, id));
-        // If we got a valid document, return it
-        if (document) {
-            return document;
-        }
-    }
-    catch (error) {
-        // If direct fetch fails with NotFoundError, try fallback
-        if (!(error instanceof NotFoundError)) {
-            throw error;
-        }
-        debug(`getDocument(${id}) - direct endpoint failed, using fallback`);
-    }
-    // Fallback: Fetch all documents and filter by ID
-    // This works around Factorial API limitations with the individual document endpoint
-    const allDocuments = await fetchList(ENDPOINTS.documents);
-    const document = allDocuments.find(doc => doc.id === id);
-    if (!document) {
-        throw new Error(`Document with ID ${id} not found.`);
-    }
-    return document;
-}
-// ============================================================================
-// Job Catalog endpoints
-// ============================================================================
-/**
- * List all job roles
- */
-export async function listJobRoles() {
-    return cached('job-roles:all', () => fetchList(ENDPOINTS.jobRoles), CACHE_TTL.default);
-}
-/**
- * Get a specific job role by ID
- */
-export async function getJobRole(id) {
-    validateId(id, 'job role');
-    return fetchOne(endpointWithId(ENDPOINTS.jobRoles, id));
-}
-/**
- * List all job levels
- */
-export async function listJobLevels() {
-    return cached('job-levels:all', () => fetchList(ENDPOINTS.jobLevels), CACHE_TTL.default);
-}
-/**
- * Get a specific job level by ID
- */
-export async function getJobLevel(id) {
-    validateId(id, 'job level');
-    return fetchOne(endpointWithId(ENDPOINTS.jobLevels, id));
-}
-// ============================================================================
-// Cache utilities
-// ============================================================================
-/**
- * Invalidate all cached data
- */
-export function clearCache() {
-    cache.clear();
-}
-/**
- * Invalidate cached data for a specific resource type
- */
-export function invalidateCache(resourceType) {
-    cache.invalidatePrefix(resourceType);
-}
-// ============================================================================
-// WRITE OPERATIONS - Employee endpoints
-// ============================================================================
-/**
- * Create a new employee
- */
-export async function createEmployee(input) {
-    return auditedOperation(AuditAction.CREATE, 'employee', undefined, async () => {
-        const employee = await postOne(ENDPOINTS.employees, input);
-        cache.invalidatePrefix('employees');
-        return employee;
-    }, Object.fromEntries(Object.entries(input).map(([k, v]) => [k, { to: v }])));
-}
-/**
- * Update an existing employee
- */
-export async function updateEmployee(id, input) {
-    validateId(id, 'employee');
-    return auditedOperation(AuditAction.UPDATE, 'employee', id, async () => {
-        const employee = await patchOne(endpointWithId(ENDPOINTS.employees, id), input);
-        cache.invalidate(`employee:${id}`);
-        cache.invalidatePrefix('employees');
-        return employee;
-    });
-}
-/**
- * Terminate an employee (soft delete)
- */
-export async function terminateEmployee(id, terminatedOn, reason) {
-    validateId(id, 'employee');
-    return auditedOperation(AuditAction.TERMINATE, 'employee', id, async () => {
-        const employee = await patchOne(endpointWithId(ENDPOINTS.employees, id), {
-            terminated_on: terminatedOn,
-        });
-        cache.invalidate(`employee:${id}`);
-        cache.invalidatePrefix('employees');
-        return employee;
-    }, { terminated_on: { to: terminatedOn }, reason: { to: reason } });
-}
-// ============================================================================
-// WRITE OPERATIONS - Team endpoints
-// ============================================================================
-/**
- * Create a new team
- */
-export async function createTeam(input) {
-    return auditedOperation(AuditAction.CREATE, 'team', undefined, async () => {
-        const team = await postOne(ENDPOINTS.teams, input);
-        cache.invalidatePrefix('teams');
-        return team;
-    });
-}
-/**
- * Update an existing team
- */
-export async function updateTeam(id, input) {
-    validateId(id, 'team');
-    return auditedOperation(AuditAction.UPDATE, 'team', id, async () => {
-        const team = await patchOne(endpointWithId(ENDPOINTS.teams, id), input);
-        cache.invalidate(`team:${id}`);
-        cache.invalidatePrefix('teams');
-        return team;
-    });
-}
-/**
- * Delete a team
- */
-export async function deleteTeam(id) {
-    validateId(id, 'team');
-    return auditedOperation(AuditAction.DELETE, 'team', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.teams, id));
-        cache.invalidate(`team:${id}`);
-        cache.invalidatePrefix('teams');
-    });
-}
-// ============================================================================
-// WRITE OPERATIONS - Location endpoints
-// ============================================================================
-/**
- * Create a new location
- */
-export async function createLocation(input) {
-    return auditedOperation(AuditAction.CREATE, 'location', undefined, async () => {
-        const location = await postOne(ENDPOINTS.locations, input);
-        cache.invalidatePrefix('locations');
-        return location;
-    });
-}
-/**
- * Update an existing location
- */
-export async function updateLocation(id, input) {
-    validateId(id, 'location');
-    return auditedOperation(AuditAction.UPDATE, 'location', id, async () => {
-        const location = await patchOne(endpointWithId(ENDPOINTS.locations, id), input);
-        cache.invalidate(`location:${id}`);
-        cache.invalidatePrefix('locations');
-        return location;
-    });
-}
-/**
- * Delete a location
- */
-export async function deleteLocation(id) {
-    validateId(id, 'location');
-    return auditedOperation(AuditAction.DELETE, 'location', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.locations, id));
-        cache.invalidate(`location:${id}`);
-        cache.invalidatePrefix('locations');
-    });
-}
-// ============================================================================
-// WRITE OPERATIONS - Leave endpoints
-// ============================================================================
-/**
- * Create a new leave request
- */
-export async function createLeave(input) {
-    return auditedOperation(AuditAction.CREATE, 'leave', undefined, async () => {
-        const leave = await postOne(ENDPOINTS.leaves, input);
-        return leave;
-    });
-}
-/**
- * Update a leave request
- */
-export async function updateLeave(id, input) {
-    validateId(id, 'leave');
-    return auditedOperation(AuditAction.UPDATE, 'leave', id, async () => {
-        const leave = await patchOne(endpointWithId(ENDPOINTS.leaves, id), input);
-        return leave;
-    });
-}
-/**
- * Cancel a leave request
- */
-export async function cancelLeave(id) {
-    validateId(id, 'leave');
-    return auditedOperation(AuditAction.DELETE, 'leave', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.leaves, id));
-    });
-}
-/**
- * Approve a leave request
- */
-export async function approveLeave(id, input) {
-    validateId(id, 'leave');
-    return auditedOperation(AuditAction.APPROVE, 'leave', id, async () => {
-        const leave = await postAction(endpointWithAction(ENDPOINTS.leaves, id, 'approve'), input || {});
-        return leave;
-    });
-}
-/**
- * Reject a leave request
- */
-export async function rejectLeave(id, input) {
-    validateId(id, 'leave');
-    return auditedOperation(AuditAction.REJECT, 'leave', id, async () => {
-        const leave = await postAction(endpointWithAction(ENDPOINTS.leaves, id, 'reject'), input || {});
-        return leave;
-    });
-}
-// ============================================================================
-// WRITE OPERATIONS - Shift endpoints
-// ============================================================================
-/**
- * Create a new shift
- */
-export async function createShift(input) {
-    return auditedOperation(AuditAction.CREATE, 'shift', undefined, async () => {
-        const shift = await postOne(ENDPOINTS.shifts, input);
-        return shift;
-    });
-}
-/**
- * Update a shift
- */
-export async function updateShift(id, input) {
-    validateId(id, 'shift');
-    return auditedOperation(AuditAction.UPDATE, 'shift', id, async () => {
-        const shift = await patchOne(endpointWithId(ENDPOINTS.shifts, id), input);
-        return shift;
-    });
-}
-/**
- * Delete a shift
- */
-export async function deleteShift(id) {
-    validateId(id, 'shift');
-    return auditedOperation(AuditAction.DELETE, 'shift', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.shifts, id));
-    });
-}
-// ============================================================================
-// Projects & Time Tracking - READ endpoints
-// ============================================================================
-/**
- * List all projects
- */
-export async function listProjects(options) {
-    const params = buildPaginationParams(options);
-    const projects = await cached(CacheManager.key('projects', options), () => fetchList(ENDPOINTS.projects), CACHE_TTL.default);
-    return sliceForPagination(projects, params);
-}
-/**
- * Get a specific project by ID
- */
-export async function getProject(id) {
-    validateId(id, 'project');
-    return cached(`project:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.projects, id)), CACHE_TTL.default);
-}
-/**
- * List project tasks
- */
-export async function listProjectTasks(projectId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (projectId)
-        queryParams.project_ids = projectId;
-    const tasks = await fetchList(ENDPOINTS.projectTasks, {
-        params: queryParams,
-    });
-    return sliceForPagination(tasks, params);
-}
-/**
- * Get a specific project task by ID
- */
-export async function getProjectTask(id) {
-    validateId(id, 'task');
-    return fetchOne(endpointWithId(ENDPOINTS.projectTasks, id));
-}
-/**
- * List project workers
- */
-export async function listProjectWorkers(projectId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (projectId)
-        queryParams.project_ids = projectId;
-    const workers = await fetchList(ENDPOINTS.projectWorkers, {
-        params: queryParams,
-    });
-    return sliceForPagination(workers, params);
-}
-/**
- * Get a specific project worker by ID
- */
-export async function getProjectWorker(id) {
-    validateId(id, 'project worker');
-    return fetchOne(endpointWithId(ENDPOINTS.projectWorkers, id));
-}
-/**
- * List time records
- */
-export async function listTimeRecords(projectWorkerId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (projectWorkerId)
-        queryParams.project_workers_ids = projectWorkerId;
-    const records = await fetchList(ENDPOINTS.timeRecords, {
-        params: queryParams,
-    });
-    return sliceForPagination(records, params);
-}
-/**
- * Get a specific time record by ID
- */
-export async function getTimeRecord(id) {
-    validateId(id, 'time record');
-    return fetchOne(endpointWithId(ENDPOINTS.timeRecords, id));
-}
-// ============================================================================
-// Projects & Time Tracking - WRITE endpoints
-// ============================================================================
-/**
- * Create a new project
- */
-export async function createProject(input) {
-    return auditedOperation(AuditAction.CREATE, 'project', undefined, async () => {
-        const project = await postOne(ENDPOINTS.projects, input);
-        cache.invalidatePrefix('projects');
-        return project;
-    });
-}
-/**
- * Update a project
- */
-export async function updateProject(id, input) {
-    validateId(id, 'project');
-    return auditedOperation(AuditAction.UPDATE, 'project', id, async () => {
-        const project = await patchOne(endpointWithId(ENDPOINTS.projects, id), input);
-        cache.invalidate(`project:${id}`);
-        cache.invalidatePrefix('projects');
-        return project;
-    });
-}
-/**
- * Delete a project
- */
-export async function deleteProject(id) {
-    validateId(id, 'project');
-    return auditedOperation(AuditAction.DELETE, 'project', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.projects, id));
-        cache.invalidate(`project:${id}`);
-        cache.invalidatePrefix('projects');
-    });
-}
-/**
- * Create a project task
- */
-export async function createProjectTask(input) {
-    return auditedOperation(AuditAction.CREATE, 'project_task', undefined, async () => {
-        return postOne(ENDPOINTS.projectTasks, input);
-    });
-}
-/**
- * Update a project task
- */
-export async function updateProjectTask(id, input) {
-    validateId(id, 'task');
-    return auditedOperation(AuditAction.UPDATE, 'project_task', id, async () => {
-        return patchOne(endpointWithId(ENDPOINTS.projectTasks, id), input);
-    });
-}
-/**
- * Delete a project task
- */
-export async function deleteProjectTask(id) {
-    validateId(id, 'task');
-    return auditedOperation(AuditAction.DELETE, 'project_task', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.projectTasks, id));
-    });
-}
-/**
- * Assign a worker to a project
- */
-export async function assignProjectWorker(input) {
-    return auditedOperation(AuditAction.ASSIGN, 'project_worker', undefined, async () => {
-        return postOne(ENDPOINTS.projectWorkers, input);
-    });
-}
-/**
- * Remove a worker from a project
- */
-export async function removeProjectWorker(id) {
-    validateId(id, 'project worker');
-    return auditedOperation(AuditAction.UNASSIGN, 'project_worker', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.projectWorkers, id));
-    });
-}
-/**
- * Create a time record
- */
-export async function createTimeRecord(input) {
-    return auditedOperation(AuditAction.CREATE, 'time_record', undefined, async () => {
-        return postOne(ENDPOINTS.timeRecords, input);
-    });
-}
-/**
- * Update a time record
- */
-export async function updateTimeRecord(id, input) {
-    validateId(id, 'time record');
-    return auditedOperation(AuditAction.UPDATE, 'time_record', id, async () => {
-        return patchOne(endpointWithId(ENDPOINTS.timeRecords, id), input);
-    });
-}
-/**
- * Delete a time record
- */
-export async function deleteTimeRecord(id) {
-    validateId(id, 'time record');
-    return auditedOperation(AuditAction.DELETE, 'time_record', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.timeRecords, id));
-    });
-}
-// ============================================================================
-// Training & Development - READ endpoints
-// ============================================================================
-/**
- * List all trainings
- */
-export async function listTrainings(options) {
-    const params = buildPaginationParams(options);
-    const trainings = await cached(CacheManager.key('trainings', options), () => fetchList(ENDPOINTS.trainings), CACHE_TTL.default);
-    return sliceForPagination(trainings, params);
-}
-/**
- * Get a specific training by ID
- */
-export async function getTraining(id) {
-    validateId(id, 'training');
-    return cached(`training:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.trainings, id)), CACHE_TTL.default);
-}
-/**
- * List training sessions
- */
-export async function listTrainingSessions(trainingId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (trainingId)
-        queryParams.training_id = trainingId;
-    const sessions = await fetchList(ENDPOINTS.trainingSessions, {
-        params: queryParams,
-    });
-    return sliceForPagination(sessions, params);
-}
-/**
- * Get a specific training session by ID
- */
-export async function getTrainingSession(id) {
-    validateId(id, 'session');
-    return fetchOne(endpointWithId(ENDPOINTS.trainingSessions, id));
-}
-/**
- * List training enrollments
- */
-export async function listTrainingEnrollments(trainingId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (trainingId)
-        queryParams.training_id = trainingId;
-    const enrollments = await fetchList(ENDPOINTS.trainingMemberships, {
-        params: queryParams,
-    });
-    return sliceForPagination(enrollments, params);
-}
-/**
- * Get a specific training enrollment by ID
- */
-export async function getTrainingEnrollment(id) {
-    validateId(id, 'enrollment');
-    return fetchOne(endpointWithId(ENDPOINTS.trainingMemberships, id));
-}
-// ============================================================================
-// Training & Development - WRITE endpoints
-// ============================================================================
-/**
- * Create a training program
- */
-export async function createTraining(input) {
-    return auditedOperation(AuditAction.CREATE, 'training', undefined, async () => {
-        const training = await postOne(ENDPOINTS.trainings, input);
-        cache.invalidatePrefix('trainings');
-        return training;
-    });
-}
-/**
- * Update a training program
- */
-export async function updateTraining(id, input) {
-    validateId(id, 'training');
-    return auditedOperation(AuditAction.UPDATE, 'training', id, async () => {
-        const training = await patchOne(endpointWithId(ENDPOINTS.trainings, id), input);
-        cache.invalidate(`training:${id}`);
-        cache.invalidatePrefix('trainings');
-        return training;
-    });
-}
-/**
- * Delete a training program
- */
-export async function deleteTraining(id) {
-    validateId(id, 'training');
-    return auditedOperation(AuditAction.DELETE, 'training', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.trainings, id));
-        cache.invalidate(`training:${id}`);
-        cache.invalidatePrefix('trainings');
-    });
-}
-/**
- * Create a training session
- */
-export async function createTrainingSession(input) {
-    return auditedOperation(AuditAction.CREATE, 'training_session', undefined, async () => {
-        return postOne(ENDPOINTS.trainingSessions, input);
-    });
-}
-/**
- * Update a training session
- */
-export async function updateTrainingSession(id, input) {
-    validateId(id, 'session');
-    return auditedOperation(AuditAction.UPDATE, 'training_session', id, async () => {
-        return patchOne(endpointWithId(ENDPOINTS.trainingSessions, id), input);
-    });
-}
-/**
- * Delete a training session
- */
-export async function deleteTrainingSession(id) {
-    validateId(id, 'session');
-    return auditedOperation(AuditAction.DELETE, 'training_session', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.trainingSessions, id));
-    });
-}
-/**
- * Enroll an employee in a training
- */
-export async function enrollInTraining(input) {
-    return auditedOperation(AuditAction.ASSIGN, 'training_enrollment', undefined, async () => {
-        return postOne(ENDPOINTS.trainingMemberships, input);
-    });
-}
-/**
- * Remove enrollment from a training
- */
-export async function unenrollFromTraining(id) {
-    validateId(id, 'enrollment');
-    return auditedOperation(AuditAction.UNASSIGN, 'training_enrollment', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.trainingMemberships, id));
-    });
-}
-// ============================================================================
-// Work Areas - READ/WRITE endpoints
-// ============================================================================
-/**
- * List all work areas
- */
-export async function listWorkAreas(options) {
-    const params = buildPaginationParams(options);
-    const workAreas = await cached(CacheManager.key('work_areas', options), () => fetchList(ENDPOINTS.workAreas), CACHE_TTL.locations);
-    return sliceForPagination(workAreas, params);
-}
-/**
- * Get a specific work area by ID
- */
-export async function getWorkArea(id) {
-    validateId(id, 'work area');
-    return cached(`work_area:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.workAreas, id)), CACHE_TTL.locations);
-}
-/**
- * Create a work area
- */
-export async function createWorkArea(input) {
-    return auditedOperation(AuditAction.CREATE, 'work_area', undefined, async () => {
-        const workArea = await postOne(ENDPOINTS.workAreas, input);
-        cache.invalidatePrefix('work_areas');
-        return workArea;
-    });
-}
-/**
- * Update a work area
- */
-export async function updateWorkArea(id, input) {
-    validateId(id, 'work area');
-    return auditedOperation(AuditAction.UPDATE, 'work_area', id, async () => {
-        const workArea = await patchOne(endpointWithId(ENDPOINTS.workAreas, id), input);
-        cache.invalidate(`work_area:${id}`);
-        cache.invalidatePrefix('work_areas');
-        return workArea;
-    });
-}
-/**
- * Archive a work area
- */
-export async function archiveWorkArea(id) {
-    validateId(id, 'work area');
-    return auditedOperation(AuditAction.ARCHIVE, 'work_area', id, async () => {
-        const workArea = await postAction(endpointWithAction(ENDPOINTS.workAreas, id, 'archive'));
-        cache.invalidate(`work_area:${id}`);
-        cache.invalidatePrefix('work_areas');
-        return workArea;
-    });
-}
-/**
- * Unarchive a work area
- */
-export async function unarchiveWorkArea(id) {
-    validateId(id, 'work area');
-    return auditedOperation(AuditAction.UNARCHIVE, 'work_area', id, async () => {
-        const workArea = await postAction(endpointWithAction(ENDPOINTS.workAreas, id, 'unarchive'));
-        cache.invalidate(`work_area:${id}`);
-        cache.invalidatePrefix('work_areas');
-        return workArea;
-    });
-}
-// ============================================================================
-// ATS (Recruiting) - READ endpoints
-// ============================================================================
-/**
- * List all job postings
- */
-export async function listJobPostings(options) {
-    const params = buildPaginationParams(options);
-    const postings = await cached(CacheManager.key('job_postings', options), () => fetchList(ENDPOINTS.jobPostings), CACHE_TTL.default);
-    return sliceForPagination(postings, params);
-}
-/**
- * Get a specific job posting by ID
- */
-export async function getJobPosting(id) {
-    validateId(id, 'job posting');
-    return cached(`job_posting:${id}`, () => fetchOne(endpointWithId(ENDPOINTS.jobPostings, id)), CACHE_TTL.default);
-}
-/**
- * List all candidates
- */
-export async function listCandidates(options) {
-    const params = buildPaginationParams(options);
-    const candidates = await fetchList(ENDPOINTS.candidates);
-    return sliceForPagination(candidates, params);
-}
-/**
- * Get a specific candidate by ID
- */
-export async function getCandidate(id) {
-    validateId(id, 'candidate');
-    return fetchOne(endpointWithId(ENDPOINTS.candidates, id));
-}
-/**
- * List all applications
- */
-export async function listApplications(jobPostingId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (jobPostingId)
-        queryParams.job_posting_id = jobPostingId;
-    const applications = await fetchList(ENDPOINTS.applications, {
-        params: queryParams,
-    });
-    return sliceForPagination(applications, params);
-}
-/**
- * Get a specific application by ID
- */
-export async function getApplication(id) {
-    validateId(id, 'application');
-    return fetchOne(endpointWithId(ENDPOINTS.applications, id));
-}
-/**
- * List all hiring stages
- */
-export async function listHiringStages() {
-    return cached('hiring_stages:all', () => fetchList(ENDPOINTS.hiringStages), CACHE_TTL.default);
-}
-/**
- * Get a specific hiring stage by ID
- */
-export async function getHiringStage(id) {
-    validateId(id, 'hiring stage');
-    return fetchOne(endpointWithId(ENDPOINTS.hiringStages, id));
-}
-// ============================================================================
-// ATS (Recruiting) - WRITE endpoints
-// ============================================================================
-/**
- * Create a job posting
- */
-export async function createJobPosting(input) {
-    return auditedOperation(AuditAction.CREATE, 'job_posting', undefined, async () => {
-        const posting = await postOne(ENDPOINTS.jobPostings, input);
-        cache.invalidatePrefix('job_postings');
-        return posting;
-    });
-}
-/**
- * Update a job posting
- */
-export async function updateJobPosting(id, input) {
-    validateId(id, 'job posting');
-    return auditedOperation(AuditAction.UPDATE, 'job_posting', id, async () => {
-        const posting = await patchOne(endpointWithId(ENDPOINTS.jobPostings, id), input);
-        cache.invalidate(`job_posting:${id}`);
-        cache.invalidatePrefix('job_postings');
-        return posting;
-    });
-}
-/**
- * Delete a job posting
- */
-export async function deleteJobPosting(id) {
-    validateId(id, 'job posting');
-    return auditedOperation(AuditAction.DELETE, 'job_posting', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.jobPostings, id));
-        cache.invalidate(`job_posting:${id}`);
-        cache.invalidatePrefix('job_postings');
-    });
-}
-/**
- * Create a candidate
- */
-export async function createCandidate(input) {
-    return auditedOperation(AuditAction.CREATE, 'candidate', undefined, async () => {
-        return postOne(ENDPOINTS.candidates, input);
-    });
-}
-/**
- * Update a candidate
- */
-export async function updateCandidate(id, input) {
-    validateId(id, 'candidate');
-    return auditedOperation(AuditAction.UPDATE, 'candidate', id, async () => {
-        return patchOne(endpointWithId(ENDPOINTS.candidates, id), input);
-    });
-}
-/**
- * Delete a candidate
- */
-export async function deleteCandidate(id) {
-    validateId(id, 'candidate');
-    return auditedOperation(AuditAction.DELETE, 'candidate', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.candidates, id));
-    });
-}
-/**
- * Create an application
- */
-export async function createApplication(input) {
-    return auditedOperation(AuditAction.CREATE, 'application', undefined, async () => {
-        return postOne(ENDPOINTS.applications, input);
-    });
-}
-/**
- * Update an application
- */
-export async function updateApplication(id, input) {
-    validateId(id, 'application');
-    return auditedOperation(AuditAction.UPDATE, 'application', id, async () => {
-        return patchOne(endpointWithId(ENDPOINTS.applications, id), input);
-    });
-}
-/**
- * Delete an application
- */
-export async function deleteApplication(id) {
-    validateId(id, 'application');
-    return auditedOperation(AuditAction.DELETE, 'application', id, async () => {
-        await deleteOne(endpointWithId(ENDPOINTS.applications, id));
-    });
-}
-/**
- * Advance an application to the next stage
- */
-export async function advanceApplication(id) {
-    validateId(id, 'application');
-    return auditedOperation(AuditAction.UPDATE, 'application', id, async () => {
-        return postAction(endpointWithAction(ENDPOINTS.applications, id, 'apply'));
-    });
-}
-// ============================================================================
-// Payroll - READ-ONLY endpoints (sensitive data)
-// ============================================================================
-/**
- * List payroll supplements for an employee
- */
-export async function listPayrollSupplements(employeeId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (employeeId)
-        queryParams.employee_id = employeeId;
-    const supplements = await fetchList(ENDPOINTS.payrollSupplements, {
-        params: queryParams,
-    });
-    return sliceForPagination(supplements, params);
-}
-/**
- * Get a specific payroll supplement by ID
- */
-export async function getPayrollSupplement(id) {
-    validateId(id, 'supplement');
-    return fetchOne(endpointWithId(ENDPOINTS.payrollSupplements, id));
-}
-/**
- * List tax identifiers
- */
-export async function listTaxIdentifiers(employeeId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (employeeId)
-        queryParams.employee_id = employeeId;
-    const identifiers = await fetchList(ENDPOINTS.taxIdentifiers, {
-        params: queryParams,
-    });
-    return sliceForPagination(identifiers, params);
-}
-/**
- * Get a specific tax identifier by ID
- */
-export async function getTaxIdentifier(id) {
-    validateId(id, 'tax identifier');
-    return fetchOne(endpointWithId(ENDPOINTS.taxIdentifiers, id));
-}
-/**
- * List family situations
- */
-export async function listFamilySituations(employeeId, options) {
-    const params = buildPaginationParams(options);
-    const queryParams = {};
-    if (employeeId)
-        queryParams.employee_id = employeeId;
-    const situations = await fetchList(ENDPOINTS.familySituations, {
-        params: queryParams,
-    });
-    return sliceForPagination(situations, params);
-}
-/**
- * Get a specific family situation by ID
+ * This file re-exports all API functions from the modular src/api/ directory.
+ * All API functions are now organized by domain for better maintainability.
  */
-export async function getFamilySituation(id) {
-    validateId(id, 'family situation');
-    return fetchOne(endpointWithId(ENDPOINTS.familySituations, id));
-}
+export * from './api/index.js';
 //# sourceMappingURL=api.js.map