import React from 'react';
import * as achievements_engine from 'achievements-engine';
import { AchievementSnapshot, ImportOptions, ImportResult, AchievementEngine, AchievementStorage as AchievementStorage$1, AsyncAchievementStorage as AsyncAchievementStorage$1, StorageType, RestApiStorageConfig, EventMapping, AchievementError } from 'achievements-engine';
export { AchievementBuilder, AchievementEngine, AchievementEngineApi, AchievementError, AchievementSnapshot, AchievementUnlockedEvent, AchievementUpdateResult, AsyncStorageAdapter, AwardDetails, ConfigurationError, EngineConfig, EngineEvent, ErrorEvent, EventMapping, ExportedData, ImportOptions, ImportResult, ImportValidationError, IndexedDBStorage, LocalStorage, MemoryStorage, MetricUpdatedEvent, MetricUpdater, OfflineQueueStorage, RestApiStorage, RestApiStorageConfig, StateChangedEvent, StorageError, StorageQuotaError, StorageType, SyncError, UnsubscribeFn, createConfigHash, exportAchievementData, importAchievementData, isAchievementError, isRecoverableError, isSimpleConfig, normalizeAchievements } from 'achievements-engine';

type ConfettiShape = 'square' | 'circle' | 'star';
interface ConfettiOptions {
    /**
     * Duration in milliseconds before the built-in confetti marker is removed.
     * Custom confetti components receive this value through `duration`.
     */
    duration?: number;
    particleCount?: number;
    colors?: string[];
    shapes?: ConfettiShape[];
    spread?: number;
    startVelocity?: number;
    gravity?: number;
    scalar?: number;
    zIndex?: number;
}

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;
}
type AchievementConfetti = false | ConfettiOptions;
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 AchievementConfigurationType = AchievementConfiguration | SimpleAchievementConfig;
interface InitialAchievementMetrics {
    [key: string]: AchievementMetricValue;
}
interface AchievementState {
    metrics: AchievementMetrics;
    unlockedAchievements: string[];
}
interface AchievementStorage {
    getMetrics(): AchievementMetrics;
    setMetrics(metrics: AchievementMetrics): void;
    getUnlockedAchievements(): string[];
    setUnlockedAchievements(achievements: string[]): void;
    clear(): void;
}
interface AsyncAchievementStorage {
    getMetrics(): Promise<AchievementMetrics>;
    setMetrics(metrics: AchievementMetrics): Promise<void>;
    getUnlockedAchievements(): Promise<string[]>;
    setUnlockedAchievements(achievements: string[]): Promise<void>;
    clear(): Promise<void>;
}
type AnyAchievementStorage = AchievementStorage | AsyncAchievementStorage;
declare function isAsyncStorage(storage: AnyAchievementStorage): storage is AsyncAchievementStorage;
/**
 * @deprecated This type is outdated and will be removed in 5.0.
 * Use AchievementContextType from 'react-achievements' instead.
 *
 * This legacy interface does not include the 'engine' property.
 *
 * @example
 * ```typescript
 * // Old (deprecated)
 * import { AchievementContextValue } from 'react-achievements';
 *
 * // New (recommended)
 * import { AchievementContextType } from 'react-achievements';
 * ```
 */
interface AchievementContextValue {
    updateMetrics: (metrics: AchievementMetrics | ((prev: AchievementMetrics) => AchievementMetrics)) => void;
    unlockedAchievements: string[];
    resetStorage: () => void;
}

interface AchievementContextType {
    update: (metrics: Record<string, any>) => void;
    achievements: {
        unlocked: string[];
        all: Record<string, AchievementWithStatus>;
    };
    snapshot: AchievementSnapshot;
    reset: () => void;
    getState: () => {
        metrics: Record<string, any>;
        unlocked: string[];
    };
    exportData: () => string;
    importData: (jsonString: string, options?: ImportOptions) => ImportResult;
    getAllAchievements: () => AchievementWithStatus[];
    engine: AchievementEngine;
    icons: Record<string, string>;
    /**
     * @deprecated Use provider props or the presence of an injected engine directly.
     * This compatibility flag will be removed in 5.0.
     */
    _isLegacyPattern: boolean;
}
declare const AchievementContext: React.Context<AchievementContextType | undefined>;
interface AchievementProviderProps {
    achievements?: AchievementConfigurationType;
    storage?: AchievementStorage$1 | AsyncAchievementStorage$1 | StorageType;
    restApiConfig?: RestApiStorageConfig;
    eventMapping?: EventMapping;
    engine?: AchievementEngine;
    children: React.ReactNode;
    icons?: Record<string, string>;
    onError?: (error: AchievementError) => void;
    /**
     * @deprecated Built-in UI is the default in the web provider. This prop is a
     * no-op and will be removed in 5.0.
     */
    useBuiltInUI?: boolean;
}
declare const AchievementProvider: React.FC<AchievementProviderProps>;

declare const useAchievements: () => AchievementContextType;

/**
 * A simplified hook for achievement tracking.
 * Provides the v4 happy path for direct metric updates plus explicit state names.
 */
declare const useSimpleAchievements: () => {
    track: (metric: string, value: any) => void;
    increment: (metric: string, amount?: number) => achievements_engine.AchievementUpdateResult;
    trackMultiple: (metrics: Record<string, any>) => void;
    unlockedIds: string[];
    unlockedAchievements: achievements_engine.AchievementWithStatus[];
    allAchievements: achievements_engine.AchievementWithStatus[];
    unlockedCount: number;
    totalCount: number;
    metrics: achievements_engine.AchievementMetrics;
    reset: () => void;
    getState: () => {
        metrics: Record<string, any>;
        unlocked: string[];
    };
    exportData: () => string;
    importData: (jsonString: string, options?: achievements_engine.ImportOptions) => achievements_engine.ImportResult;
    getAllAchievements: () => achievements_engine.AchievementWithStatus[];
    /**
     * @deprecated Use `unlockedIds` instead. This alias will be removed in 5.0.
     */
    unlocked: string[];
    /**
     * @deprecated Use `allAchievements` instead. This alias will be removed in 5.0.
     */
    all: achievements_engine.AchievementWithStatus[];
};

declare const useAchievementState: () => {
    unlockedIds: string[];
    unlockedAchievements: achievements_engine.AchievementWithStatus[];
    allAchievements: achievements_engine.AchievementWithStatus[];
    unlockedCount: number;
    totalCount: number;
    metrics: achievements_engine.AchievementMetrics;
};

/**
 * Access the active AchievementEngine instance.
 *
 * In v4 this works with both provider-created engines (`achievements` prop) and
 * injected engines (`engine` prop).
 */
declare const useAchievementEngine: () => AchievementEngine;

export { AchievementCondition, AchievementConfetti, AchievementConfiguration, AchievementConfigurationType, AchievementContext, AchievementContextType, AchievementContextValue, AchievementDetails, AchievementMetricArrayValue, AchievementMetricValue, AchievementMetrics, AchievementProvider, AchievementProviderProps, AchievementState, AchievementStorage, AchievementWithStatus, AnyAchievementStorage, AsyncAchievementStorage, CustomAchievementDetails, InitialAchievementMetrics, SimpleAchievementConfig, SimpleAchievementDetails, isAsyncStorage, useAchievementEngine, useAchievementState, useAchievements, useSimpleAchievements };