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: ReadablePathLike, **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 = ensure_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: WritablePathLike,
    indent: int | str | None = 4,
    **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()`
        **kwargs: Optional extra keyword arguments to pass to `to_json()`

    Returns:
        output_path: Universal Path representation of the target file.
    """
    output_path = ensure_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, **kwargs))
    return output_path

def to_json(self, default=llmeter_default_serializer, **kwargs) -> str:
    """Serialize this object to JSON.

    Args:
        default: Fallback serializer. Defaults to
            :func:`~llmeter.json_utils.llmeter_default_serializer`.
        **kwargs: Extra keyword arguments passed to :func:`json.dumps`.
    """
    return json.dumps(self.to_dict(), default=default, **kwargs)