TypeScript Schema Generator

Here's the reference information for the included TypeScript schema generator classes with all their parameters, attributes and methods.

You can import these classes directly from pyrmute:

from pyrmute import TypeScriptConfig, TypeScriptExporter

pyrmute.TypeScriptExporter

TypeScriptExporter(
    registry, style="interface", config=None
)

Export Pydantic models to TypeScript schema files.

Initialize the TypeScript exporter.

PARAMETER	DESCRIPTION
registry	Model registry instance. TYPE: Registry
style	Output style - 'interface', 'type', or 'zod'. TYPE: Literal['interface', 'type', 'zod'] DEFAULT: 'interface'
config	Optional configuration for schema generation. TYPE: TypeScriptConfig | None DEFAULT: None

Source code in src/pyrmute/typescript_schema.py

def __init__(
    self: Self,
    registry: Registry,
    style: Literal["interface", "type", "zod"] = "interface",
    config: TypeScriptConfig | None = None,
) -> None:
    """Initialize the TypeScript exporter.

    Args:
        registry: Model registry instance.
        style: Output style - 'interface', 'type', or 'zod'.
        config: Optional configuration for schema generation.
    """
    self._registry = registry
    self.generator = TypeScriptSchemaGenerator(style=style, config=config)

generator instance-attribute

generator = TypeScriptSchemaGenerator(
    style=style, config=config
)

export_schema

export_schema(
    name,
    version,
    output_path=None,
    organization="flat",
    include_barrel_exports=True,
)

Export a single model version as a TypeScript schema.

PARAMETER	DESCRIPTION
name	Model name. TYPE: str
version	Model version. TYPE: str | ModelVersion
output_path	Optional file path to save schema. TYPE: str | Path | None DEFAULT: None
organization	Directory structure for output files: - 'flat': All files in output directory (Model.v1.0.0.ts) - 'major_version': Organize by major version (v1/Model.v1.0.0.ts) - 'model': Organize by model name (Model/1.0.0.ts) TYPE: Literal['flat', 'major_version', 'model'] DEFAULT: 'flat'
include_barrel_exports	Whether to generate index.ts files for easier imports. TYPE: bool DEFAULT: True

RETURNS	DESCRIPTION
str	TypeScript schema code.

Source code in src/pyrmute/typescript_schema.py

def export_schema(
    self: Self,
    name: str,
    version: str | ModelVersion,
    output_path: str | Path | None = None,
    organization: Literal["flat", "major_version", "model"] = "flat",
    include_barrel_exports: bool = True,
) -> str:
    """Export a single model version as a TypeScript schema.

    Args:
        name: Model name.
        version: Model version.
        output_path: Optional file path to save schema.
        organization: Directory structure for output files:
            - 'flat': All files in output directory (Model.v1.0.0.ts)
            - 'major_version': Organize by major version (v1/Model.v1.0.0.ts)
            - 'model': Organize by model name (Model/1.0.0.ts)
        include_barrel_exports: Whether to generate index.ts files for easier
            imports.

    Returns:
        TypeScript schema code.
    """
    model = self._registry.get_model(name, version)
    module = self.generator.generate_schema(model, name, version)
    schema_code = module.to_string()

    if output_path:
        output_path = Path(output_path)

        version_obj = (
            ModelVersion.parse(version) if isinstance(version, str) else version
        )

        if organization == "major_version":
            version_dir = output_path / f"v{version_obj.major}"
            version_dir.mkdir(parents=True, exist_ok=True)
            filepath = version_dir / f"{name}.v{version_obj}.ts"
        elif organization == "model":
            model_dir = output_path / name
            model_dir.mkdir(parents=True, exist_ok=True)
            filepath = model_dir / f"{version_obj}.ts"
        else:  # flat
            output_path.mkdir(parents=True, exist_ok=True)
            filepath = output_path / f"{name}.v{version_obj}.ts"

        filepath.write_text(schema_code)

    return schema_code

export_all_schemas

export_all_schemas(
    output_dir,
    organization="flat",
    include_barrel_exports=True,
)

Export all registered models as TypeScript schemas.

PARAMETER	DESCRIPTION
output_dir	Directory to save schema files. TYPE: str | Path
organization	Directory structure for output files: - 'flat': All files in output directory (Model.v1.0.0.ts) - 'major_version': Organize by major version (v1/Model.v1.0.0.ts) - 'model': Organize by model name (Model/1.0.0.ts) TYPE: Literal['flat', 'major_version', 'model'] DEFAULT: 'flat'
include_barrel_exports	Whether to generate index.ts files for easier imports. TYPE: bool DEFAULT: True

RETURNS	DESCRIPTION
dict[str, dict[str, str]]	Dictionary mapping model names to version to schema code.

Source code in src/pyrmute/typescript_schema.py

def export_all_schemas(
    self: Self,
    output_dir: str | Path,
    organization: Literal["flat", "major_version", "model"] = "flat",
    include_barrel_exports: bool = True,
) -> dict[str, dict[str, str]]:
    """Export all registered models as TypeScript schemas.

    Args:
        output_dir: Directory to save schema files.
        organization: Directory structure for output files:
            - 'flat': All files in output directory (Model.v1.0.0.ts)
            - 'major_version': Organize by major version (v1/Model.v1.0.0.ts)
            - 'model': Organize by model name (Model/1.0.0.ts)
        include_barrel_exports: Whether to generate index.ts files for easier
            imports.

    Returns:
        Dictionary mapping model names to version to schema code.
    """
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    all_schemas: dict[str, dict[str, str]] = {}

    for model_name in self._registry.list_models():
        all_schemas[model_name] = {}
        versions = self._registry.get_versions(model_name)

        for version in versions:
            model = self._registry.get_model(model_name, version)
            module = self.generator.generate_schema(model, model_name, version)
            schema_code = module.to_string()

            version_obj = (
                ModelVersion.parse(version) if isinstance(version, str) else version
            )

            if organization == "major_version":
                version_dir = output_dir / f"v{version_obj.major}"
                version_dir.mkdir(exist_ok=True)
                filepath = version_dir / f"{model_name}.v{version_obj}.ts"
            elif organization == "model":
                model_dir = output_dir / model_name
                model_dir.mkdir(exist_ok=True)
                filepath = model_dir / f"{version_obj}.ts"
            else:  # flat
                filepath = output_dir / f"{model_name}.v{version_obj}.ts"

            filepath.write_text(schema_code)
            all_schemas[model_name][str(version)] = schema_code

    if include_barrel_exports and organization != "flat":
        if organization == "major_version":
            self._generate_barrel_exports_major_version(output_dir)
        elif organization == "model":
            self._generate_barrel_exports_model(output_dir)

    return all_schemas

pyrmute.TypeScriptConfig

Bases: TypedDict

Configuration options for TypeScript schema generation.

include_docs instance-attribute

include_docs

date_format instance-attribute

date_format

enum_style instance-attribute

enum_style

include_computed_fields instance-attribute

include_computed_fields

mark_computed_readonly instance-attribute

mark_computed_readonly