import { PrismaClient } from '@prisma/client';
import { b as TimeEntry, c as Timesheet, R as RateCard, d as TimeCategory, e as TimeLock, A as AuditLog } from '../../types-ecK2b88Z.js';
import { C as CreateTimeEntryInput, U as UpdateTimeEntryInput, T as TimeEntryFilter, P as PaginationParams } from '../../schemas-ZDVMEZ9A.js';
import 'zod';

/**
 * Repository interfaces and Prisma implementations
 */

interface TimeEntryRepository {
    create(input: CreateTimeEntryInput): Promise<TimeEntry>;
    update(id: string, input: UpdateTimeEntryInput): Promise<TimeEntry>;
    delete(id: string): Promise<void>;
    findById(id: string): Promise<TimeEntry | null>;
    findMany(filter: TimeEntryFilter): Promise<{
        data: TimeEntry[];
        total: number;
    }>;
    findOverlapping(developerId: string, startAt: Date, endAt: Date, excludeId?: string): Promise<TimeEntry[]>;
}
interface TimesheetRepository {
    generate(developerId: string, clientId: string, periodStart: Date, periodEnd: Date): Promise<Timesheet>;
    findById(id: string): Promise<Timesheet | null>;
    findMany(filter: PaginationParams & {
        developerId?: string;
        clientId?: string;
    }): Promise<{
        data: Timesheet[];
        total: number;
    }>;
    submit(id: string): Promise<Timesheet>;
    approve(id: string, approvedBy: string): Promise<Timesheet>;
    reject(id: string, rejectedBy: string, reason: string): Promise<Timesheet>;
}
interface RateCardRepository {
    create(input: Omit<RateCard, 'id' | 'createdAt' | 'updatedAt'>): Promise<RateCard>;
    update(id: string, input: Partial<RateCard>): Promise<RateCard>;
    findById(id: string): Promise<RateCard | null>;
    findEffective(params: {
        developerId?: string;
        projectId?: string;
        clientId?: string;
        date: Date;
    }): Promise<RateCard | null>;
    findMany(filter: PaginationParams): Promise<{
        data: RateCard[];
        total: number;
    }>;
}
interface TimeCategoryRepository {
    create(input: Omit<TimeCategory, 'id'>): Promise<TimeCategory>;
    update(id: string, input: Partial<TimeCategory>): Promise<TimeCategory>;
    findById(id: string): Promise<TimeCategory | null>;
    findAll(): Promise<TimeCategory[]>;
}
interface TimeLockRepository {
    create(input: Omit<TimeLock, 'id'>): Promise<TimeLock>;
    unlock(id: string, unlockedBy: string): Promise<TimeLock>;
    findActive(projectId?: string, clientId?: string): Promise<TimeLock[]>;
    checkLocked(params: {
        projectId?: string;
        clientId?: string;
        startAt: Date;
        endAt: Date;
    }): Promise<boolean>;
}
interface AuditLogRepository {
    create(input: Omit<AuditLog, 'id' | 'createdAt'>): Promise<AuditLog>;
    findMany(filter: {
        entityType?: string;
        entityId?: string;
        userId?: string;
    } & PaginationParams): Promise<{
        data: AuditLog[];
        total: number;
    }>;
}
/**
 * Create repository instances with Prisma client
 */
declare function createRepositories(prisma: PrismaClient): {
    timeEntry: TimeEntryRepository;
    timesheet: TimesheetRepository;
    rateCard: RateCardRepository;
    timeCategory: TimeCategoryRepository;
    timeLock: TimeLockRepository;
    auditLog: AuditLogRepository;
};

/**
 * Mappers between Prisma models and domain types
 */

/**
 * Map Prisma TimeEntry to domain TimeEntry
 */
declare function mapPrismaToTimeEntry(prismaEntry: any): TimeEntry;
/**
 * Map domain TimeEntry to Prisma create input
 */
declare function mapTimeEntryToPrismaCreate(entry: Partial<TimeEntry>): any;
/**
 * Map domain TimeEntry to Prisma update input
 */
declare function mapTimeEntryToPrismaUpdate(entry: Partial<TimeEntry>): any;

/**
 * Prisma client configuration for Time Log
 */

interface TimeLogPrismaConfig {
    prisma: PrismaClient;
}
/**
 * Create a configured Prisma client instance for Time Log
 */
declare function createTimeLogPrismaClient(config: TimeLogPrismaConfig): PrismaClient;

export { type AuditLogRepository, type RateCardRepository, type TimeCategoryRepository, type TimeEntryRepository, type TimeLockRepository, type TimeLogPrismaConfig, type TimesheetRepository, createRepositories, createTimeLogPrismaClient, mapPrismaToTimeEntry, mapTimeEntryToPrismaCreate, mapTimeEntryToPrismaUpdate };