@brownandroot/api 1.2.1 → 2.0.1

package/dist/cache.d.ts

@@ -97,46 +97,34 @@ export interface JobtypejobstepFilters {
     /** Case-insensitive partial match on description, jobType, or jobStep */
     q?: string;
 }
-export declare function getEmployees(filters?: EmployeeFilters): Promise<Employee[]>;
-export declare function getEmployeesDropdown(filters?: EmployeeFilters): Promise<DropdownOption[]>;
-/** Single employee by ID — always fetches fresh (no IndexedDB). */
-export declare function getEmployee(employeeId: string): Promise<Employee>;
+declare function getEmployees(filters?: EmployeeFilters): Promise<Employee[]>;
+declare function getEmployeesDropdown(filters?: EmployeeFilters): Promise<DropdownOption[]>;
 /** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
-export declare function getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
+declare function getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
 /** Full supervisor chain above an employee — always fetches fresh. */
-export declare function getSupervisorChain(employeeId: string): Promise<Employee[]>;
+declare function getSupervisorChain(employeeId: string): Promise<Employee[]>;
 /** Look up JDE number and employee from email — always fetches fresh. */
-export declare function getJdeFromEmail(email: string): Promise<{
+declare function getJdeFromEmail(email: string): Promise<{
     jde: string | null;
     employee: Employee | null;
 }>;
 /** Verify employee identity — always fetches fresh. */
-export declare function verifyIdentity(inputs: {
+declare function verifyIdentity(inputs: {
     first3FirstName: string;
     first3LastName: string;
     dob: string;
     ssn4: string;
 }): Promise<Employee | null>;
-export declare function getWorkorders(filters?: WorkorderFilters): Promise<Workorder[]>;
-export declare function getWorkordersDropdown(filters?: WorkorderFilters): Promise<DropdownOption[]>;
-/** Single workorder by ID — always fetches fresh (no IndexedDB). */
-export declare function getWorkorder(id: string): Promise<Workorder>;
-export declare function getCostcodes(filters?: CostcodeFilters): Promise<Costcode[]>;
-export declare function getCostcodesDropdown(filters?: CostcodeFilters): Promise<DropdownOption[]>;
-/** Single cost code by ID — always fetches fresh (no IndexedDB). */
-export declare function getCostcode(id: string): Promise<Costcode>;
-export declare function getPaytypes(filters?: PaytypeFilters): Promise<Paytype[]>;
-export declare function getPaytypesDropdown(filters?: PaytypeFilters): Promise<PaytypeDropdownOption[]>;
-/** Single pay type by ID — always fetches fresh (no IndexedDB). */
-export declare function getPaytype(id: string): Promise<Paytype>;
-export declare function getBusinessUnits(filters?: BusinessUnitFilters): Promise<BusinessUnit[]>;
-export declare function getBusinessUnitsDropdown(filters?: BusinessUnitFilters): Promise<DropdownOption[]>;
-/** Single business unit by ID — always fetches fresh (no IndexedDB). */
-export declare function getBusinessUnit(id: string): Promise<BusinessUnit>;
-export declare function getJobtypejobsteps(filters?: JobtypejobstepFilters): Promise<Jobtypejobstep[]>;
-export declare function getJobtypejobstepsDropdown(filters?: JobtypejobstepFilters): Promise<DropdownOption[]>;
-/** Single job type/job step by ID — always fetches fresh (no IndexedDB). */
-export declare function getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
+declare function getWorkorders(filters?: WorkorderFilters): Promise<Workorder[]>;
+declare function getWorkordersDropdown(filters?: WorkorderFilters): Promise<DropdownOption[]>;
+declare function getCostcodes(filters?: CostcodeFilters): Promise<Costcode[]>;
+declare function getCostcodesDropdown(filters?: CostcodeFilters): Promise<DropdownOption[]>;
+declare function getPaytypes(filters?: PaytypeFilters): Promise<Paytype[]>;
+declare function getPaytypesDropdown(filters?: PaytypeFilters): Promise<PaytypeDropdownOption[]>;
+declare function getBusinessUnits(filters?: BusinessUnitFilters): Promise<BusinessUnit[]>;
+declare function getBusinessUnitsDropdown(filters?: BusinessUnitFilters): Promise<DropdownOption[]>;
+declare function getJobtypejobsteps(filters?: JobtypejobstepFilters): Promise<Jobtypejobstep[]>;
+declare function getJobtypejobstepsDropdown(filters?: JobtypejobstepFilters): Promise<DropdownOption[]>;
 /**
  * Clear the IndexedDB cache for a specific entity, or all entities.
  *
@@ -150,3 +138,38 @@ export declare function getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
  * clearCache()  // clear everything
  */
 export declare function clearCache(entity?: IdbStore): void;
+export declare const employees: {
+    getAll: typeof getEmployees;
+    dropdown: typeof getEmployeesDropdown;
+    get: (id: string) => Promise<Employee | null>;
+    getPrivileged: typeof getEmployeePrivileged;
+    getSupervisorChain: typeof getSupervisorChain;
+    getJdeFromEmail: typeof getJdeFromEmail;
+    verifyIdentity: typeof verifyIdentity;
+};
+export declare const workorders: {
+    getAll: typeof getWorkorders;
+    dropdown: typeof getWorkordersDropdown;
+    get: (id: string) => Promise<Workorder | null>;
+};
+export declare const costcodes: {
+    getAll: typeof getCostcodes;
+    dropdown: typeof getCostcodesDropdown;
+    get: (id: string) => Promise<Costcode | null>;
+};
+export declare const paytypes: {
+    getAll: typeof getPaytypes;
+    dropdown: typeof getPaytypesDropdown;
+    get: (id: string) => Promise<Paytype | null>;
+};
+export declare const businessUnits: {
+    getAll: typeof getBusinessUnits;
+    dropdown: typeof getBusinessUnitsDropdown;
+    get: (id: string) => Promise<BusinessUnit | null>;
+};
+export declare const jobtypejobsteps: {
+    getAll: typeof getJobtypejobsteps;
+    dropdown: typeof getJobtypejobstepsDropdown;
+    get: (id: string) => Promise<Jobtypejobstep | null>;
+};
+export {};

package/dist/cache.js

@@ -20,7 +20,25 @@ import { getJobtypejobsteps as _getJobtypejobsteps, getJobtypejobstep as _getJob
 // ---------------------------------------------------------------------------
 /** How long cached data is considered fresh before a background refresh is triggered. */
 const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+/** Server-side in-memory cache TTL for SSR/BFF usage. */
+const SERVER_CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
+const serverCache = new Map();
+function logReadFailure(operation, error) {
+    if (typeof window !== 'undefined')
+        return;
+    const detail = error instanceof Error ? { name: error.name, message: error.message } : { error };
+    console.error(`[APIHubReadFailOpen] ${operation}`, detail);
+}
 async function loadCached(store, fetcher) {
+    if (typeof window === 'undefined') {
+        const cached = serverCache.get(store);
+        if (cached && Date.now() - cached.fetchedAt < SERVER_CACHE_TTL_MS) {
+            return cached.data;
+        }
+        const data = await fetcher();
+        serverCache.set(store, { data, fetchedAt: Date.now() });
+        return data;
+    }
     const cached = await idbGet(store, 'all');
     if (cached) {
         // Only refresh in the background if the cached data is older than the TTL
@@ -195,57 +213,102 @@ async function applyCostcodeFilters(data, f) {
 // ---------------------------------------------------------------------------
 // Public API — Employees
 // ---------------------------------------------------------------------------
-export async function getEmployees(filters) {
-    const all = await loadCached('employees', () => _getEmployees());
+async function getEmployees(filters) {
+    let all;
+    try {
+        all = await loadCached('employees', () => _getEmployees());
+    }
+    catch (error) {
+        logReadFailure('employees.getAll', error);
+        return [];
+    }
     return applyEmployeeFilters(all, filters);
 }
-export async function getEmployeesDropdown(filters) {
+async function getEmployeesDropdown(filters) {
     const results = await getEmployees(filters);
     return results.map((e) => ({ value: e.employeeId, label: e.name ?? e.employeeId }));
 }
 /** Single employee by ID — always fetches fresh (no IndexedDB). */
-export async function getEmployee(employeeId) {
-    return _getEmployee(employeeId);
+async function getEmployee(employeeId) {
+    try {
+        return await _getEmployee(employeeId);
+    }
+    catch (error) {
+        logReadFailure('employees.get', error);
+        return null;
+    }
 }
 /** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
-export async function getEmployeePrivileged(employeeId) {
+async function getEmployeePrivileged(employeeId) {
     return _getEmployeePrivileged(employeeId);
 }
 /** Full supervisor chain above an employee — always fetches fresh. */
-export async function getSupervisorChain(employeeId) {
-    return _getSupervisorChain(employeeId);
+async function getSupervisorChain(employeeId) {
+    try {
+        return await _getSupervisorChain(employeeId);
+    }
+    catch (error) {
+        logReadFailure('employees.getSupervisorChain', error);
+        return [];
+    }
 }
 /** Look up JDE number and employee from email — always fetches fresh. */
-export async function getJdeFromEmail(email) {
-    return _getJdeFromEmail(email);
+async function getJdeFromEmail(email) {
+    try {
+        return await _getJdeFromEmail(email);
+    }
+    catch (error) {
+        logReadFailure('employees.getJdeFromEmail', error);
+        return { jde: null, employee: null };
+    }
 }
 /** Verify employee identity — always fetches fresh. */
-export async function verifyIdentity(inputs) {
+async function verifyIdentity(inputs) {
     return _verifyIdentity(inputs);
 }
 // ---------------------------------------------------------------------------
 // Public API — Workorders
 // ---------------------------------------------------------------------------
-export async function getWorkorders(filters) {
-    const all = await loadCached('workorders', () => _getWorkorders());
+async function getWorkorders(filters) {
+    let all;
+    try {
+        all = await loadCached('workorders', () => _getWorkorders());
+    }
+    catch (error) {
+        logReadFailure('workorders.getAll', error);
+        return [];
+    }
     return applyWorkorderFilters(all, filters);
 }
-export async function getWorkordersDropdown(filters) {
+async function getWorkordersDropdown(filters) {
     const results = await getWorkorders({ isActive: true, ...filters });
     return results.map((w) => ({ value: w.id, label: w.description ?? w.id }));
 }
 /** Single workorder by ID — always fetches fresh (no IndexedDB). */
-export async function getWorkorder(id) {
-    return _getWorkorder(id);
+async function getWorkorder(id) {
+    try {
+        return await _getWorkorder(id);
+    }
+    catch (error) {
+        logReadFailure('workorders.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Cost Codes
 // ---------------------------------------------------------------------------
-export async function getCostcodes(filters) {
-    const all = await loadCached('costcodes', () => _getCostcodes());
+async function getCostcodes(filters) {
+    let all;
+    try {
+        all = await loadCached('costcodes', () => _getCostcodes());
+    }
+    catch (error) {
+        logReadFailure('costcodes.getAll', error);
+        return [];
+    }
     return applyCostcodeFilters(all, filters);
 }
-export async function getCostcodesDropdown(filters) {
+async function getCostcodesDropdown(filters) {
     const mergedFilters = { isActive: true, entryFlag: true, ...filters };
     const results = await getCostcodes(mergedFilters);
     const now = new Date();
@@ -257,56 +320,104 @@ export async function getCostcodesDropdown(filters) {
     }));
 }
 /** Single cost code by ID — always fetches fresh (no IndexedDB). */
-export async function getCostcode(id) {
-    return _getCostcode(id);
+async function getCostcode(id) {
+    try {
+        return await _getCostcode(id);
+    }
+    catch (error) {
+        logReadFailure('costcodes.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Pay Types
 // ---------------------------------------------------------------------------
-export async function getPaytypes(filters) {
-    const all = await loadCached('paytypes', () => _getPaytypes());
+async function getPaytypes(filters) {
+    let all;
+    try {
+        all = await loadCached('paytypes', () => _getPaytypes());
+    }
+    catch (error) {
+        logReadFailure('paytypes.getAll', error);
+        return [];
+    }
     return applyPaytypeFilters(all, filters);
 }
-export async function getPaytypesDropdown(filters) {
-    const results = await getPaytypes(filters);
+async function getPaytypesDropdown(filters) {
+    const mergedFilters = { isActive: true, ...filters };
+    const results = await getPaytypes(mergedFilters);
     return results.map((p) => ({ value: p.id, label: p.description, payClass: p.payClass }));
 }
 /** Single pay type by ID — always fetches fresh (no IndexedDB). */
-export async function getPaytype(id) {
-    return _getPaytype(id);
+async function getPaytype(id) {
+    try {
+        return await _getPaytype(id);
+    }
+    catch (error) {
+        logReadFailure('paytypes.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Business Units
 // ---------------------------------------------------------------------------
-export async function getBusinessUnits(filters) {
-    const all = await loadCached('businessUnits', () => _getBusinessUnits());
+async function getBusinessUnits(filters) {
+    let all;
+    try {
+        all = await loadCached('businessUnits', () => _getBusinessUnits());
+    }
+    catch (error) {
+        logReadFailure('businessUnits.getAll', error);
+        return [];
+    }
     return applyBusinessUnitFilters(all, filters);
 }
-export async function getBusinessUnitsDropdown(filters) {
-    const results = await getBusinessUnits(filters);
+async function getBusinessUnitsDropdown(filters) {
+    const mergedFilters = { isActive: true, ...filters };
+    const results = await getBusinessUnits(mergedFilters);
     return results.map((b) => ({ value: b.id, label: b.description }));
 }
 /** Single business unit by ID — always fetches fresh (no IndexedDB). */
-export async function getBusinessUnit(id) {
-    return _getBusinessUnit(id);
+async function getBusinessUnit(id) {
+    try {
+        return await _getBusinessUnit(id);
+    }
+    catch (error) {
+        logReadFailure('businessUnits.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Job Type / Job Steps
 // ---------------------------------------------------------------------------
-export async function getJobtypejobsteps(filters) {
-    const all = await loadCached('jobtypejobsteps', () => _getJobtypejobsteps());
+async function getJobtypejobsteps(filters) {
+    let all;
+    try {
+        all = await loadCached('jobtypejobsteps', () => _getJobtypejobsteps());
+    }
+    catch (error) {
+        logReadFailure('jobtypejobsteps.getAll', error);
+        return [];
+    }
     return applyJobtypejobstepFilters(all, filters);
 }
-export async function getJobtypejobstepsDropdown(filters) {
-    const results = await getJobtypejobsteps(filters);
+async function getJobtypejobstepsDropdown(filters) {
+    const mergedFilters = { isActive: true, ...filters };
+    const results = await getJobtypejobsteps(mergedFilters);
     return results.map((j) => ({
         value: j.id,
         label: j.description ?? `${j.jobType ?? ''} ${j.jobStep ?? ''}`.trim(),
     }));
 }
 /** Single job type/job step by ID — always fetches fresh (no IndexedDB). */
-export async function getJobtypejobstep(id) {
-    return _getJobtypejobstep(id);
+async function getJobtypejobstep(id) {
+    try {
+        return await _getJobtypejobstep(id);
+    }
+    catch (error) {
+        logReadFailure('jobtypejobsteps.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Cache management
@@ -324,5 +435,48 @@ export async function getJobtypejobstep(id) {
  * clearCache()  // clear everything
  */
 export function clearCache(entity) {
+    if (entity) {
+        serverCache.delete(entity);
+    }
+    else {
+        serverCache.clear();
+    }
     idbClear(entity).catch(() => { });
 }
+// ---------------------------------------------------------------------------
+// Unified domain-style API (v2 contract)
+// ---------------------------------------------------------------------------
+export const employees = {
+    getAll: getEmployees,
+    dropdown: getEmployeesDropdown,
+    get: (id) => getEmployee(id),
+    getPrivileged: getEmployeePrivileged,
+    getSupervisorChain,
+    getJdeFromEmail,
+    verifyIdentity,
+};
+export const workorders = {
+    getAll: getWorkorders,
+    dropdown: getWorkordersDropdown,
+    get: (id) => getWorkorder(id),
+};
+export const costcodes = {
+    getAll: getCostcodes,
+    dropdown: getCostcodesDropdown,
+    get: (id) => getCostcode(id),
+};
+export const paytypes = {
+    getAll: getPaytypes,
+    dropdown: getPaytypesDropdown,
+    get: (id) => getPaytype(id),
+};
+export const businessUnits = {
+    getAll: getBusinessUnits,
+    dropdown: getBusinessUnitsDropdown,
+    get: (id) => getBusinessUnit(id),
+};
+export const jobtypejobsteps = {
+    getAll: getJobtypejobsteps,
+    dropdown: getJobtypejobstepsDropdown,
+    get: (id) => getJobtypejobstep(id),
+};

package/dist/costcodes.remote.d.ts

@@ -1,3 +1,3 @@
 export declare const getCostcodes: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Costcode[]>;
 export declare const getCostcodesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
-export declare const getCostcode: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Costcode>;
+export declare const getCostcode: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Costcode | null>;

package/dist/costcodes.remote.js

@@ -1,6 +1,21 @@
 import { query } from '$app/server';
 import { z } from 'zod';
 import { getClient } from './client.js';
+function isNotFoundError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /not found/i.test(error.message);
+}
+async function asNullable(fetcher) {
+    try {
+        return await fetcher();
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
 export const getCostcodes = query(async () => getClient().getCostcodes());
 export const getCostcodesDropdown = query(async () => getClient().getCostcodesDropdown());
-export const getCostcode = query(z.string(), async (id) => getClient().getCostcode(id));
+export const getCostcode = query(z.string(), async (id) => asNullable(() => getClient().getCostcode(id)));

package/dist/employees.remote.d.ts

@@ -1,6 +1,6 @@
 export declare const getEmployees: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Employee[]>;
 export declare const getEmployeesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
-export declare const getEmployee: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee>;
+export declare const getEmployee: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee | null>;
 export declare const getEmployeePrivileged: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").EmployeePrivileged>;
 export declare const getSupervisorChain: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
 export declare const getJdeFromEmail: import("@sveltejs/kit").RemoteQueryFunction<string, {

package/dist/employees.remote.js

@@ -1,6 +1,21 @@
 import { query, command } from '$app/server';
 import { z } from 'zod';
 import { getClient } from './client.js';
+function isNotFoundError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /not found/i.test(error.message);
+}
+async function asNullable(fetcher) {
+    try {
+        return await fetcher();
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
 const employeeIdSchema = z.string().min(1);
 const verifyIdentitySchema = z.object({
     first3FirstName: z.string(),
@@ -10,7 +25,7 @@ const verifyIdentitySchema = z.object({
 });
 export const getEmployees = query(async () => getClient().getEmployees());
 export const getEmployeesDropdown = query(async () => getClient().getEmployeesDropdown());
-export const getEmployee = query(employeeIdSchema, async (employeeId) => getClient().getEmployee(employeeId));
+export const getEmployee = query(employeeIdSchema, async (employeeId) => asNullable(() => getClient().getEmployee(employeeId)));
 export const getEmployeePrivileged = query(employeeIdSchema, async (employeeId) => getClient().getEmployeePrivileged(employeeId));
 export const getSupervisorChain = query(employeeIdSchema, async (employeeId) => getClient().getSupervisorChain(employeeId));
 export const getJdeFromEmail = query(z.string(), async (email) => getClient().getJdeFromEmail(email));

package/dist/index.d.ts

@@ -57,6 +57,29 @@ export interface ApiHubClientOptions {
     apiKey: string;
     /** Default cache TTL in milliseconds. Set to 0 to disable caching. Default: 5 minutes. */
     cacheTtl?: number;
+    /** Request timeout in milliseconds. Default: 10000. */
+    timeoutMs?: number;
+    /** Retry count for idempotent GET requests on transient failures. Default: 2. */
+    retryCount?: number;
+    /** Optional hook invoked whenever an APIHubError is raised. */
+    onError?: (error: ApiHubError) => void;
+}
+export declare class ApiHubError extends Error {
+    status: number | null;
+    path: string;
+    url: string;
+    responseBody: unknown;
+    retriable: boolean;
+    service: string;
+    constructor(options: {
+        message: string;
+        status: number | null;
+        path: string;
+        url: string;
+        responseBody: unknown;
+        retriable: boolean;
+        service?: string;
+    });
 }
 export interface DropdownOption {
     value: number | string;
@@ -89,6 +112,8 @@ export interface ChatRequest {
     function?: string;
     temperature?: number;
     maxTokens?: number;
+    /** Flag to enable RAG context enrichment in chat responses. */
+    enableRag?: boolean;
 }
 export interface ChatResponse {
     message: ChatMessage;
@@ -126,7 +151,7 @@ export interface StreamChatRequest {
         content: string;
     }[];
     userContext?: StreamChatUserContext;
-    useRag?: boolean;
+    enableRag?: boolean;
     tools?: string[];
     source?: string;
 }
@@ -208,8 +233,15 @@ export declare class ApiHubClient {
     private baseUrl;
     private apiKey;
     private cacheTtl;
+    private timeoutMs;
+    private retryCount;
+    private onError?;
     private cache;
     constructor(options: ApiHubClientOptions);
+    private isRetriableStatus;
+    private createApiHubError;
+    private fetchWithTimeout;
+    private delay;
     /** Clear all cached responses, or a specific path */
     clearCache(path?: string): void;
     private cachedRequest;
@@ -288,3 +320,33 @@ export declare class ApiHubClient {
     getJobtypejobstepsDropdown(): Promise<DropdownOption[]>;
     getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
 }
+export { employees, workorders, costcodes, paytypes, businessUnits, jobtypejobsteps, clearCache } from './cache.js';
+export declare const llm: {
+    getLogs: import("@sveltejs/kit").RemoteQueryFunction<void, LlmLog[]>;
+    chat: import("@sveltejs/kit").RemoteCommand<{
+        user: string;
+        messages: {
+            role: "system" | "user" | "assistant";
+            content: string;
+        }[];
+        source: string;
+        function?: string | undefined;
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        enableRag?: boolean | undefined;
+    }, Promise<ChatResponse>>;
+};
+export declare const rag: {
+    list: import("@sveltejs/kit").RemoteQueryFunction<void, DocumentRecord[]>;
+    upload: import("@sveltejs/kit").RemoteCommand<{
+        fileName: string;
+        base64Content: string;
+        uploadedBy: string;
+    }, Promise<DocumentRecord>>;
+    delete: import("@sveltejs/kit").RemoteCommand<number, Promise<void>>;
+    search: import("@sveltejs/kit").RemoteCommand<{
+        query: string;
+        topK?: number | undefined;
+    }, Promise<SearchResult[]>>;
+};
+export type { EmployeeFilters, WorkorderFilters, CostcodeFilters, PaytypeFilters, BusinessUnitFilters, JobtypejobstepFilters, } from './cache.js';