import { Model, DataTypes, type Sequelize } from 'sequelize';
import { LRUCache } from 'lru-cache';
import IORedis, { type Redis } from 'ioredis';
import type { KythiaConfig } from '../types/KythiaConfig';
import type { CacheStats, KythiaModelDependencies, CacheEntry, KythiaModelStructure } from '../types/KythiaModel';
import type { KythiaLogger } from '@src/types';
import type { MetricsManager } from '@src/managers/MetricsManager';
export declare class KythiaModel<T extends object = Record<string, unknown>, TCreationAttributes extends object = T> extends Model<T, TCreationAttributes> {
    static client: import('discord.js').Client;
    static redis: Redis | undefined;
    static isRedisConnected: boolean;
    static logger: KythiaLogger;
    static config: KythiaConfig | {};
    static metrics: MetricsManager | undefined;
    static CACHE_VERSION: string;
    static localCache: LRUCache<string, {
        data: unknown;
        expires: number;
    }, unknown>;
    static MAX_LOCAL_CACHE_SIZE: number;
    static DEFAULT_TTL: number;
    static NEGATIVE_CACHE_TTL?: number;
    static DRIFT_CHECK_ENABLED: boolean;
    static DRIFT_CHECK_RATE: number;
    static driftStats: {
        checked: number;
        drifted: number;
        healed: number;
        errors: number;
    };
    static lastRedisOpts: string[] | null;
    static reconnectTimeout: NodeJS.Timeout | null;
    static lastAutoReconnectTs: number;
    static pendingQueries: Map<string, Promise<unknown>>;
    static cacheStats: CacheStats;
    static redisErrorTimestamps: number[];
    static isShardMode: boolean;
    static isShuttingDown: boolean;
    static _redisFallbackURLs: string[];
    static _redisCurrentIndex: number;
    static _redisFailedIndexes: Set<number>;
    static _justFailedOver: boolean;
    static fillable?: string[];
    static guarded?: string[];
    static structure?: KythiaModelStructure;
    static table?: string;
    static cacheKeys?: (string | string[])[];
    static CACHE_KEYS?: string[];
    static CACHE_TTL?: number;
    static customInvalidationTags?: string[];
    static useRedis: boolean;
    static init(attributes: import('sequelize').ModelAttributes<Model, Record<string, unknown>>, options: import('sequelize').InitOptions<Model>): unknown;
    static hasOne(target: import('sequelize').ModelStatic<import('sequelize').Model>, options?: import('sequelize').HasOneOptions): import('sequelize').HasOne;
    static belongsTo(target: import('sequelize').ModelStatic<import('sequelize').Model>, options?: import('sequelize').BelongsToOptions): import('sequelize').BelongsTo;
    static hasMany(target: import('sequelize').ModelStatic<import('sequelize').Model>, options?: import('sequelize').HasManyOptions): import('sequelize').HasMany;
    static belongsToMany(target: import('sequelize').ModelStatic<import('sequelize').Model>, options?: import('sequelize').BelongsToManyOptions): import('sequelize').BelongsToMany;
    static autoBoot(sequelize: Sequelize): Promise<typeof KythiaModel | undefined>;
    static _mapDbTypeToSequelize(dbType: string): DataTypes.AbstractDataTypeConstructor;
    static _setupLaravelHooks(): void;
    static setDependencies({ logger, config, redis, redisOptions, }: KythiaModelDependencies): void;
    static _trackRedisError(err: unknown): void;
    static _tryRedisFailover(): boolean;
    static _closeCurrentRedis(): void;
    static initializeRedis(redisOptions?: Record<string, unknown>): IORedis | null;
    static _makeRetryStrategy(): (times: number) => number | null;
    static _setupRedisEventHandlers(): void;
    static _scheduleReconnect(): void;
    static getCacheKey(queryIdentifier: unknown): string;
    static normalizeQueryOptions(data: unknown): unknown;
    static _generateSmartTags(instance: import('sequelize').Model): string[];
    static setCacheEntry(cacheKeyOrQuery: unknown, data: unknown, ttl?: number, tags?: string[]): Promise<void>;
    static getCachedEntry(cacheKeyOrQuery: unknown, includeOptions?: unknown): Promise<CacheEntry>;
    static clearCache(keys: unknown): Promise<void>;
    static _redisSetCacheEntry(cacheKey: string, data: unknown, ttl: number, tags?: string[]): Promise<void>;
    static _redisGetCachedEntry(cacheKey: string, includeOptions: unknown): Promise<CacheEntry>;
    static _redisClearCache(cacheKey: string): Promise<void>;
    static invalidateByTags(tags: string[]): Promise<void>;
    static _mapSetCacheEntry(cacheKey: string, data: unknown, ttl: number): void;
    static _mapGetCachedEntry(cacheKey: string, includeOptions: unknown): CacheEntry;
    static _mapClearCache(cacheKey: string): void;
    static _mapClearAllModelCache(): void;
    static _performDriftCheck(cacheKey: string, cachedData: unknown, query: unknown, ttl?: number): Promise<void>;
    static getCacheDriftStats(): {
        rate: number;
        enabled: boolean;
        checked: number;
        drifted: number;
        healed: number;
        errors: number;
    };
    static getGlobalCacheStats(sequelizeModels?: Record<string, unknown>): CacheStats;
    static _normalizeFindOptions(options: unknown): unknown;
    static getCache(keys: unknown, options?: unknown): Promise<unknown>;
    static getAllCache(options?: unknown): Promise<unknown>;
    static scheduleAdd(keySuffix: string, score: number, value: string): Promise<void>;
    static scheduleRemove(keySuffix: string, value: string): Promise<void>;
    static scheduleGetExpired(keySuffix: string, scoreLimit?: number): Promise<string[]>;
    static scheduleClear(keySuffix: string): Promise<void>;
    static findOrCreateCache(options: unknown): Promise<unknown>;
    static getOrCreateCache(where: unknown, defaults?: unknown, options?: unknown): Promise<[import('sequelize').Model, boolean]>;
    static firstOrCreateCache(where: unknown, defaults?: unknown, options?: unknown): Promise<[import('sequelize').Model, boolean]>;
    static firstOrNewCache(where: unknown, defaults?: unknown, options?: unknown): Promise<[import('sequelize').Model, boolean]>;
    static firstOrUpdateCache(where: unknown, values?: unknown, options?: unknown): Promise<[import('sequelize').Model, boolean]>;
    static updateOrCreateCache(where: unknown, values?: unknown, options?: unknown): Promise<[import('sequelize').Model, boolean]>;
    static countCache(options?: unknown, ttlParam?: number): Promise<unknown>;
    static clearNegativeCache(keys: unknown): Promise<void>;
    static aggregateCache(options?: unknown, cacheOptions?: unknown): Promise<unknown>;
    static refreshCache(keys: unknown, options?: unknown): Promise<KythiaModel<object, object> | null>;
    static existsCache(where: unknown, options?: unknown): Promise<boolean>;
    static bulkGetCache(ids: unknown[], options?: unknown): Promise<import('sequelize').Model[]>;
    static destroyAndClearCache(options: unknown): Promise<number>;
    static incrementCache(where: unknown, field: string, amount?: number): Promise<void>;
    static paginateCache(options?: unknown): Promise<{
        rows: unknown[];
        count: number;
        totalPages: number;
        currentPage: number;
    }>;
    static initializeCacheHooks(): void;
    static attachHooksToAllModels(sequelizeInstance: Sequelize, client: unknown): void;
    static touchParent(childInstance: unknown, foreignKeyField: string, ParentModel: typeof KythiaModel, timestampField?: string): Promise<void>;
    static setupParentTouch(foreignKeyField: string, ParentModel: typeof KythiaModel, timestampField?: string): void;
}
export default KythiaModel;
//# sourceMappingURL=KythiaModel.d.ts.map