@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/systems/NiceEquipment.d.ts

@@ -0,0 +1,137 @@
+import { EventEmitter } from 'events';
+export type EquipmentId = string;
+export type SlotId = string;
+export type StatId = string;
+export type EnchantmentId = string;
+export type SetId = string;
+export type GemId = string;
+export type CharacterId = string;
+export interface SlotDefinition {
+    id: SlotId;
+    name: string;
+    allowedTypes: string[];
+    required?: boolean;
+}
+export interface EquipmentItem {
+    id: EquipmentId;
+    name: string;
+    type: string;
+    rarity: EquipmentRarity;
+    level: number;
+    stats: Record<StatId, number>;
+    requirements?: EquipmentRequirements;
+    setId?: SetId;
+    sockets?: Socket[];
+    enchantments?: Enchantment[];
+    durability?: number;
+    maxDurability?: number;
+    description?: string;
+    icon?: string;
+}
+export type EquipmentRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic';
+export interface EquipmentRequirements {
+    level?: number;
+    stats?: Record<StatId, number>;
+    class?: string[];
+    quest?: string;
+}
+export interface Socket {
+    type: string;
+    gemId?: GemId;
+}
+export interface Enchantment {
+    id: EnchantmentId;
+    name: string;
+    level: number;
+    stats: Record<StatId, number>;
+}
+export interface EquipmentSet {
+    id: SetId;
+    name: string;
+    pieces: EquipmentId[];
+    bonuses: SetBonus[];
+}
+export interface SetBonus {
+    piecesRequired: number;
+    stats: Record<StatId, number>;
+    ability?: string;
+    description: string;
+}
+export interface Gem {
+    id: GemId;
+    name: string;
+    type: string;
+    stats: Record<StatId, number>;
+    rarity: EquipmentRarity;
+}
+export interface CharacterEquipment {
+    characterId: CharacterId;
+    slots: Map<SlotId, EquipmentId | null>;
+    activeSetBonuses: Map<SetId, number[]>;
+}
+export interface StatSummary {
+    base: Record<StatId, number>;
+    fromEquipment: Record<StatId, number>;
+    fromEnchantments: Record<StatId, number>;
+    fromGems: Record<StatId, number>;
+    fromSetBonuses: Record<StatId, number>;
+    total: Record<StatId, number>;
+}
+export type EquipmentEventType = 'item-equipped' | 'item-unequipped' | 'item-swapped' | 'gem-socketed' | 'gem-removed' | 'enchantment-added' | 'enchantment-removed' | 'set-bonus-activated' | 'set-bonus-deactivated' | 'durability-changed';
+export interface EquipmentEvent {
+    type: EquipmentEventType;
+    characterId: CharacterId;
+    slotId?: SlotId;
+    itemId?: EquipmentId;
+    setId?: SetId;
+    bonusLevel?: number;
+}
+export interface EquipmentConfig {
+    defaultSlots?: SlotDefinition[];
+    enableDurability?: boolean;
+    enableEnchantments?: boolean;
+    enableSockets?: boolean;
+}
+export declare const DEFAULT_EQUIPMENT_CONFIG: EquipmentConfig;
+export declare class NiceEquipment extends EventEmitter {
+    private slots;
+    private items;
+    private sets;
+    private gems;
+    private characters;
+    private config;
+    constructor(config?: Partial<EquipmentConfig>);
+    registerSlot(slot: SlotDefinition): void;
+    unregisterSlot(slotId: SlotId): boolean;
+    getSlot(slotId: SlotId): SlotDefinition | undefined;
+    getAllSlots(): SlotDefinition[];
+    registerItem(item: EquipmentItem): void;
+    unregisterItem(itemId: EquipmentId): boolean;
+    getItem(itemId: EquipmentId): EquipmentItem | undefined;
+    registerSet(set: EquipmentSet): void;
+    unregisterSet(setId: SetId): boolean;
+    getSet(setId: SetId): EquipmentSet | undefined;
+    registerGem(gem: Gem): void;
+    unregisterGem(gemId: GemId): boolean;
+    getGem(gemId: GemId): Gem | undefined;
+    registerCharacter(characterId: CharacterId): void;
+    unregisterCharacter(characterId: CharacterId): boolean;
+    equip(characterId: CharacterId, slotId: SlotId, itemId: EquipmentId): boolean;
+    unequip(characterId: CharacterId, slotId: SlotId): EquipmentId | null;
+    swap(characterId: CharacterId, slotId1: SlotId, slotId2: SlotId): boolean;
+    socketGem(itemId: EquipmentId, socketIndex: number, gemId: GemId): boolean;
+    removeGem(itemId: EquipmentId, socketIndex: number): GemId | null;
+    addEnchantment(itemId: EquipmentId, enchantment: Enchantment): boolean;
+    removeEnchantment(itemId: EquipmentId, enchantmentId: EnchantmentId): boolean;
+    private updateSetBonuses;
+    getSetBonuses(characterId: CharacterId): Map<SetId, SetBonus[]>;
+    calculateStats(characterId: CharacterId, baseStats?: Record<StatId, number>): StatSummary;
+    compare(characterId: CharacterId, slotId: SlotId, newItemId: EquipmentId): Record<StatId, number>;
+    getEquipped(characterId: CharacterId, slotId: SlotId): EquipmentItem | null;
+    getAllEquipped(characterId: CharacterId): Map<SlotId, EquipmentItem>;
+    isSlotEmpty(characterId: CharacterId, slotId: SlotId): boolean;
+}
+export declare function createEquipmentSystem(config?: Partial<EquipmentConfig>): NiceEquipment;
+export declare function defineEquipmentItem(id: EquipmentId, name: string, type: string, stats: Record<StatId, number>, options?: Partial<Omit<EquipmentItem, 'id' | 'name' | 'type' | 'stats'>>): EquipmentItem;
+export declare function defineEquipmentSet(id: SetId, name: string, pieces: EquipmentId[], bonuses: SetBonus[]): EquipmentSet;
+export default NiceEquipment;

package/dist/types/systems/NiceEvent.d.ts

@@ -0,0 +1,202 @@
+export type EventId = string;
+export type ObjectiveId = string;
+export type EventRewardId = string;
+export type EventType = 'limited-time' | 'seasonal' | 'collaboration' | 'anniversary' | 'boss-rush' | 'ranking' | 'login-campaign' | 'raid' | 'pvp-season' | 'festival' | 'custom';
+export type EventStatus = 'upcoming' | 'active' | 'ending-soon' | 'ended' | 'archived';
+export type ObjectiveStatus = 'locked' | 'available' | 'in-progress' | 'completed' | 'claimed';
+export interface EventDefinition {
+    id: EventId;
+    name: string;
+    description: string;
+    type: EventType;
+    startDate: number;
+    endDate: number;
+    gracePeriod?: number;
+    recurring?: boolean;
+    recurringPattern?: 'daily' | 'weekly' | 'monthly' | 'yearly';
+    objectives: EventObjective[];
+    milestones: EventMilestone[];
+    shop?: EventShop;
+    stages?: EventStage[];
+    eventCurrency?: {
+        id: string;
+        name: string;
+        icon: string;
+        maxAmount?: number;
+    };
+    levelRequired?: number;
+    prerequisiteEventId?: EventId;
+    bannerUrl?: string;
+    bgColor?: string;
+    theme?: string;
+    hasLeaderboard: boolean;
+    hasGlobalProgress: boolean;
+    rewardsAfterEnd: boolean;
+}
+export interface EventObjective {
+    id: ObjectiveId;
+    name: string;
+    description: string;
+    targetType: 'count' | 'collect' | 'defeat' | 'score' | 'reach' | 'custom';
+    targetId?: string;
+    targetAmount: number;
+    prerequisiteObjectiveId?: ObjectiveId;
+    availableFrom?: number;
+    availableUntil?: number;
+    rewards: EventReward[];
+    pointsAwarded?: number;
+    countMethod?: 'cumulative' | 'single-session' | 'daily';
+    isRepeatable?: boolean;
+    maxCompletions?: number;
+}
+export interface EventReward {
+    id: EventRewardId;
+    type: 'item' | 'currency' | 'event_currency' | 'title' | 'cosmetic' | 'buff';
+    itemId?: string;
+    currency?: string;
+    amount: number;
+    rarity?: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+}
+export interface EventMilestone {
+    id: string;
+    name: string;
+    pointsRequired: number;
+    rewards: EventReward[];
+    isGlobal?: boolean;
+}
+export interface EventStage {
+    id: string;
+    name: string;
+    description: string;
+    order: number;
+    unlockCondition: 'date' | 'previous-stage' | 'points' | 'objective';
+    unlockValue?: number | string;
+    unlockDate?: number;
+    content: {
+        type: 'boss' | 'dungeon' | 'quest-chain' | 'challenge' | 'custom';
+        contentId: string;
+        difficulty?: number;
+    };
+    firstClearRewards?: EventReward[];
+    repeatRewards?: EventReward[];
+}
+export interface EventShopItem {
+    id: string;
+    itemId: string;
+    name: string;
+    description: string;
+    currencyType: 'event' | 'premium' | 'standard';
+    currencyId: string;
+    cost: number;
+    stock: number;
+    maxPurchasePerPlayer?: number;
+    availableFrom?: number;
+    availableUntil?: number;
+    featured?: boolean;
+    sortOrder: number;
+}
+export interface EventShop {
+    items: EventShopItem[];
+    refreshTime?: number;
+    exchangeRates?: Array<{
+        fromCurrency: string;
+        toCurrency: string;
+        rate: number;
+    }>;
+}
+export interface EventPlayerProgress {
+    playerId: string;
+    eventId: EventId;
+    totalPoints: number;
+    objectiveProgress: Map<ObjectiveId, ObjectiveProgress>;
+    claimedMilestones: string[];
+    completedStages: string[];
+    stageAttempts: Map<string, number>;
+    purchases: Map<string, number>;
+    eventCurrency: number;
+    firstParticipation: number;
+    lastParticipation: number;
+    score?: number;
+    rank?: number;
+}
+export interface ObjectiveProgress {
+    objectiveId: ObjectiveId;
+    status: ObjectiveStatus;
+    currentAmount: number;
+    completions: number;
+    completedAt?: number;
+    claimedAt?: number;
+}
+export interface LeaderboardEntry {
+    playerId: string;
+    playerName: string;
+    score: number;
+    rank: number;
+    change?: number;
+    rewards?: EventReward[];
+}
+export type EventEventType = 'event-started' | 'event-ending-soon' | 'event-ended' | 'objective-progress' | 'objective-completed' | 'reward-claimed' | 'milestone-reached' | 'stage-completed' | 'shop-purchase' | 'currency-earned' | 'rank-updated' | 'global-progress-updated';
+export interface EventSystemEvent {
+    type: EventEventType;
+    timestamp: number;
+    eventId: EventId;
+    playerId?: string;
+    data?: unknown;
+}
+export type EventSystemCallback = (event: EventSystemEvent) => void;
+export interface EventConfig {
+    endingSoonThreshold: number;
+    maxActiveEvents: number;
+    archiveAfterDays: number;
+    storageKey: string;
+}
+export declare const DEFAULT_EVENT_CONFIG: EventConfig;
+export declare class NiceEvent {
+    private config;
+    private events;
+    private playerProgress;
+    private globalProgress;
+    private leaderboards;
+    private eventListeners;
+    private updateInterval?;
+    constructor(config?: Partial<EventConfig>);
+    on(event: EventEventType, callback: EventSystemCallback): () => void;
+    private emit;
+    private startUpdateLoop;
+    private checkEventStatuses;
+    registerEvent(event: EventDefinition): void;
+    getEventStatus(eventId: EventId): EventStatus;
+    getActiveEvents(): EventDefinition[];
+    getUpcomingEvents(): EventDefinition[];
+    private getOrCreateProgress;
+    getPlayerProgress(playerId: string, eventId: EventId): EventPlayerProgress | undefined;
+    updateObjectiveProgress(playerId: string, eventId: EventId, objectiveId: ObjectiveId, amount: number): ObjectiveProgress | null;
+    private completeObjective;
+    private unlockDependentObjectives;
+    claimObjectiveRewards(playerId: string, eventId: EventId, objectiveId: ObjectiveId): EventReward[] | null;
+    private checkMilestones;
+    claimMilestone(playerId: string, eventId: EventId, milestoneId: string): EventReward[] | null;
+    canAttemptStage(playerId: string, eventId: EventId, stageId: string): boolean;
+    completeStage(playerId: string, eventId: EventId, stageId: string, score?: number): EventReward[];
+    canPurchase(playerId: string, eventId: EventId, itemId: string): {
+        can: boolean;
+        reason?: string;
+    };
+    purchaseItem(playerId: string, eventId: EventId, itemId: string): boolean;
+    private updateGlobalProgress;
+    private updateLeaderboard;
+    getLeaderboard(eventId: EventId, limit?: number): LeaderboardEntry[];
+    getPlayerRank(playerId: string, eventId: EventId): LeaderboardEntry | undefined;
+    getEvent(eventId: EventId): EventDefinition | undefined;
+    getAllEvents(): EventDefinition[];
+    getGlobalProgress(eventId: EventId): {
+        totalPoints: number;
+        participants: number;
+    } | undefined;
+    getAvailableObjectives(playerId: string, eventId: EventId): EventObjective[];
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createEventSystem(config?: Partial<EventConfig>): NiceEvent;

package/dist/types/systems/NiceEventBus.d.ts

@@ -0,0 +1,164 @@
+export type EventName = string;
+export type EventCallback<T = unknown> = (data: T, event: GameEvent<T>) => void;
+export interface GameEvent<T = unknown> {
+    name: EventName;
+    data: T;
+    timestamp: number;
+    source?: string;
+    cancelled: boolean;
+    propagationStopped: boolean;
+}
+export interface EventListener<T = unknown> {
+    id: string;
+    eventName: EventName;
+    callback: EventCallback<T>;
+    priority: number;
+    once: boolean;
+    context?: unknown;
+    filter?: (data: T) => boolean;
+}
+export interface QueuedEvent<T = unknown> {
+    name: EventName;
+    data: T;
+    source?: string;
+    delay: number;
+    timestamp: number;
+}
+export interface EventStats {
+    eventName: EventName;
+    emitCount: number;
+    listenerCount: number;
+    lastEmit: number;
+    avgProcessTime: number;
+    totalProcessTime: number;
+}
+export interface EventBusConfig {
+    /** Enable event history */
+    trackHistory: boolean;
+    /** Max history entries */
+    maxHistory: number;
+    /** Enable statistics */
+    trackStats: boolean;
+    /** Allow wildcards */
+    allowWildcards: boolean;
+    /** Log events */
+    debug: boolean;
+    /** Max listeners per event (0 = unlimited) */
+    maxListeners: number;
+}
+export declare const DEFAULT_EVENT_CONFIG: EventBusConfig;
+export declare class NiceEvent {
+    private config;
+    private listeners;
+    private wildcardListeners;
+    private queue;
+    private history;
+    private stats;
+    private listenerIdCounter;
+    private processing;
+    constructor(config?: Partial<EventBusConfig>);
+    on<T = unknown>(eventName: EventName, callback: EventCallback<T>, options?: {
+        priority?: number;
+        once?: boolean;
+        context?: unknown;
+        filter?: (data: T) => boolean;
+    }): () => void;
+    once<T = unknown>(eventName: EventName, callback: EventCallback<T>, options?: {
+        priority?: number;
+        context?: unknown;
+    }): () => void;
+    off(listenerId: string): boolean;
+    off(eventName: EventName, callback?: EventCallback): boolean;
+    private removeListenerById;
+    private sortByPriority;
+    emit<T = unknown>(eventName: EventName, data: T, source?: string): GameEvent<T>;
+    private getMatchingWildcards;
+    /**Queue event for delayed emission */
+    queueEvent<T = unknown>(eventName: EventName, data: T, delay: number, source?: string): void;
+    /** Process queued events */
+    processQueue(): void;
+    clearQueue(): void;
+    getQueueLength(): number;
+    has(eventName: EventName): boolean;
+    listenerCount(eventName?: EventName): number;
+    eventNames(): EventName[];
+    getHistory(filter?: {
+        eventName?: EventName;
+        since?: number;
+    }): GameEvent[];
+    clearHistory(): void;
+    private updateStats;
+    getStats(eventName?: EventName): EventStats | EventStats[] | undefined;
+    clearStats(): void;
+    removeAllListeners(eventName?: EventName): void;
+    destroy(): void;
+}
+export declare function createEventBus(config?: Partial<EventBusConfig>): NiceEvent;
+export interface TypedEventMap {
+    [key: string]: any;
+}
+export declare class TypedEventBus<T extends TypedEventMap> extends NiceEvent {
+    emit<K extends keyof T & string>(eventName: K, data: T[K], source?: string): GameEvent<T[K]>;
+    on<K extends keyof T & string>(eventName: K, callback: EventCallback<T[K]>, options?: {
+        priority?: number;
+        once?: boolean;
+        context?: unknown;
+    }): () => void;
+    once<K extends keyof T & string>(eventName: K, callback: EventCallback<T[K]>, options?: {
+        priority?: number;
+        context?: unknown;
+    }): () => void;
+}
+export interface CommonGameEvents {
+    'game:start': void;
+    'game:pause': void;
+    'game:resume': void;
+    'game:stop': void;
+    'game:save': {
+        slotId: string;
+    };
+    'game:load': {
+        slotId: string;
+    };
+    'scene:load': {
+        sceneId: string;
+    };
+    'scene:unload': {
+        sceneId: string;
+    };
+    'scene:ready': {
+        sceneId: string;
+    };
+    'entity:spawn': {
+        entityId: string;
+        type: string;
+    };
+    'entity:destroy': {
+        entityId: string;
+    };
+    'player:spawn': {
+        playerId: string;
+    };
+    'player:death': {
+        playerId: string;
+        killer?: string;
+    };
+    'player:respawn': {
+        playerId: string;
+    };
+    'input:action': {
+        action: string;
+        pressed: boolean;
+    };
+    'network:connect': void;
+    'network:disconnect': {
+        reason: string;
+    };
+    'ui:open': {
+        panelId: string;
+    };
+    'ui:close': {
+        panelId: string;
+    };
+}
+export declare function createGameEventBus(): TypedEventBus<CommonGameEvents>;

package/dist/types/systems/NiceFaction.d.ts

@@ -0,0 +1,173 @@
+export type FactionId = string;
+export type ReputationTier = 'hostile' | 'unfriendly' | 'neutral' | 'friendly' | 'honored' | 'revered' | 'exalted';
+export interface FactionDefinition {
+    id: FactionId;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    /** Starting reputation with player */
+    baseReputation: number;
+    /** Can reputation go negative */
+    allowNegative: boolean;
+    /** Is this a major/primary faction */
+    isMajor: boolean;
+    /** Parent faction (for sub-factions) */
+    parentFaction?: FactionId;
+    /** Reputation decay per day (if any) */
+    reputationDecay?: number;
+    /** Max reputation */
+    maxReputation: number;
+    /** Min reputation */
+    minReputation: number;
+    /** Custom data */
+    customData?: Record<string, unknown>;
+}
+export interface FactionRelationship {
+    factionA: FactionId;
+    factionB: FactionId;
+    /** Relationship value (-1 to 1) */
+    relationship: number;
+    /** Does A/B actions affect reputation with other */
+    propagateReputation: boolean;
+    /** Propagation factor (0-1) */
+    propagationFactor: number;
+}
+export interface ReputationTierDefinition {
+    tier: ReputationTier;
+    name: string;
+    minReputation: number;
+    maxReputation: number;
+    color: string;
+    benefits: string[];
+    restrictions: string[];
+}
+export interface FactionState {
+    factionId: FactionId;
+    reputation: number;
+    tier: ReputationTier;
+    totalGained: number;
+    totalLost: number;
+    lastInteraction: number;
+    isKnown: boolean;
+    flags: Set<string>;
+}
+export interface ReputationModifier {
+    id: string;
+    factionId: FactionId;
+    amount: number;
+    /** Multiplicative modifier */
+    multiplier?: number;
+    /** Duration in ms (0 = permanent) */
+    duration: number;
+    /** When applied */
+    appliedAt: number;
+    /** Reason/source */
+    source: string;
+}
+export interface ReputationGain {
+    factionId: FactionId;
+    amount: number;
+    source: string;
+    /** Affected by modifiers */
+    applyModifiers: boolean;
+}
+export interface FactionReward {
+    id: string;
+    factionId: FactionId;
+    requiredTier: ReputationTier;
+    requiredReputation?: number;
+    name: string;
+    description: string;
+    type: 'item' | 'ability' | 'discount' | 'access' | 'title' | 'custom';
+    data: unknown;
+    oneTime: boolean;
+    claimed: boolean;
+}
+export type DiplomaticStatus = 'war' | 'hostile' | 'cold' | 'neutral' | 'friendly' | 'allied';
+export interface DiplomaticState {
+    factionA: FactionId;
+    factionB: FactionId;
+    status: DiplomaticStatus;
+    since: number;
+    treatyEndDate?: number;
+}
+export type FactionEventType = 'reputation-changed' | 'tier-changed' | 'faction-discovered' | 'reward-unlocked' | 'reward-claimed' | 'modifier-applied' | 'modifier-expired' | 'diplomacy-changed' | 'war-declared' | 'peace-declared';
+export interface FactionEvent {
+    type: FactionEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type FactionEventCallback = (event: FactionEvent) => void;
+export interface FactionSystemConfig {
+    /** Default reputation tiers */
+    tiers: ReputationTierDefinition[];
+    /** Update interval for decay/modifiers (ms) */
+    updateInterval: number;
+    /** Enable reputation decay */
+    enableDecay: boolean;
+    /** Auto-save */
+    autoSave: boolean;
+    /** Storage key */
+    storageKey: string;
+}
+export declare const DEFAULT_REPUTATION_TIERS: ReputationTierDefinition[];
+export declare const DEFAULT_FACTION_CONFIG: FactionSystemConfig;
+export declare class NiceFaction {
+    private config;
+    private factions;
+    private factionStates;
+    private relationships;
+    private diplomacy;
+    private modifiers;
+    private rewards;
+    private eventListeners;
+    private updateTimer;
+    constructor(config?: Partial<FactionSystemConfig>);
+    on(event: FactionEventType, callback: FactionEventCallback): () => void;
+    private emit;
+    registerFaction(faction: FactionDefinition): void;
+    registerFactions(factions: FactionDefinition[]): void;
+    getFaction(id: FactionId): FactionDefinition | undefined;
+    getFactionState(id: FactionId): FactionState | undefined;
+    getAllFactions(): FactionDefinition[];
+    getKnownFactions(): FactionDefinition[];
+    setRelationship(factionA: FactionId, factionB: FactionId, relationship: number, propagate?: boolean, propagationFactor?: number): void;
+    getRelationship(factionA: FactionId, factionB: FactionId): FactionRelationship | undefined;
+    private getRelationshipKey;
+    getReputation(factionId: FactionId): number;
+    getTier(factionId: FactionId): ReputationTier;
+    getTierForReputation(reputation: number): ReputationTier;
+    getTierDefinition(tier: ReputationTier): ReputationTierDefinition | undefined;
+    addReputation(gain: ReputationGain): number;
+    private propagateReputation;
+    setReputation(factionId: FactionId, reputation: number): void;
+    addModifier(modifier: Omit<ReputationModifier, 'appliedAt'>): string;
+    removeModifier(id: string): boolean;
+    getActiveModifiers(factionId?: FactionId): ReputationModifier[];
+    registerReward(reward: FactionReward): void;
+    registerRewards(rewards: FactionReward[]): void;
+    private checkRewardUnlocks;
+    getAvailableRewards(factionId: FactionId): FactionReward[];
+    claimReward(rewardId: string): boolean;
+    setDiplomaticStatus(factionA: FactionId, factionB: FactionId, status: DiplomaticStatus, treatyDuration?: number): void;
+    getDiplomaticStatus(factionA: FactionId, factionB: FactionId): DiplomaticStatus;
+    areAtWar(factionA: FactionId, factionB: FactionId): boolean;
+    areAllied(factionA: FactionId, factionB: FactionId): boolean;
+    setFlag(factionId: FactionId, flag: string): void;
+    removeFlag(factionId: FactionId, flag: string): void;
+    hasFlag(factionId: FactionId, flag: string): boolean;
+    private startUpdateTimer;
+    private update;
+    getProgressToNextTier(factionId: FactionId): {
+        current: number;
+        required: number;
+        percentage: number;
+    };
+    save(): string;
+    load(data: string): void;
+    saveToStorage(): void;
+    loadFromStorage(): boolean;
+    destroy(): void;
+}
+export declare function createFactionSystem(config?: Partial<FactionSystemConfig>): NiceFaction;