@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,142 @@
+export interface GridPosition {
+    x: number;
+    y: number;
+}
+export interface GridSize {
+    width: number;
+    height: number;
+}
+export type GridCellCallback<T> = (cell: T, x: number, y: number) => void;
+export type GridCellPredicate<T> = (cell: T, x: number, y: number) => boolean;
+export type GridCellMapper<T, U> = (cell: T, x: number, y: number) => U;
+export type CardinalDirection = 'north' | 'east' | 'south' | 'west';
+export type DiagonalDirection = 'northeast' | 'southeast' | 'southwest' | 'northwest';
+export type Direction = CardinalDirection | DiagonalDirection;
+export declare const DIRECTIONS: Record<Direction, GridPosition>;
+export declare const CARDINAL_DIRECTIONS: CardinalDirection[];
+export declare const ALL_DIRECTIONS: Direction[];
+export interface GridCell<T = unknown> {
+    x: number;
+    y: number;
+    data: T;
+    walkable: boolean;
+    cost: number;
+    metadata?: Record<string, unknown>;
+}
+export interface GridConfig<T> {
+    width: number;
+    height: number;
+    defaultValue: T | (() => T);
+    wrapX?: boolean;
+    wrapY?: boolean;
+}
+export declare class NiceGrid<T> {
+    readonly width: number;
+    readonly height: number;
+    private cells;
+    private wrapX;
+    private wrapY;
+    private defaultValue;
+    constructor(config: GridConfig<T>);
+    private getDefaultValue;
+    private normalizeX;
+    private normalizeY;
+    isInBounds(x: number, y: number): boolean;
+    toIndex(x: number, y: number): number;
+    fromIndex(index: number): GridPosition;
+    get(x: number, y: number): T | undefined;
+    set(x: number, y: number, value: T): void;
+    getAt(pos: GridPosition): T | undefined;
+    setAt(pos: GridPosition, value: T): void;
+    fill(value: T): void;
+    fillRect(x: number, y: number, width: number, height: number, value: T): void;
+    clear(): void;
+    getNeighbor(x: number, y: number, direction: Direction): T | undefined;
+    getNeighbors(x: number, y: number, includeDiagonals?: boolean): Array<{
+        value: T;
+        direction: Direction;
+        x: number;
+        y: number;
+    }>;
+    getCardinalNeighbors(x: number, y: number): Array<{
+        value: T;
+        direction: CardinalDirection;
+        x: number;
+        y: number;
+    }>;
+    getAllNeighbors(x: number, y: number): Array<{
+        value: T;
+        direction: Direction;
+        x: number;
+        y: number;
+    }>;
+    forEach(callback: GridCellCallback<T>): void;
+    map<U>(mapper: GridCellMapper<T, U>): NiceGrid<U>;
+    filter(predicate: GridCellPredicate<T>): Array<{
+        value: T;
+        x: number;
+        y: number;
+    }>;
+    find(predicate: GridCellPredicate<T>): {
+        value: T;
+        x: number;
+        y: number;
+    } | undefined;
+    some(predicate: GridCellPredicate<T>): boolean;
+    every(predicate: GridCellPredicate<T>): boolean;
+    count(predicate: GridCellPredicate<T>): number;
+    getInRadius(centerX: number, centerY: number, radius: number, includeDiagonals?: boolean): Array<{
+        value: T;
+        x: number;
+        y: number;
+        distance: number;
+    }>;
+    getInRect(startX: number, startY: number, width: number, height: number): Array<{
+        value: T;
+        x: number;
+        y: number;
+    }>;
+    getLine(x1: number, y1: number, x2: number, y2: number): Array<{
+        value: T;
+        x: number;
+        y: number;
+    }>;
+    manhattanDistance(x1: number, y1: number, x2: number, y2: number): number;
+    euclideanDistance(x1: number, y1: number, x2: number, y2: number): number;
+    chebyshevDistance(x1: number, y1: number, x2: number, y2: number): number;
+    floodFill(startX: number, startY: number, value: T, predicate: GridCellPredicate<T>): number;
+    clone(): NiceGrid<T>;
+    copyTo(target: NiceGrid<T>, offsetX?: number, offsetY?: number): void;
+    toArray(): T[][];
+    toFlatArray(): T[];
+    static fromArray<T>(array: T[][], defaultValue: T): NiceGrid<T>;
+}
+export declare function createGrid<T>(width: number, height: number, defaultValue: T | (() => T)): NiceGrid<T>;
+export declare function createBooleanGrid(width: number, height: number, defaultValue?: boolean): NiceGrid<boolean>;
+export declare function createNumberGrid(width: number, height: number, defaultValue?: number): NiceGrid<number>;
+export declare class SparseGrid<T> {
+    private cells;
+    private defaultValue;
+    constructor(defaultValue: T | (() => T));
+    private key;
+    private getDefault;
+    get(x: number, y: number): T;
+    set(x: number, y: number, value: T): void;
+    has(x: number, y: number): boolean;
+    delete(x: number, y: number): boolean;
+    clear(): void;
+    getSize(): number;
+    getBounds(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    } | null;
+    forEach(callback: (value: T, x: number, y: number) => void): void;
+    entries(): Array<{
+        x: number;
+        y: number;
+        value: T;
+    }>;
+}
+export declare function createSparseGrid<T>(defaultValue: T | (() => T)): SparseGrid<T>;

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

@@ -0,0 +1,162 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type GuildId = string;
+export type RankId = string;
+export type AllianceId = string;
+export type GuildPermission = 'invite' | 'kick' | 'promote' | 'demote' | 'edit_info' | 'edit_ranks' | 'manage_bank' | 'withdraw_bank' | 'deposit_bank' | 'declare_war' | 'manage_alliance' | 'broadcast' | 'edit_motd' | 'disband';
+export interface GuildRank {
+    id: RankId;
+    name: string;
+    order: number;
+    permissions: Set<GuildPermission>;
+    isDefault?: boolean;
+    isLeader?: boolean;
+}
+export interface GuildInfo {
+    id: GuildId;
+    name: string;
+    tag: string;
+    description: string;
+    motd: string;
+    emblem?: string;
+    createdAt: number;
+    leaderId: EntityId;
+}
+export interface GuildMember {
+    entityId: EntityId;
+    rankId: RankId;
+    joinedAt: number;
+    lastActive: number;
+    contribution: number;
+    note?: string;
+}
+export interface GuildBank {
+    gold: number;
+    items: Map<string, number>;
+    capacity: number;
+}
+export interface GuildPerk {
+    id: string;
+    name: string;
+    description: string;
+    level: number;
+    maxLevel: number;
+    effects: {
+        type: string;
+        value: number;
+    }[];
+    cost: number;
+}
+export interface Guild {
+    info: GuildInfo;
+    ranks: Map<RankId, GuildRank>;
+    members: Map<EntityId, GuildMember>;
+    bank: GuildBank;
+    level: number;
+    experience: number;
+    perks: Map<string, GuildPerk>;
+    maxMembers: number;
+    allianceId?: AllianceId;
+    wars: Set<GuildId>;
+    rivals: Set<GuildId>;
+}
+export interface Alliance {
+    id: AllianceId;
+    name: string;
+    leaderId: GuildId;
+    memberGuilds: Set<GuildId>;
+    createdAt: number;
+}
+export interface GuildInvitation {
+    id: string;
+    guildId: GuildId;
+    targetId: EntityId;
+    inviterId: EntityId;
+    createdAt: number;
+    expiresAt: number;
+}
+export interface GuildApplication {
+    id: string;
+    guildId: GuildId;
+    applicantId: EntityId;
+    message: string;
+    createdAt: number;
+}
+export type GuildEventType = 'guild-created' | 'guild-disbanded' | 'member-joined' | 'member-left' | 'member-kicked' | 'member-promoted' | 'member-demoted' | 'rank-created' | 'rank-updated' | 'rank-deleted' | 'info-updated' | 'level-up' | 'perk-unlocked' | 'bank-deposit' | 'bank-withdraw' | 'war-declared' | 'war-ended' | 'alliance-created' | 'alliance-joined' | 'alliance-left' | 'alliance-disbanded';
+export interface GuildEvent {
+    type: GuildEventType;
+    guildId: GuildId;
+    entityId?: EntityId;
+    data?: Record<string, unknown>;
+}
+export interface GuildSystemConfig {
+    maxGuilds?: number;
+    defaultMaxMembers?: number;
+    invitationExpiryMs?: number;
+    guildNameMinLength?: number;
+    guildNameMaxLength?: number;
+    tagMinLength?: number;
+    tagMaxLength?: number;
+    maxRanks?: number;
+    experiencePerLevel?: number[];
+    creationCost?: number;
+}
+export declare const DEFAULT_GUILD_CONFIG: GuildSystemConfig;
+export declare class NiceGuild extends EventEmitter {
+    private guilds;
+    private alliances;
+    private invitations;
+    private applications;
+    private entityToGuild;
+    private nameToGuild;
+    private tagToGuild;
+    private nextGuildId;
+    private nextAllianceId;
+    private config;
+    constructor(config?: Partial<GuildSystemConfig>);
+    createGuild(founderId: EntityId, name: string, tag: string, description?: string): GuildId | null;
+    private createDefaultRanks;
+    disbandGuild(guildId: GuildId, disbanderId: EntityId): boolean;
+    invite(guildId: GuildId, inviterId: EntityId, targetId: EntityId): string | null;
+    acceptInvitation(invitationId: string): boolean;
+    declineInvitation(invitationId: string): void;
+    leave(entityId: EntityId): boolean;
+    kick(guildId: GuildId, kickerId: EntityId, targetId: EntityId): boolean;
+    promote(guildId: GuildId, promoterId: EntityId, targetId: EntityId): boolean;
+    demote(guildId: GuildId, demoterId: EntityId, targetId: EntityId): boolean;
+    transferLeadership(guildId: GuildId, currentLeaderId: EntityId, newLeaderId: EntityId): boolean;
+    hasPermission(guildId: GuildId, entityId: EntityId, permission: GuildPermission): boolean;
+    createRank(guildId: GuildId, creatorId: EntityId, rankId: RankId, name: string, order: number, permissions: GuildPermission[]): boolean;
+    updateRank(guildId: GuildId, updaterId: EntityId, rankId: RankId, updates: {
+        name?: string;
+        permissions?: GuildPermission[];
+    }): boolean;
+    deleteRank(guildId: GuildId, deleterId: EntityId, rankId: RankId): boolean;
+    updateInfo(guildId: GuildId, updaterId: EntityId, updates: {
+        description?: string;
+        motd?: string;
+        emblem?: string;
+    }): boolean;
+    depositGold(guildId: GuildId, entityId: EntityId, amount: number): boolean;
+    withdrawGold(guildId: GuildId, entityId: EntityId, amount: number): boolean;
+    depositItem(guildId: GuildId, entityId: EntityId, itemId: string, quantity: number): boolean;
+    withdrawItem(guildId: GuildId, entityId: EntityId, itemId: string, quantity: number): boolean;
+    addExperience(guildId: GuildId, amount: number): void;
+    declareWar(guildId: GuildId, declarerId: EntityId, enemyGuildId: GuildId): boolean;
+    endWar(guildId: GuildId, enemyGuildId: GuildId): boolean;
+    isAtWar(guildId1: GuildId, guildId2: GuildId): boolean;
+    createAlliance(creatorGuildId: GuildId, name: string): AllianceId | null;
+    joinAlliance(guildId: GuildId, allianceId: AllianceId): boolean;
+    leaveAlliance(guildId: GuildId): boolean;
+    getGuild(id: GuildId): Guild | undefined;
+    getGuildByName(name: string): Guild | undefined;
+    getGuildByTag(tag: string): Guild | undefined;
+    getEntityGuild(entityId: EntityId): Guild | undefined;
+    getMember(guildId: GuildId, entityId: EntityId): GuildMember | undefined;
+    getAllGuilds(): Guild[];
+    getAlliance(id: AllianceId): Alliance | undefined;
+    getInvitationsFor(entityId: EntityId): GuildInvitation[];
+}
+export declare function createGuildSystem(config?: Partial<GuildSystemConfig>): NiceGuild;
+export declare function defineGuildPerk(options: GuildPerk): GuildPerk;
+export default NiceGuild;

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

@@ -0,0 +1,112 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type PatternId = string;
+export type ControllerId = string;
+export type MotorType = 'left' | 'right' | 'both' | 'trigger_left' | 'trigger_right';
+export type WaveformType = 'sine' | 'square' | 'triangle' | 'sawtooth' | 'noise';
+export interface VibrationParams {
+    motor: MotorType;
+    intensity: number;
+    duration: number;
+    delay?: number;
+}
+export interface VibrationSegment {
+    intensity: number;
+    duration: number;
+    frequency?: number;
+    waveform?: WaveformType;
+}
+export type PatternCategory = 'combat' | 'environment' | 'ui' | 'movement' | 'notification' | 'custom';
+export interface HapticPattern {
+    id: PatternId;
+    name: string;
+    category: PatternCategory;
+    segments: VibrationSegment[];
+    motor: MotorType;
+    loop?: boolean;
+    priority: number;
+}
+export type TriggerEffect = 'off' | 'feedback' | 'weapon' | 'vibration' | 'resistance' | 'bow' | 'galloping' | 'automatic' | 'machine';
+export interface AdaptiveTriggerParams {
+    trigger: 'left' | 'right';
+    effect: TriggerEffect;
+    startPosition?: number;
+    endPosition?: number;
+    strength?: number;
+    frequency?: number;
+}
+export interface ControllerState {
+    id: ControllerId;
+    isConnected: boolean;
+    supportsHaptics: boolean;
+    supportsAdaptiveTriggers: boolean;
+    supportsHDHaptics: boolean;
+    batteryLevel?: number;
+    activePatterns: PatternId[];
+    triggerStates: {
+        left: AdaptiveTriggerParams | null;
+        right: AdaptiveTriggerParams | null;
+    };
+}
+export type HapticsEventType = 'controller-connected' | 'controller-disconnected' | 'pattern-started' | 'pattern-stopped' | 'trigger-effect-applied' | 'vibration-started' | 'vibration-stopped';
+export interface HapticsEvent {
+    type: HapticsEventType;
+    controllerId?: ControllerId;
+    patternId?: PatternId;
+    data?: Record<string, unknown>;
+}
+export interface HapticsSystemConfig {
+    enabled?: boolean;
+    globalIntensity?: number;
+    maxConcurrentPatterns?: number;
+    defaultDuration?: number;
+    respectSystemSettings?: boolean;
+    minIntensity?: number;
+    maxIntensity?: number;
+}
+export declare const DEFAULT_HAPTICS_CONFIG: HapticsSystemConfig;
+export declare class NiceHaptics extends EventEmitter {
+    private patterns;
+    private controllers;
+    private activeVibrations;
+    private config;
+    constructor(config?: Partial<HapticsSystemConfig>);
+    private initializeBuiltInPatterns;
+    registerController(controllerId: ControllerId, capabilities?: {
+        supportsHaptics?: boolean;
+        supportsAdaptiveTriggers?: boolean;
+        supportsHDHaptics?: boolean;
+    }): void;
+    unregisterController(controllerId: ControllerId): void;
+    getController(controllerId: ControllerId): ControllerState | undefined;
+    getAllControllers(): ControllerState[];
+    registerPattern(pattern: HapticPattern): void;
+    unregisterPattern(patternId: PatternId): void;
+    getPattern(patternId: PatternId): HapticPattern | undefined;
+    getPatterns(category?: PatternCategory): HapticPattern[];
+    vibrate(controllerId: ControllerId, params: VibrationParams | VibrationParams[]): void;
+    private executeVibration;
+    stopVibration(controllerId: ControllerId, motor?: MotorType): void;
+    playPattern(controllerId: ControllerId, patternId: PatternId, intensityMultiplier?: number): boolean;
+    private executePattern;
+    stopPattern(controllerId: ControllerId, patternId: PatternId): void;
+    stopAllPatterns(controllerId: ControllerId): void;
+    setAdaptiveTrigger(controllerId: ControllerId, params: AdaptiveTriggerParams): boolean;
+    clearAdaptiveTrigger(controllerId: ControllerId, trigger: 'left' | 'right'): void;
+    setWeaponTrigger(controllerId: ControllerId, trigger: 'left' | 'right', startPosition?: number, endPosition?: number, strength?: number): void;
+    setBowTrigger(controllerId: ControllerId, trigger: 'left' | 'right', strength?: number): void;
+    setResistanceTrigger(controllerId: ControllerId, trigger: 'left' | 'right', startPosition?: number, strength?: number): void;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    setGlobalIntensity(intensity: number): void;
+    getGlobalIntensity(): number;
+    stopAll(): void;
+    private stopAllForController;
+    private clampIntensity;
+    quickVibrate(controllerId: ControllerId, intensity?: number, duration?: number): void;
+    pulseVibration(controllerId: ControllerId, intensity?: number, pulseCount?: number, pulseDuration?: number, pauseDuration?: number): void;
+    rampVibration(controllerId: ControllerId, startIntensity: number, endIntensity: number, duration: number, steps?: number): void;
+}
+export declare function createHapticsSystem(config?: Partial<HapticsSystemConfig>): NiceHaptics;
+export declare function defineHapticPattern(options: HapticPattern): HapticPattern;
+export default NiceHaptics;

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

@@ -0,0 +1,197 @@
+export type HouseId = string;
+export type PropertyId = string;
+export type FurnitureId = string;
+export type RoomId = string;
+export type HouseSize = 'tiny' | 'small' | 'medium' | 'large' | 'mansion' | 'estate';
+export type PropertyType = 'apartment' | 'house' | 'villa' | 'castle' | 'treehouse' | 'underwater' | 'floating' | 'custom';
+export interface PropertyDefinition {
+    id: PropertyId;
+    name: string;
+    description: string;
+    type: PropertyType;
+    size: HouseSize;
+    rooms: RoomDefinition[];
+    maxFurniture: number;
+    storageSlots: number;
+    purchasePrice: number;
+    currency: string;
+    maintenanceCost?: number;
+    maintenanceInterval?: number;
+    levelRequired?: number;
+    questRequired?: string;
+    reputationRequired?: Record<string, number>;
+    features: string[];
+    outdoorSpace?: boolean;
+    gardenSlots?: number;
+    imageUrl?: string;
+    previewImages?: string[];
+}
+export interface RoomDefinition {
+    id: string;
+    name: string;
+    type: 'living' | 'bedroom' | 'kitchen' | 'bathroom' | 'storage' | 'crafting' | 'garden' | 'special';
+    width: number;
+    height: number;
+    maxFurniture: number;
+    wallSlots: number;
+    floorSlots: number;
+}
+export interface RoomInstance {
+    definitionId: string;
+    wallColor?: string;
+    wallTexture?: string;
+    floorColor?: string;
+    floorTexture?: string;
+    lighting?: number;
+    furniture: PlacedFurniture[];
+    decorations: PlacedDecoration[];
+}
+export interface FurnitureDefinition {
+    id: FurnitureId;
+    name: string;
+    description: string;
+    category: 'seating' | 'table' | 'storage' | 'lighting' | 'decoration' | 'appliance' | 'bed' | 'plant' | 'trophy';
+    width: number;
+    height: number;
+    depth?: number;
+    placementType: 'floor' | 'wall' | 'ceiling' | 'table';
+    rotatable: boolean;
+    stackable: boolean;
+    price: number;
+    currency: string;
+    craftable?: boolean;
+    craftingRecipe?: Record<string, number>;
+    comfortBonus?: number;
+    storageSlots?: number;
+    craftingStationId?: string;
+    restBonus?: number;
+    modelId?: string;
+    variations?: string[];
+    imageUrl?: string;
+}
+export interface PlacedFurniture {
+    instanceId: string;
+    definitionId: FurnitureId;
+    roomId: string;
+    x: number;
+    y: number;
+    rotation: number;
+    variation?: string;
+    condition: number;
+    storedItems?: Array<{
+        itemId: string;
+        quantity: number;
+    }>;
+}
+export interface PlacedDecoration {
+    instanceId: string;
+    type: 'poster' | 'painting' | 'plant' | 'rug' | 'lamp' | 'trophy';
+    itemId: string;
+    x: number;
+    y: number;
+    rotation: number;
+}
+export interface HouseInstance {
+    id: HouseId;
+    propertyId: PropertyId;
+    ownerId: string;
+    name: string;
+    purchasedAt: number;
+    lastVisitedAt?: number;
+    lastMaintenanceAt?: number;
+    maintenanceStatus: 'good' | 'needs-maintenance' | 'deteriorating';
+    rooms: Map<string, RoomInstance>;
+    totalFurniture: number;
+    totalDecorations: number;
+    comfortLevel: number;
+    aestheticScore: number;
+    storageUsed: number;
+    storageCapacity: number;
+    storedItems: Array<{
+        itemId: string;
+        quantity: number;
+    }>;
+    visitorPermissions: 'private' | 'friends' | 'guild' | 'public';
+    allowedVisitors: string[];
+    blockedVisitors: string[];
+    visitorLog: Array<{
+        visitorId: string;
+        timestamp: number;
+    }>;
+    unlockedFeatures: string[];
+    activeBuffs: string[];
+}
+export type HousingEventType = 'property-purchased' | 'property-sold' | 'furniture-placed' | 'furniture-removed' | 'furniture-moved' | 'room-customized' | 'visitor-entered' | 'visitor-left' | 'storage-updated' | 'maintenance-due' | 'maintenance-completed' | 'feature-unlocked' | 'comfort-changed';
+export interface HousingEvent {
+    type: HousingEventType;
+    timestamp: number;
+    houseId?: HouseId;
+    ownerId?: string;
+    data?: unknown;
+}
+export type HousingEventCallback = (event: HousingEvent) => void;
+export interface HousingConfig {
+    maxPropertiesPerPlayer: number;
+    maintenanceCheckInterval: number;
+    deteriorationRate: number;
+    comfortDecayRate: number;
+    visitorLogSize: number;
+    defaultStorageSlots: number;
+    storageExpansionCost: number;
+    storageExpansionAmount: number;
+    storageKey: string;
+}
+export declare const DEFAULT_HOUSING_CONFIG: HousingConfig;
+export declare class NiceHousing {
+    private config;
+    private properties;
+    private furniture;
+    private houses;
+    private playerHouses;
+    private eventListeners;
+    private idCounter;
+    constructor(config?: Partial<HousingConfig>);
+    on(event: HousingEventType, callback: HousingEventCallback): () => void;
+    private emit;
+    registerProperty(property: PropertyDefinition): void;
+    registerFurniture(furniture: FurnitureDefinition): void;
+    canPurchaseProperty(playerId: string, propertyId: PropertyId): {
+        can: boolean;
+        reason?: string;
+    };
+    purchaseProperty(playerId: string, propertyId: PropertyId, customName?: string): HouseInstance | null;
+    sellProperty(houseId: HouseId): number;
+    placeFurniture(houseId: HouseId, roomId: string, furnitureId: FurnitureId, x: number, y: number, rotation?: number, variation?: string): PlacedFurniture | null;
+    removeFurniture(houseId: HouseId, roomId: string, instanceId: string): boolean;
+    moveFurniture(houseId: HouseId, roomId: string, instanceId: string, newX: number, newY: number, newRotation?: number): boolean;
+    private isValidPlacement;
+    customizeRoom(houseId: HouseId, roomId: string, options: {
+        wallColor?: string;
+        wallTexture?: string;
+        floorColor?: string;
+        floorTexture?: string;
+        lighting?: number;
+    }): boolean;
+    storeItem(houseId: HouseId, itemId: string, quantity: number): boolean;
+    retrieveItem(houseId: HouseId, itemId: string, quantity: number): boolean;
+    expandStorage(houseId: HouseId): boolean;
+    setVisitorPermissions(houseId: HouseId, permissions: 'private' | 'friends' | 'guild' | 'public'): boolean;
+    allowVisitor(houseId: HouseId, visitorId: string): boolean;
+    blockVisitor(houseId: HouseId, visitorId: string): boolean;
+    canVisit(houseId: HouseId, visitorId: string, relationship?: 'friend' | 'guild' | 'none'): boolean;
+    recordVisit(houseId: HouseId, visitorId: string): void;
+    checkMaintenance(houseId: HouseId): void;
+    performMaintenance(houseId: HouseId): boolean;
+    private recalculateHouseStats;
+    getHouse(houseId: HouseId): HouseInstance | undefined;
+    getPlayerHouses(playerId: string): HouseInstance[];
+    getProperty(propertyId: PropertyId): PropertyDefinition | undefined;
+    getAllProperties(): PropertyDefinition[];
+    getAvailableProperties(playerId: string): PropertyDefinition[];
+    getFurnitureCatalog(category?: string): FurnitureDefinition[];
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createHousingSystem(config?: Partial<HousingConfig>): NiceHousing;