@nice2dev/game-engine 1.3.13 → 1.3.15

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

@@ -1,137 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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;