Help me implement this concept.

Fixed API with example:
```python
import json
from pathlib import Path
from typing import Any

import numpy as np


def load_json(path) -> dict[str, Any]:
    path = Path(path)
    return json.loads(path.read_text())

def save_json(path, data) -> None:
    path = Path(path)
    return path.write_text(json.dumps(data))

# everthing below is FIXED API. Everything above is just a concept and can be changed!
mydir = MyDir("/tmp/testdir1")
assert mydir.path == Path("/tmp/testdir1")
mydir.config.save({"a": 2, "b": "test"})
config = mydir.config.load()
print(f"Config is saved at {mydir.config.path}")

for i in range(10):
    ts_data = np.random.uniform(0, 1, 5)
    mydir.ts1.save(ts_data, key=i)

all_ts_keys, all_ts_data = mydir.ts1.load_all(sort_it=False)  # returns tuple[list, list]
example_ts_data = mydir.ts1.load(key=8)

dynamic_ts_1 = mydir.new_ts("dynamic_ts_1")
for i in range(20):
    ts_data = np.random.uniform(0, 1, 5)
    dynamic_ts_1.save(ts_data, key=i)

dynamic_ts_1_mean = np.mean(dynamic_ts_1.load_all(sort_it=False), axis=0)
```


`rel_path` means relative to the root of `MyDir`.

Should support autocomplete, type checking, etc. That means that I want for example `mydir.conf` to be autocompleted to `mydir.config`. It has to know that there is the member `config` to do that. A counter-example is a pandas dataframe. I can do `df.test123` when there is the column `test123`, but it won't be suggested for autocomplete since it does not know that there is this member. Similarly, I want type checking to work such that I know the type of `config` when I do `config = mydir.config.load()`.




Idea of how to declare the directoy, because I don't have the python code yet in which it should be declared to make type support possible:. The Python code should look nothing like this, this just shows what kind of stuff should be declared.
```json
{
"MyDir": {
    "config": {
        "load_fun": "load_json",
        "save_fun": "save_json",
        "rel_path": "config.json",
    },
    "data": {
        "load_fun": "np.load",
        "save_fun": "np.save",
        "rel_path": "data.npy",
    },
    "ts1": {
        "load_fun": "np.load",
        "save_fun": "np.save",
        "rel_path": "ts1/",
        "file_template": "ts1data_{key}.npy",
    },
}
}
```


The idea is also to have many such dirs and that the declarative structure is all there is needed. Like this:
```json
{
    "MyDir1": {
        "config": {
            "load_fun": "load_json",
            "save_fun": "save_json",
            "rel_path": "config.json",
        },
        "data": {
            "load_fun": "np.load",
            "save_fun": "np.save",
            "rel_path": "data.npy",
        },
        "ts1": {
            "load_fun": "np.load",
            "save_fun": "np.save",
            "rel_path": "ts1/",
            "file_template": "ts1data_{key}.npy",
        }
    },
    "MyDir2": {
        "metadata": {
            "load_fun": "load_json",
            "save_fun": "save_json",
            "rel_path": "metadata.json",
        },
        "data": {
            "load_fun": "np.load",
            "save_fun": "np.save",
            "rel_path": "data.npy",
        },
        "testts": {
            "load_fun": "np.load",
            "save_fun": "np.save",
            "rel_path": "testts/",
            "file_template": "data_{key}.npy",
        },
        "testts2": {
            "load_fun": "np.load",
            "save_fun": "np.save",
            "rel_path": "testts2/",
            "file_template": "data2_{key}.npy",
        }
    }
}
```

Code Guidelines:
- KISS
- Minimal Code duplication