Syncwave

def create_store(self, tp: TypeForm[T], /, *, name: str, default: Any = void) -> T:
    """Create a store, persisted to `<root_path>/<name>.json` and two-way synced.

    Every change to the store, from Python or from the file, is validated against
    `tp`.

    Example:
    ```python
    from syncwave import SyncSet, Syncwave

    syncwave = Syncwave()

    tags = syncwave.create_store(SyncSet[str], name="tags")
    tags.add("python")
    ```

    ---

    Abstract: Usage Documentation
        [Create a Store](https://syncwave.dev/usage/syncwave/#create-a-store)

    Args:
        tp: Type of the store, e.g. `list[int]`, `SyncSet[str]`, or a `SyncModel`.
        name: Name of the store, used as its key and as its file name.
        default: Initial value, used if the file is missing or empty. Required when
            no empty value (`{}`, `[]`, `""`, or `None`) fits `tp`.

    Returns:
        The store's value: the live object for a reactive type, a copy otherwise.

    """
    if name in self.__stores:
        raise ValueError(f"Store '{name}' already exists.")
    str_guard("name", name)
    io.file_name_guard(name)

    self.__create_store(tp, name, default)
    value, store_info = self.__stores[name]
    return detach(value, store_info.type_adapter)

def store(
    self,
    *,
    name: str,
    collection: type[SyncDict[Any, Never] | SyncList[Never]]
    | Literal["auto"]
    | None = "auto",
    default: Any = void,
) -> F[[type[SyncModelLike_T]], type[SyncModelLike_T]]:
    """Class decorator creating a store from a reactive model.

    Like `create_store`, but the model is wrapped in a collection first (see
    `collection`). The class is returned unchanged.

    Example:
    ```python
    from syncwave import SyncModel, Syncwave

    syncwave = Syncwave()


    @syncwave.store(name="customers")
    class Customer(SyncModel):
        name: str
        age: int


    customers = syncwave["customers"]  # a SyncList[Customer]
    customers.append(Customer(name="Alice", age=30))
    ```

    ---

    Abstract: Usage Documentation
        [The `store` Decorator](https://syncwave.dev/usage/models/#the-store-decorator)

    Args:
        name: Name of the store, used as its key and as its file name.
        collection: `SyncList`, `SyncDict` (`str` keys) or `SyncDict[<key type>]`,
            or `None` for no wrapping. `"auto"` picks `None` for a `SyncRoot`, a
            `SyncDict` if the model has a `key` field, and `SyncList` otherwise.
        default: Initial value, used if the file is missing or empty. Pass plain
            data (e.g. a `dict` or a `list`), not an instance.

    Returns:
        A decorator that creates the store and returns the class unchanged.

    """
    if name in self.__stores:
        raise ValueError(f"Store '{name}' already exists.")
    str_guard("name", name)
    io.file_name_guard(name)

    def decorator(cls: type[SyncModelLike_T]) -> type[SyncModelLike_T]:
        if not isclass(cls):
            raise TypeError(f"Expected a class, got `{type(cls).__qualname__}`.")

        if issubclass(cls, SyncModel) or is_sync_dataclass(cls):
            store_tp = collection_wrap(cls, collection)
            self.__create_store(store_tp, name, default)
            return cls

        err = "Use %s instead of a %s."
        if issubclass(cls, BaseModel):
            raise TypeError(err % ("a `SyncModel`", "`BaseModel`"))
        if is_pydantic_dataclass(cls):
            raise TypeError(err % ("`@sync_dataclass`", "Pydantic dataclass"))
        if is_dataclass(cls):
            undecorated_guard(cls)
            raise TypeError(err % ("`@sync_dataclass`", "standard dataclass"))
        raise TypeError(
            "Expected a `SyncModel` or a reactive dataclass, "
            f"but got `{cls.__qualname__}` instead."
        )

    return decorator