/**
 * Type definitions for the achievements engine
 * Framework-agnostic achievement system types
 */

type AchievementMetricValue = number | string | boolean | Date | null | undefined;
type AchievementMetricArrayValue = AchievementMetricValue | AchievementMetricValue[];
interface AchievementMetrics {
    [key: string]: AchievementMetricValue[];
}
interface AchievementDetails {
    achievementId: string;
    achievementTitle: string;
    achievementDescription: string;
    achievementIconKey?: string;
    confetti?: AchievementConfetti;
}
interface AchievementWithStatus extends AchievementDetails {
    isUnlocked: boolean;
}
interface AchievementCondition {
    isConditionMet: (value: AchievementMetricArrayValue, state: AchievementState) => boolean;
    achievementDetails: AchievementDetails | AchievementWithStatus;
}
interface AchievementConfiguration {
    [key: string]: AchievementCondition[];
}
interface SimpleAchievementDetails {
    title: string;
    description?: string;
    icon?: string;
    confetti?: AchievementConfetti;
}
interface CustomAchievementDetails extends SimpleAchievementDetails {
    condition: (metrics: Record<string, any>) => boolean;
}
interface SimpleAchievementConfig {
    [metric: string]: {
        [threshold: string]: SimpleAchievementDetails | CustomAchievementDetails;
    };
}
type AchievementConfetti = false | Record<string, unknown>;
type AchievementConfigurationType = AchievementConfiguration | SimpleAchievementConfig;
interface AchievementState {
    metrics: AchievementMetrics;
    unlockedAchievements: string[];
}
/**
 * Metric updater function for custom event-to-metric mapping
 */
type MetricUpdater = (eventData: any, currentMetrics: Record<string, any>) => Record<string, any>;
/**
 * Event mapping configuration
 * Maps event names to either:
 * - String (metric name) for direct 1:1 mapping
 * - MetricUpdater function for custom transformation
 */
interface EventMapping {
    [eventName: string]: string | MetricUpdater;
}

type AchievementSubjectId = string;
interface AchievementProgress {
    current: number;
    target: number;
    percent: number;
}
interface AchievementDto {
    id: string;
    title: string;
    description?: string;
    icon?: string;
    iconKey?: string;
    isUnlocked: boolean;
    unlockedAt?: string | null;
    progress?: AchievementProgress;
    metadata?: Record<string, unknown>;
    confetti?: AchievementConfetti;
}
interface AchievementApiSnapshot {
    achievements: AchievementDto[];
    unlockedIds: string[];
    unlockedAchievements: AchievementDto[];
    unlockedCount: number;
    totalCount: number;
    metrics?: Record<string, unknown>;
}
interface AchievementMutationResult {
    snapshot: AchievementApiSnapshot;
    newlyUnlocked: AchievementDto[];
}
interface TrackAchievementInput {
    metric: string;
    value: unknown;
}
interface TrackManyAchievementsInput {
    metrics: Record<string, unknown>;
}
interface IncrementAchievementInput {
    metric: string;
    amount?: number;
}
interface AchievementEventInput {
    name: string;
    payload?: unknown;
}
interface StoredAchievementState {
    metrics: Record<string, unknown>;
    unlockedIds: string[];
    unlockedAt?: Record<string, string>;
}
interface AchievementRepository {
    getState(subjectId: AchievementSubjectId): Promise<StoredAchievementState | undefined>;
    saveState(subjectId: AchievementSubjectId, state: StoredAchievementState): Promise<void>;
    clearState?(subjectId: AchievementSubjectId): Promise<void>;
    withTransaction?<T>(subjectId: AchievementSubjectId, run: () => Promise<T>): Promise<T>;
}
interface AchievementServiceConfig {
    achievements: AchievementConfigurationType;
    repository: AchievementRepository;
    eventMapping?: EventMapping;
    clock?: () => Date;
}
interface AchievementClient {
    getSnapshot(): Promise<AchievementApiSnapshot>;
    track(metric: string, value: unknown): Promise<AchievementMutationResult>;
    trackMany?(metrics: Record<string, unknown>): Promise<AchievementMutationResult>;
    increment(metric: string, amount?: number): Promise<AchievementMutationResult>;
    event(name: string, payload?: unknown): Promise<AchievementMutationResult>;
    reset?(): Promise<AchievementApiSnapshot>;
}

declare class AchievementService {
    private achievements;
    private repository;
    private config;
    private clock;
    constructor(config: AchievementServiceConfig);
    getSnapshot(subjectId: AchievementSubjectId): Promise<AchievementApiSnapshot>;
    track(subjectId: AchievementSubjectId, input: TrackAchievementInput | TrackManyAchievementsInput): Promise<AchievementMutationResult>;
    increment(subjectId: AchievementSubjectId, input: IncrementAchievementInput): Promise<AchievementMutationResult>;
    event(subjectId: AchievementSubjectId, input: AchievementEventInput): Promise<AchievementMutationResult>;
    reset(subjectId: AchievementSubjectId): Promise<AchievementApiSnapshot>;
    private mutate;
    private applyMetricUpdate;
    private evaluate;
    private toSnapshot;
    private getAchievementConditions;
    private toDto;
}

declare class MemoryAchievementRepository implements AchievementRepository {
    private states;
    getState(subjectId: AchievementSubjectId): Promise<StoredAchievementState | undefined>;
    saveState(subjectId: AchievementSubjectId, state: StoredAchievementState): Promise<void>;
    clearState(subjectId: AchievementSubjectId): Promise<void>;
    withTransaction<T>(_subjectId: AchievementSubjectId, run: () => Promise<T>): Promise<T>;
}

interface AchievementFetchHandlerOptions {
    service: AchievementService;
    getSubjectId: (request: Request) => AchievementSubjectId | Promise<AchievementSubjectId>;
    basePath?: string;
}
declare const createAchievementFetchHandler: ({ service, getSubjectId, basePath, }: AchievementFetchHandlerOptions) => (request: Request) => Promise<Response>;

export { AchievementApiSnapshot, AchievementClient, AchievementDto, AchievementEventInput, AchievementFetchHandlerOptions, AchievementMutationResult, AchievementProgress, AchievementRepository, AchievementService, AchievementServiceConfig, AchievementSubjectId, IncrementAchievementInput, MemoryAchievementRepository, StoredAchievementState, TrackAchievementInput, TrackManyAchievementsInput, createAchievementFetchHandler };