@yglin/tw-env-records 0.0.4 → 0.0.5

package/lib/authentication.d.ts

@@ -0,0 +1,8 @@
+import { AuthenticationService } from '@feathersjs/authentication';
+import type { Application } from './declarations';
+declare module './declarations' {
+    interface ServiceTypes {
+        authentication: AuthenticationService;
+    }
+}
+export declare const authentication: (app: Application) => void;

package/lib/configuration.d.ts

@@ -114,10 +114,13 @@ export declare const configurationSchema: import("@sinclair/typebox").TIntersect
         askAi: import("@sinclair/typebox").TObject<{
             ai_model: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
             ai_api_key: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
-            recordsLimit: import("@sinclair/typebox").TNumber;
+            recordsLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            maxRequestsPerDay: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            keepDailyStatsDays: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
         }>;
     }>;
     jobs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        internalSecret: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
         crawler: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
             enabled: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
             schedule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
@@ -184,6 +187,36 @@ export declare const configurationSchema: import("@sinclair/typebox").TIntersect
             }>>;
             internalSecret: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
         }>>;
+        duplicateCheckBatch: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            enabled: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            timezone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
+            max_records_per_window: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            max_candidates_per_record: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            similarity_threshold: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            schedules: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                submit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
+                process: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
+            }>>;
+            batch: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                use_file_input: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+                requests_per_batch: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+                display_name_prefix: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
+            }>>;
+            processing: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                max_retry_attempts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+                retry_interval_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+                confidence_threshold: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            }>>;
+            merge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                story_min_length: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            }>>;
+            backup_failure_log: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                enabled: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+                path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
+                retention_days: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            }>>;
+            internalSecret: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString<string>>;
+        }>>;
     }>>;
 }>]>;
 export type ApplicationConfiguration = Static<typeof configurationSchema>;

package/lib/{jobs → google}/gemini-client-factory.d.ts

@@ -14,13 +14,10 @@ export interface IGeminiClient {
 }
 /**
  * Default configuration applied to all Gemini requests
- * Includes Google Search grounding tool
+ * NOTE: Google Search grounding is NOT included because the Batch API
+ * does not return grounding metadata, making it ineffective for batch jobs.
  */
-export declare const GEMINI_DEFAULT_CONFIG: {
-    tools: {
-        googleSearch: {};
-    }[];
-};
+export declare const GEMINI_DEFAULT_CONFIG: {};
 /**
  * Default Gemini model
  */
@@ -44,8 +41,8 @@ declare class GeminiClientFactory {
      */
     getModel(): string;
     /**
-     * Get default configuration with Google Search grounding
-     * Use this in all generateContent calls
+     * Get default configuration for Gemini API requests
+     * NOTE: Does not include Google Search grounding since Batch API doesn't support it
      */
     getDefaultConfig(): typeof GEMINI_DEFAULT_CONFIG;
     /**

package/lib/hooks/after-askai-create.d.ts

@@ -0,0 +1,2 @@
+import type { HookContext } from '@feathersjs/feathers';
+export declare const afterAskAiCreate: (context: HookContext) => Promise<HookContext<import("@feathersjs/feathers").Application<any, any>, any>>;

package/lib/hooks/before-askai-create.d.ts

@@ -0,0 +1,2 @@
+import type { HookContext } from '@feathersjs/feathers';
+export declare const beforeAskAiCreate: (context: HookContext) => Promise<HookContext<import("@feathersjs/feathers").Application<any, any>, any>>;

package/lib/internal/duplicate-check-batch-endpoints.d.ts

@@ -0,0 +1,2 @@
+import { Application } from '../declarations';
+export declare const duplicateCheckBatchEndpoints: (app: Application) => void;

package/lib/jobs/audit-batch-process.d.ts

@@ -1,15 +1,9 @@
 import { Application } from '../declarations';
-import { type IGeminiClient } from './gemini-client-factory';
-export interface ProcessStats {
-    processed: number;
+import { GenericBatchProcessStats } from './shared/index';
+export interface ProcessStats extends GenericBatchProcessStats {
     recordsUpdated: number;
     recordsSkipped: number;
-    errors: number;
 }
-/**
- * Download and parse results from a completed batch job
- */
-export declare function downloadAndParseResults(client: IGeminiClient, jobName: string, isFileResult: boolean, resultFileName?: string): Promise<any[]>;
 /**
  * Process all pending audit batch jobs
  */

package/lib/jobs/audit-batch-state.d.ts

@@ -36,3 +36,7 @@ export declare function updateCleanupTime(): void;
  * WARNING: Only use in tests!
  */
 export declare function resetStateForTesting(): void;
+/**
+ * Reconstruct state from database on service startup
+ */
+export declare function reconstructFromDatabase(batchJobsService: any): Promise<void>;

package/lib/jobs/audit-batch-submit.d.ts

@@ -1,20 +1,12 @@
 import { Application } from '../declarations';
-export interface SubmitStats {
-    submitted: number;
+import { GenericBatchSubmitStats } from './shared/index';
+export interface SubmitStats extends GenericBatchSubmitStats {
     recordsQueued: number;
-    jobNames: string[];
 }
 /**
  * Build the audit prompt for a single record
  */
 export declare function buildAuditPrompt(record: any): string;
-/**
- * Create a batch request object for audit
- */
-/**
- * Create a batch request object for audit
- */
-export declare function createBatchRequest(prompt: string, recordId: number): any;
 /**
  * Submit a new audit batch job
  */

package/lib/jobs/audit-batch.d.ts

@@ -1,9 +1,8 @@
 import { Application } from '../declarations';
 import { type SubmitStats } from './audit-batch-submit';
 import { type ProcessStats } from './audit-batch-process';
-export interface CleanupStats {
-    removed: number;
-}
+import { getBatchAuditState, reconstructFromDatabase } from './audit-batch-state';
+import { type CleanupStats } from './shared/index';
 export interface CycleStats {
     submit: SubmitStats;
     process: ProcessStats;
@@ -34,3 +33,4 @@ export declare function getAuditBatchStatus(app: Application): Promise<{
  * Run a complete audit batch cycle (submit + process + cleanup)
  */
 export declare function runAuditBatchCycle(app: Application): Promise<CycleStats>;
+export { getBatchAuditState, reconstructFromDatabase };

package/lib/jobs/crawler-batch-process.d.ts

@@ -1,19 +1,10 @@
 import { Application } from '../declarations';
-import { type IGeminiClient } from './gemini-client-factory';
-export interface ProcessStats {
-    processed: number;
-    recordsExtracted: number;
-    duplicateCheckJobsCreated: number;
-    recordsCreated: number;
-    recordsUpdated: number;
-    duplicatesChecked: number;
-    errors: number;
+import { GenericBatchProcessStats } from './shared/index';
+export interface ProcessStats extends GenericBatchProcessStats {
+    recordsExtracted?: number;
+    recordsCreated?: number;
 }
 /**
- * Download and parse results from a completed batch job
- */
-export declare function downloadAndParseResults(client: IGeminiClient, jobName: string, isFileResult: boolean, resultFileName?: string): Promise<any[]>;
-/**
- * Process all pending batch jobs
+ * Process all pending crawl batch jobs
  */
 export declare function processPendingBatches(app: Application): Promise<ProcessStats>;

package/lib/jobs/crawler-batch-state.d.ts

@@ -23,17 +23,48 @@ export type BatchCrawlerState = {
     runningJobs?: number;
     succeededJobs?: number;
 };
+/**
+ * Get current crawler batch state
+ */
 export declare function getBatchCrawlerState(): BatchCrawlerState;
+/**
+ * Mark submit phase as started
+ */
 export declare function startSubmit(): void;
+/**
+ * Mark submit phase as completed
+ */
 export declare function finishSubmit(result: BatchCrawlerStats, durationMs: number): void;
+/**
+ * Mark submit phase as failed
+ */
 export declare function failSubmit(error: unknown, durationMs: number): void;
+/**
+ * Mark process phase as started
+ */
 export declare function startProcess(): void;
+/**
+ * Mark process phase as completed
+ */
 export declare function finishProcess(result: BatchCrawlerStats, durationMs: number): void;
+/**
+ * Mark process phase as failed
+ */
 export declare function failProcess(error: unknown, durationMs: number): void;
+/**
+ * Update job counts from database
+ */
 export declare function updateJobCounts(pending: number, running: number, succeeded: number): void;
+/**
+ * Mark cleanup operation with current timestamp
+ */
 export declare function updateCleanupTime(): void;
 /**
- * Reset state for testing purposes
- * WARNING: Only use in tests!
+ * Reset state for testing
  */
 export declare function resetStateForTesting(): void;
+/**
+ * Reconstruct state from database
+ * Used on service startup
+ */
+export declare function reconstructFromDatabase(batchJobsService: any): Promise<void>;

package/lib/jobs/crawler-batch-submit.d.ts

@@ -1,17 +1,7 @@
 import { Application } from '../declarations';
-export interface SubmitStats {
-    submitted: number;
-    jobNames: string[];
+import { GenericBatchSubmitStats } from './shared/index';
+export interface SubmitStats extends GenericBatchSubmitStats {
 }
-/**
- * Build the crawl prompt for batch request
- * Reuses the same prompt logic as the synchronous crawler
- */
-export declare function buildCrawlPrompt(schema: any): string;
-/**
- * Create a batch request object
- */
-export declare function createBatchRequest(prompt: string, config: any): any;
 /**
  * Submit a new crawl batch job
  */

package/lib/jobs/crawler-batch.d.ts

@@ -1,7 +1,9 @@
 import { Application } from '../declarations';
 import { SubmitStats } from './crawler-batch-submit';
 import { ProcessStats } from './crawler-batch-process';
-import { getBatchCrawlerState, BatchCrawlerState } from './crawler-batch-state';
+import { getBatchCrawlerState, BatchCrawlerState, reconstructFromDatabase } from './crawler-batch-state';
+import { CleanupStats as SharedCleanupStats } from './shared/index';
+export type CleanupStats = SharedCleanupStats;
 export interface CycleStats {
     submitted: number;
     processed: number;
@@ -12,9 +14,6 @@ export interface CycleStats {
     cleanedUp: number;
     errors: number;
 }
-export interface CleanupStats {
-    cleanedUp: number;
-}
 export type { SubmitStats } from './crawler-batch-submit';
 export type { ProcessStats } from './crawler-batch-process';
 export interface BatchStatus {
@@ -38,7 +37,7 @@ export declare function submitPhase(app: Application): Promise<SubmitStats>;
  */
 export declare function processPhase(app: Application): Promise<ProcessStats>;
 /**
- * Cleanup phase - remove old completed jobs
+ * Cleanup phase - remove old completed jobs based on retention policy
  */
 export declare function cleanupPhase(app: Application): Promise<CleanupStats>;
 /**
@@ -49,4 +48,4 @@ export declare function getBatchStatus(app: Application): Promise<BatchStatus[]>
  * Run full batch crawl cycle (submit → process → cleanup)
  */
 export declare function runBatchCrawlCycle(app: Application): Promise<CycleStats>;
-export { getBatchCrawlerState, BatchCrawlerState };
+export { getBatchCrawlerState, BatchCrawlerState, reconstructFromDatabase };

package/lib/jobs/crawler-prompt.d.ts

@@ -0,0 +1,6 @@
+import { Application } from '../declarations';
+/**
+ * Build the crawl prompt for batch request
+ * Reuses the same prompt logic as the synchronous crawler
+ */
+export declare function buildCrawlPrompt(app: Application): Promise<string>;

package/lib/jobs/duplicate-check/find-candidates.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Find records needing duplicate check and their potential duplicate candidates
+ */
+import { Application } from '../../declarations';
+/**
+ * Find records that need duplicate checking
+ * @param app - Feathers application
+ * @param limit - Maximum number of records to return (default: 50)
+ * @returns Array of records with duplicate_check_status = 'pending'
+ */
+export declare function findRecordsNeedingDuplicateCheck(app: Application, limit?: number): Promise<any[]>;
+/**
+ * Calculate Jaccard similarity between two arrays
+ * @param arr1 - First array
+ * @param arr2 - Second array
+ * @returns Similarity score between 0.0 and 1.0
+ */
+export declare function calculateJaccardSimilarity(arr1: string[], arr2: string[]): number;
+/**
+ * Find potential duplicate candidates for a given record
+ * Uses two-phase filtering: database filter (date + place) + in-memory similarity (tags + people)
+ *
+ * @param app - Feathers application
+ * @param record - The record to find duplicates for
+ * @param maxCandidates - Maximum number of candidates to return (default: 20)
+ * @param similarityThreshold - Minimum Jaccard similarity threshold (default: 0.5)
+ * @returns Array of candidate records that might be duplicates
+ */
+export declare function findDuplicateCandidates(app: Application, record: any, maxCandidates?: number, similarityThreshold?: number): Promise<any[]>;

package/lib/jobs/duplicate-check/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Duplicate-check module exports
+ */
+export { findRecordsNeedingDuplicateCheck, findDuplicateCandidates, calculateJaccardSimilarity } from './find-candidates';
+export { buildDuplicateCheckPrompt } from './prompt';
+export { mergeRecordsFromGeminiResponse, type MergeResult } from './merge-records';

package/lib/jobs/duplicate-check/log-failed-backup.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Log failed MongoDB backup to file for recovery
+ */
+/**
+ * Log a failed MongoDB backup to file
+ * Writes in JSONL format (one JSON object per line) for easy recovery
+ *
+ * @param record - The record that failed to backup
+ * @param error - The error that occurred
+ * @param metadata - Additional metadata about the deletion
+ */
+export declare function logFailedMongoBackup(record: any, error: Error, metadata: {
+    merged_into_id?: number;
+    deletion_reason?: string;
+    deleted_at: string;
+    deleted_by?: string;
+}): void;

package/lib/jobs/duplicate-check/merge-records.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Merge duplicate records and handle deletion with MongoDB backup
+ */
+import { Application } from '../../declarations';
+export interface MergeResult {
+    mergedRecordId: number;
+    deletedRecordIds: number[];
+    confidence: number;
+}
+/**
+ * Merge duplicate records into a single record
+ * Creates a new merged record and deletes the duplicates (with MongoDB backup via hook)
+ *
+ * @param app - Feathers application
+ * @param duplicateIds - Array of record IDs to merge
+ * @param mergedRecordData - Data for the merged record
+ * @param confidence - AI confidence score
+ * @returns MergeResult with merged record ID and deleted IDs
+ */
+export declare function mergeRecordsFromGeminiResponse(app: Application, duplicateIds: number[], mergedRecordData: any, confidence: number): Promise<MergeResult>;

package/lib/jobs/duplicate-check/prompt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Build prompts for Gemini API to detect and merge duplicate records
+ */
+/**
+ * Build a duplicate-check prompt for Gemini API
+ * Asks the AI to identify which candidates are duplicates and provide a merged record
+ *
+ * @param newRecord - The record being checked for duplicates
+ * @param candidates - Array of potential duplicate records
+ * @returns Prompt string for Gemini API
+ */
+export declare function buildDuplicateCheckPrompt(newRecord: any, candidates: any[]): string;

package/lib/jobs/duplicate-check-batch-process.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Duplicate-check batch result processor
+ * Implements BatchJobResultHandler to process completed batch jobs from Gemini API
+ * Handles merging duplicates, managing status, and fallback for failed cases
+ */
+import { Application } from '../declarations';
+import { GenericBatchProcessStats } from './shared';
+export interface ValidatedDuplicateCheckResult {
+    duplicateIds: number[];
+    mergedRecord: any | null;
+    confidence?: number;
+}
+export declare function validateDuplicateCheckResponse(recordId: number, parsed: any): ValidatedDuplicateCheckResult;
+export interface ProcessStats extends GenericBatchProcessStats {
+    merged?: number;
+    manualReviewFlagged?: number;
+    skipped?: number;
+    checked?: number;
+}
+/**
+ * Process pending duplicate-check batch jobs
+ * Polls for completed jobs and processes their results
+ *
+ * @param app - Feathers application
+ * @returns ProcessStats with processing results
+ */
+export declare function processDuplicateCheckBatches(app: Application): Promise<ProcessStats>;

package/lib/jobs/duplicate-check-batch-state.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Duplicate-check batch state management
+ * Optional: Tracks execution state for monitoring and debugging
+ * Can be extended to support checkpoint-based recovery
+ */
+export interface BatchExecutionState {
+    phase: 'idle' | 'submitting' | 'processing' | 'error';
+    lastSubmitAt?: Date;
+    lastProcessAt?: Date;
+    lastSuccessAt?: Date;
+    lastErrorAt?: Date;
+    lastErrorMessage?: string;
+    pendingJobCount?: number;
+    completedJobCount?: number;
+}
+/**
+ * In-memory state tracker for batch execution
+ * For production use, consider storing in database or cache (Redis)
+ */
+declare class DuplicateCheckBatchStateManager {
+    private state;
+    setState(phase: BatchExecutionState['phase']): void;
+    recordSubmitStart(): void;
+    recordSubmitComplete(): void;
+    recordProcessStart(): void;
+    recordProcessComplete(): void;
+    recordError(error: Error): void;
+    updatePendingJobCount(count: number): void;
+    updateCompletedJobCount(count: number): void;
+    getState(): BatchExecutionState;
+    isIdle(): boolean;
+    isRunning(): boolean;
+    hasError(): boolean;
+    getLastError(): string | undefined;
+    resetError(): void;
+}
+export declare const duplicateCheckBatchState: DuplicateCheckBatchStateManager;
+/**
+ * Get current batch execution state for monitoring
+ * Can be exposed via API endpoint for dashboards
+ *
+ * @returns Current execution state
+ */
+export declare function getDuplicateCheckBatchState(): BatchExecutionState;
+/**
+ * Check if batch can run (no other instance running)
+ * Use for preventing concurrent executions
+ *
+ * @returns true if batch can run
+ */
+export declare function canRunDuplicateCheckBatch(): boolean;
+export {};

package/lib/jobs/duplicate-check-batch-submit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Duplicate-check batch submission handler
+ * Implements BatchRequestFactory to submit duplicate-check batch jobs to Gemini API
+ * Reuses shared submitBatchJob utility for API communication
+ */
+import { Application } from '../declarations';
+import { GenericBatchSubmitStats, BatchJobMetadata } from './shared';
+export interface SubmitStats extends GenericBatchSubmitStats {
+    recordsWithoutCandidates?: number;
+}
+export interface DuplicateCheckBatchJobMetadata extends BatchJobMetadata {
+    candidatesArray: {
+        subjectId: string;
+        candidates: string[];
+    }[];
+    recordIds?: number[];
+}
+/**
+ * Submit a new duplicate-check batch job
+ * Finds records needing checking, identifies candidates, and submits to Gemini batch API
+ * Records without candidates are marked as checked immediately (no API call needed)
+ *
+ * @param app - Feathers application
+ * @returns SubmitStats with submission results
+ */
+export declare function submitDuplicateCheckBatch(app: Application): Promise<SubmitStats>;

package/lib/jobs/duplicate-check-batch.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Duplicate-check batch orchestrator
+ * Main entry point for managing the duplicate-check batch job lifecycle
+ * Coordinates submission and processing phases with scheduling integration
+ */
+import { Application } from '../declarations';
+export interface DuplicateCheckBatchStats {
+    submitted?: number;
+    processed?: number;
+    succeeded?: number;
+    failed?: number;
+    merged?: number;
+    recordsWithoutCandidates?: number;
+}
+/**
+ * Execute full duplicate-check batch cycle
+ * Runs both submit and process phases in sequence
+ * Designed to be called by scheduler or manually via endpoint
+ *
+ * @param app - Feathers application
+ * @returns Statistics from both phases
+ */
+export declare function executeDuplicateCheckBatch(app: Application): Promise<DuplicateCheckBatchStats>;
+/**
+ * Process only (skip submission)
+ * Use this to catch up on processing completed jobs without submitting new ones
+ * Useful for recovery or manual processing runs
+ *
+ * @param app - Feathers application
+ * @returns Process statistics
+ */
+export declare function processDuplicateCheckBatchOnly(app: Application): Promise<import("./duplicate-check-batch-process").ProcessStats>;
+/**
+ * Submit only (skip processing)
+ * Use this to only submit new batch jobs without processing results
+ * Useful if you want to control submission and processing timing separately
+ *
+ * @param app - Feathers application
+ * @returns Submit statistics
+ */
+export declare function submitDuplicateCheckBatchOnly(app: Application): Promise<import("./duplicate-check-batch-submit").SubmitStats>;

package/lib/jobs/shared/batch-common.d.ts

@@ -0,0 +1,90 @@
+import { Application } from '../../declarations';
+/**
+ * Generic configuration for batch job creation
+ */
+export interface GenericBatchRequestConfig {
+    responseMimeType?: string;
+    tools?: any[];
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxOutputTokens?: number;
+    [key: string]: any;
+}
+/**
+ * Statistics for batch submission
+ */
+export interface GenericBatchSubmitStats {
+    submitted: number;
+    jobNames: string[];
+    recordsQueued?: number;
+    [key: string]: any;
+}
+/**
+ * Statistics for batch processing
+ */
+export interface GenericBatchProcessStats {
+    processed: number;
+    recordsExtracted?: number;
+    duplicateCheckJobsCreated?: number;
+    recordsCreated?: number;
+    recordsUpdated?: number;
+    duplicatesChecked?: number;
+    errors?: number;
+    [key: string]: any;
+}
+/**
+ * Metadata for batch jobs
+ */
+export interface BatchJobMetadata {
+    displayName: string;
+    submittedAt?: string;
+    [key: string]: any;
+}
+/**
+ * Generic batch job record in database
+ */
+export interface GenericBatchJob {
+    id?: number;
+    job_name: string;
+    job_type: string;
+    status: string;
+    model?: string;
+    request_count?: number;
+    metadata?: BatchJobMetadata;
+    schema_version?: number;
+    created_at?: string;
+    updated_at?: string;
+    completed_at?: string;
+    error_message?: string;
+}
+/**
+ * Clean JSON response by removing markdown code blocks
+ * Handles patterns like ```json ... ```
+ */
+export declare function cleanJSONResponse(jsonResponse: string): string;
+/**
+ * Extract response text from Gemini API response object
+ */
+export declare function extractResponseText(response: any): string;
+/**
+ * No-op function - we now keep the JOB_STATE_ prefix to match Gemini API convention
+ * Status values are stored with prefix: JOB_STATE_SUCCEEDED, JOB_STATE_RUNNING, etc.
+ */
+export declare function stripJobStatePrefix(status: string): string;
+/**
+ * Parse JSON response text with error handling
+ */
+export declare function parseResponseJSON(text: string): any;
+/**
+ * Get cleanup configuration with defaults
+ */
+export declare function getCleanupConfig(app: Application): BatchCleanupConfig;
+/**
+ * Cleanup configuration for batch jobs
+ */
+export interface BatchCleanupConfig {
+    successful_retention_days: number;
+    failed_retention_days: number;
+    enable_auto_cleanup: boolean;
+}