what would be the best file/folder structure for the following mermaid code. make sure everything is in a logical place so it's easy to find by people and uses separation of concerns

classDiagram
    class Saveable {
        +async save() void
        +serialize() Object
        +withSave(operation) Function
    }

    class WebScraper {
        -url: String
        -interval: Number
        +async fetchPlayerCount() Object
    }

    class PlayerGraphManager {
        -data: Array~PlayerGraphNode~
        +addData(timestamp: Date, playerCount: Number) void
        +getData() Object
        +async generateGraph() Graph
        +async generateAndDisplayGraph() void
    }

    class PlayerGraphNode {
        -timestamp: Date
        -playerCount: Number
        +async save() void
        +serialize() Object
    }

    class Graph {
        -times: Array~Date~
        -playerCounts: Array~Number~
        +async draw() Buffer
    }

    class PlayerGraphDisplay {
        -graph: Graph
        +async sendGraph() void
        +async displayGraph() void
    }

    class DataManager {
        - _filePath: string
        #directory: string
        #filePromise: Promise<void>
        static #fileLock: Object
        static #instances: Object
        + constructor(subDirectory: string, fileName: string)
        + static getInstance(subDirectory: string, fileName: string): DataManager
        + async _readFromFile(): Object|null
        + async _ensureSource(): Promise<void>
        + static resetInstances(): void
        + static getInstances(): Object
        - async #initializeFile(): void
        - async #writeToFile(data: Object): void
    }

    class DynamicDataManager {
        #filteredData: Object
        #mutex: Mutex
        static #instances: Object
        + constructor(fileName: string)
        + static getInstance(fileName: string): DynamicDataManager
        + async createRecord(key: string, value: Object): void
        + async readRecord(key: string): Object|null
        + async getWhere(property: string, operator: string, value: any): DynamicDataManager
        + where(property: string, operator: string, value: any): DynamicDataManager
        + getResult(): Object
        + async readAllRecords(): Object
        + async updateRecord(key: string, value: Object): void
        + async deleteRecord(key: string): void
        - static operators: Object
    }

    class StaticDataManager {
        #data: Object|null
        static #instances: Object
        + constructor(fileName: string)
        + static getInstance(fileName: string): StaticDataManager
        + async getData(): Object|null
        - async _readFromFile(): Object|null
    }

    class Mutex {
        - locked: boolean
        - queue: Array<Function>
        + constructor()
        + async acquire(): Promise<void>
        + release(): void
    }

    class Generator {
        - data: StaticGeneratorDataManager
        - userId: string
        - fuel: number
        - level: number
        - powered: boolean
        - lastUpdated: number
        + constructor(uid: string, fuel: number, level: number, powered: boolean, lastUpdated: number)
        + static revive(instance: Object): Generator
        + async notify(amount: number): Promise<void>
        + async addFuel(): Promise<void>
        + decreaseFuel(amount: number): void
        + async upgradeLevel(): Promise<void>
        + async _getMaxFuel(): Promise<number>
        + powerOff(): void
        + powerOn(): void
        + isPowered(): boolean
        + getUserId(): string
        + getFuel(): number
        + async getFuelLevel(): Promise<number>
        + getLevel(): number
        + async isMaxLevel(): Promise<boolean>
        + getTimeLeft(): number
        + async save(): Promise<void>
        + serialize(): Object
    }

    class GeneratorManager {
        #dataManager: DynamicDataManager
        #generators: HashMap
        + constructor()
        + async start(): void
        + async getByUserId(uid: string): Generator
        + async create(id: string): Generator
        + async getAll(): Object
        + async update(id: string, generator: Generator): void
        + async delete(id: string): void
    }

    class HashMap {
        + constructor()
        + put(key: string, value: any): void
        + get(key: string): any
        + remove(key: string): void
    }

    class StaticGeneratorDataManager {
        #staticDataManager: StaticDataManager
        + constructor()
        + async getAllGenerators(): Array
        + async getGeneratorByLevel(level: number): Object|null
        + async getHoursPerGasCanByLevel(level: number): number|null
        + async getMaxLevel(): number
    }

    PlayerGraphNode --> Saveable

    WebScraper --> PlayerGraphManager : manages
    PlayerGraphManager *-- PlayerGraphNode : contains
    PlayerGraphManager --> Graph : generates
    PlayerGraphManager --> PlayerGraphDisplay : uses
    PlayerGraphManager --> DynamicDataManager : implements
    
    DataManager <|-- DynamicDataManager
    DataManager <|-- StaticDataManager
    DynamicDataManager --|> DataManager
    StaticDataManager --|> DataManager
    GeneratorManager --|> DynamicDataManager
    GeneratorManager --|> HashMap
    Generator --|> Saveable
    GeneratorManager -- Generator
    Generator --|> StaticGeneratorDataManager
    StaticGeneratorDataManager --|> StaticDataManager
    Mutex --|> DynamicDataManager