Serde

@classmethod
def from_dict(cls, **kwargs) -> TSerializable:
    """Load an instance of this class from a JSON-able dictionary representation"""
    ...

def to_dict(self) -> dict:
    """Represent this object with a fully JSON-serializable dictionary"""
    ...

@classmethod
def from_dict(
    cls: Type[TJSONable],
    raw: dict,
    alt_classes: Dict[str, TJSONable] = {},
    **kwargs: Any,
) -> TJSONable:
    """Initialize an instance of this class from a plain dict (with optional extra kwargs)

    Args:
        raw: A plain Python dict, for example loaded from a JSON file
        alt_classes: By default, this method will only use the class of the current object
            (i.e. `cls`). If you want to support loading of subclasses, provide a mapping
            from your raw dict's `_type` field to class, for example `{cls.__name__: cls}`.
        **kwargs: Optional extra keyword arguments to pass to the constructor
    """
    if alt_classes:
        return from_dict_with_class_map(
            raw=raw,
            class_map={cls.__name__: cls, **alt_classes},
            **kwargs,
        )
    else:
        return from_dict_with_class(raw=raw, cls=cls, **kwargs)

@classmethod
def from_file(cls: Type[TJSONable], input_path: os.PathLike, **kwargs) -> TJSONable:
    """Initialize an instance of this class from a (local or Cloud) JSON file
    Args:
        input_path: The path to the JSON data file.
        **kwargs: Optional extra keyword arguments to pass to `from_dict()`
    """
    input_path = Path(input_path)
    with input_path.open("r") as f:
        return cls.from_json(f.read(), **kwargs)

@classmethod
def from_json(cls: Type[TJSONable], json_string: str, **kwargs: Any) -> TJSONable:
    """Initialize an instance of this class from a JSON string (with optional extra kwargs)

    Args:
        json_string: A string containing valid JSON data
        **kwargs: Optional extra keyword arguments to pass to `from_dict()``
    """
    return cls.from_dict(json.loads(json_string), **kwargs)

def to_dict(self, **kwargs) -> dict:
    """Save the state of the object to a JSON-dumpable dictionary (with optional extra kwargs)

    Implementers of this method should ensure that the returned dict is fully JSON-compatible:
    Mapping any child fields from Python classes to dicts if necessary, avoiding any circular
    references, etc.
    """
    return to_dict_recursive_generic(self, **kwargs)

def to_file(
    self,
    output_path: os.PathLike,
    indent: int | str | None = 4,
    default: Callable[[Any], Any] | None = str,
    **kwargs: Any,
) -> Path:
    """Save the state of the object to a (local or Cloud) JSON file

    Args:
        output_path: The path where the configuration file will be saved.
        indent: Optional indentation passed through to `to_json()` and therefore `json.dumps()`
        default: Optional function to convert non-JSON-serializable objects to strings, passed
            through to `to_json()` and therefore to `json.dumps()`
        **kwargs: Optional extra keyword arguments to pass to `to_json()`

    Returns:
        output_path: Universal Path representation of the target file.
    """
    output_path = Path(output_path)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    with output_path.open("w") as f:
        f.write(self.to_json(indent=indent, default=default, **kwargs))
    return output_path

def to_json(self, **kwargs) -> str:
    """Serialize this object to JSON, with optional kwargs passed through to `json.dumps()`"""
    return json.dumps(self.to_dict(), **kwargs)