stackgen-sdk 0.1.1__py3-none-any.whl

stackgen/generated/models/investigation_structured_rca.py

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from stackgen.generated.models.investigation_plain_summary import InvestigationPlainSummary
+from stackgen.generated.models.investigation_recommended_next_step import InvestigationRecommendedNextStep
+from stackgen.generated.models.investigation_structured_hypothesis_entry import InvestigationStructuredHypothesisEntry
+from stackgen.generated.models.investigation_structured_limitation_entry import InvestigationStructuredLimitationEntry
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationStructuredRCA(BaseModel):
+    """
+    Structured root-cause analysis fields attached to an investigation after triage completes.
+    """ # noqa: E501
+    root_cause: StrictStr = Field(description="Identified or suspected root cause in plain language.")
+    impact: StrictStr = Field(description="User or system impact summary.")
+    mitigation: StrictStr = Field(description="Recommended mitigation or next steps.")
+    confidence: Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]] = Field(description="Agent confidence in the RCA (0–1).")
+    unverified_hypotheses: Optional[List[InvestigationStructuredHypothesisEntry]] = Field(default=None, description="Hypotheses that could not be confirmed or ruled out during triage.")
+    ruled_out_hypotheses: Optional[List[InvestigationStructuredHypothesisEntry]] = Field(default=None, description="Hypotheses falsified during investigation.")
+    investigation_limitations: Optional[List[InvestigationStructuredLimitationEntry]] = Field(default=None, description="Observability or integration gaps encountered during triage.")
+    recommended_next_steps: Optional[List[InvestigationRecommendedNextStep]] = Field(default=None, description="Tiered remediation steps with verification, rollback, and operator commands. Required when triage status is completed; also required for HTTP error incidents.")
+    plain_summary: Optional[InvestigationPlainSummary] = None
+    __properties: ClassVar[List[str]] = ["root_cause", "impact", "mitigation", "confidence", "unverified_hypotheses", "ruled_out_hypotheses", "investigation_limitations", "recommended_next_steps", "plain_summary"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InvestigationStructuredRCA from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in unverified_hypotheses (list)
+        _items = []
+        if self.unverified_hypotheses:
+            for _item_unverified_hypotheses in self.unverified_hypotheses:
+                if _item_unverified_hypotheses:
+                    _items.append(_item_unverified_hypotheses.to_dict())
+            _dict['unverified_hypotheses'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in ruled_out_hypotheses (list)
+        _items = []
+        if self.ruled_out_hypotheses:
+            for _item_ruled_out_hypotheses in self.ruled_out_hypotheses:
+                if _item_ruled_out_hypotheses:
+                    _items.append(_item_ruled_out_hypotheses.to_dict())
+            _dict['ruled_out_hypotheses'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in investigation_limitations (list)
+        _items = []
+        if self.investigation_limitations:
+            for _item_investigation_limitations in self.investigation_limitations:
+                if _item_investigation_limitations:
+                    _items.append(_item_investigation_limitations.to_dict())
+            _dict['investigation_limitations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in recommended_next_steps (list)
+        _items = []
+        if self.recommended_next_steps:
+            for _item_recommended_next_steps in self.recommended_next_steps:
+                if _item_recommended_next_steps:
+                    _items.append(_item_recommended_next_steps.to_dict())
+            _dict['recommended_next_steps'] = _items
+        # override the default output from pydantic by calling `to_dict()` of plain_summary
+        if self.plain_summary:
+            _dict['plain_summary'] = self.plain_summary.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationStructuredRCA from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "root_cause": obj.get("root_cause"),
+            "impact": obj.get("impact"),
+            "mitigation": obj.get("mitigation"),
+            "confidence": obj.get("confidence"),
+            "unverified_hypotheses": [InvestigationStructuredHypothesisEntry.from_dict(_item) for _item in obj["unverified_hypotheses"]] if obj.get("unverified_hypotheses") is not None else None,
+            "ruled_out_hypotheses": [InvestigationStructuredHypothesisEntry.from_dict(_item) for _item in obj["ruled_out_hypotheses"]] if obj.get("ruled_out_hypotheses") is not None else None,
+            "investigation_limitations": [InvestigationStructuredLimitationEntry.from_dict(_item) for _item in obj["investigation_limitations"]] if obj.get("investigation_limitations") is not None else None,
+            "recommended_next_steps": [InvestigationRecommendedNextStep.from_dict(_item) for _item in obj["recommended_next_steps"]] if obj.get("recommended_next_steps") is not None else None,
+            "plain_summary": InvestigationPlainSummary.from_dict(obj["plain_summary"]) if obj.get("plain_summary") is not None else None
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_triage_metadata.py

@@ -0,0 +1,134 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from stackgen.generated.models.alert_role import AlertRole
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationTriageMetadata(BaseModel):
+    """
+    Opaque-but-typed metadata about how structured triage was produced (classifier version, storm context, timestamps, draft follow-ups).
+    """ # noqa: E501
+    alert_role: Optional[AlertRole] = None
+    storm_context: Optional[StrictStr] = Field(default=None, description="Whether triage ran on a lone alert or a correlated storm.")
+    classifier_version: Optional[StrictStr] = Field(default=None, description="Version tag of the heuristic or agent classifier used.")
+    classified_at: Optional[datetime] = Field(default=None, description="When cause-effect classification was last applied.")
+    more_info_requested: Optional[List[StrictStr]] = Field(default=None, description="Gaps requested when triage was accepted as draft instead of completed. Operators and follow-up submits should address every entry.")
+    more_info_notes: Optional[StrictStr] = Field(default=None, description="Plain-English note for operators explaining why the investigation is still draft. Agent-facing gap codes stay in more_info_requested.")
+    __properties: ClassVar[List[str]] = ["alert_role", "storm_context", "classifier_version", "classified_at", "more_info_requested", "more_info_notes"]
+
+    @field_validator('storm_context')
+    def storm_context_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['single', 'correlated']):
+            raise ValueError("must be one of enum values ('single', 'correlated')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InvestigationTriageMetadata from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if storm_context (nullable) is None
+        # and model_fields_set contains the field
+        if self.storm_context is None and "storm_context" in self.model_fields_set:
+            _dict['storm_context'] = None
+
+        # set to None if classifier_version (nullable) is None
+        # and model_fields_set contains the field
+        if self.classifier_version is None and "classifier_version" in self.model_fields_set:
+            _dict['classifier_version'] = None
+
+        # set to None if classified_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.classified_at is None and "classified_at" in self.model_fields_set:
+            _dict['classified_at'] = None
+
+        # set to None if more_info_requested (nullable) is None
+        # and model_fields_set contains the field
+        if self.more_info_requested is None and "more_info_requested" in self.model_fields_set:
+            _dict['more_info_requested'] = None
+
+        # set to None if more_info_notes (nullable) is None
+        # and model_fields_set contains the field
+        if self.more_info_notes is None and "more_info_notes" in self.model_fields_set:
+            _dict['more_info_notes'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationTriageMetadata from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "alert_role": obj.get("alert_role"),
+            "storm_context": obj.get("storm_context"),
+            "classifier_version": obj.get("classifier_version"),
+            "classified_at": obj.get("classified_at"),
+            "more_info_requested": obj.get("more_info_requested"),
+            "more_info_notes": obj.get("more_info_notes")
+        })
+        return _obj
+
+

stackgen/generated/models/json_error.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class JsonError(BaseModel):
+    """
+    JSON body Aiden returns for many failed requests. Same shape as `github.com/appcd-dev/go-lib/problems.Problem` serialized to JSON (`msg`, `errCode`, optional `extras`). Keep `msg` as stable constant strings; put variables in `extras` (often one object map). 
+    """ # noqa: E501
+    msg: StrictStr = Field(description="Human-readable message; use constant strings for validation errors so metrics stay low-cardinality.")
+    err_code: StrictStr = Field(description="Machine-readable code (e.g. BAD_REQUEST, PAYLOAD_TOO_LARGE, NOT_FOUND).", alias="errCode")
+    extras: Optional[List[Dict[str, Any]]] = Field(default=None, description="Optional context list; often a single object map (e.g. filename, max_files, session_id).")
+    __properties: ClassVar[List[str]] = ["msg", "errCode", "extras"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of JsonError from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of JsonError from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "msg": obj.get("msg"),
+            "errCode": obj.get("errCode"),
+            "extras": obj.get("extras")
+        })
+        return _obj
+
+

stackgen/generated/models/list_alerts_response.py

@@ -0,0 +1,119 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from stackgen.generated.models.alert_categorization_summary import AlertCategorizationSummary
+from stackgen.generated.models.alert_summary import AlertSummary
+from stackgen.generated.models.alert_v1 import AlertV1
+from stackgen.generated.models.pagination import Pagination
+from stackgen.generated.models.sync_response import SyncResponse
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ListAlertsResponse(BaseModel):
+    """
+    Paginated alert list with summary counts.
+    """ # noqa: E501
+    summary: AlertSummary
+    categorization: AlertCategorizationSummary
+    alerts: List[AlertV1] = Field(description="Current page of alerts.")
+    pagination: Pagination
+    active_sync: Optional[SyncResponse] = None
+    __properties: ClassVar[List[str]] = ["summary", "categorization", "alerts", "pagination", "active_sync"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ListAlertsResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of summary
+        if self.summary:
+            _dict['summary'] = self.summary.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of categorization
+        if self.categorization:
+            _dict['categorization'] = self.categorization.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in alerts (list)
+        _items = []
+        if self.alerts:
+            for _item_alerts in self.alerts:
+                if _item_alerts:
+                    _items.append(_item_alerts.to_dict())
+            _dict['alerts'] = _items
+        # override the default output from pydantic by calling `to_dict()` of pagination
+        if self.pagination:
+            _dict['pagination'] = self.pagination.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of active_sync
+        if self.active_sync:
+            _dict['active_sync'] = self.active_sync.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ListAlertsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "summary": AlertSummary.from_dict(obj["summary"]) if obj.get("summary") is not None else None,
+            "categorization": AlertCategorizationSummary.from_dict(obj["categorization"]) if obj.get("categorization") is not None else None,
+            "alerts": [AlertV1.from_dict(_item) for _item in obj["alerts"]] if obj.get("alerts") is not None else None,
+            "pagination": Pagination.from_dict(obj["pagination"]) if obj.get("pagination") is not None else None,
+            "active_sync": SyncResponse.from_dict(obj["active_sync"]) if obj.get("active_sync") is not None else None
+        })
+        return _obj
+
+

stackgen/generated/models/list_investigations_response.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from stackgen.generated.models.investigation import Investigation
+from stackgen.generated.models.pagination import Pagination
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ListInvestigationsResponse(BaseModel):
+    """
+    Paginated investigation list.
+    """ # noqa: E501
+    investigations: List[Investigation]
+    pagination: Pagination
+    __properties: ClassVar[List[str]] = ["investigations", "pagination"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ListInvestigationsResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in investigations (list)
+        _items = []
+        if self.investigations:
+            for _item_investigations in self.investigations:
+                if _item_investigations:
+                    _items.append(_item_investigations.to_dict())
+            _dict['investigations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of pagination
+        if self.pagination:
+            _dict['pagination'] = self.pagination.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ListInvestigationsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "investigations": [Investigation.from_dict(_item) for _item in obj["investigations"]] if obj.get("investigations") is not None else None,
+            "pagination": Pagination.from_dict(obj["pagination"]) if obj.get("pagination") is not None else None
+        })
+        return _obj
+
+

stackgen/generated/models/pagination.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Pagination(BaseModel):
+    """
+    Pagination metadata for a list response.
+    """ # noqa: E501
+    page: StrictInt = Field(description="Current page number (1-based).")
+    page_size: StrictInt = Field(description="Number of items per page.")
+    total: StrictInt = Field(description="Total number of matching items.")
+    __properties: ClassVar[List[str]] = ["page", "page_size", "total"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Pagination from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Pagination from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "page": obj.get("page"),
+            "page_size": obj.get("page_size"),
+            "total": obj.get("total")
+        })
+        return _obj
+
+