moolabs 0.3.0__py3-none-any.whl

moolabs/models/filter_string.py

@@ -0,0 +1,129 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.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 FilterString(BaseModel):
+    """
+    A filter for a string field.
+    """ # noqa: E501
+    eq: Optional[StrictStr] = Field(default=None, description="The field must be equal to the provided value.", alias="$eq")
+    ne: Optional[StrictStr] = Field(default=None, description="The field must not be equal to the provided value.", alias="$ne")
+    var_in: Optional[List[StrictStr]] = Field(default=None, description="The field must be in the provided list of values.", alias="$in")
+    nin: Optional[List[StrictStr]] = Field(default=None, description="The field must not be in the provided list of values.", alias="$nin")
+    like: Optional[StrictStr] = Field(default=None, description="The field must match the provided value.", alias="$like")
+    nlike: Optional[StrictStr] = Field(default=None, description="The field must not match the provided value.", alias="$nlike")
+    ilike: Optional[StrictStr] = Field(default=None, description="The field must match the provided value, ignoring case.", alias="$ilike")
+    nilike: Optional[StrictStr] = Field(default=None, description="The field must not match the provided value, ignoring case.", alias="$nilike")
+    gt: Optional[StrictStr] = Field(default=None, description="The field must be greater than the provided value.", alias="$gt")
+    gte: Optional[StrictStr] = Field(default=None, description="The field must be greater than or equal to the provided value.", alias="$gte")
+    lt: Optional[StrictStr] = Field(default=None, description="The field must be less than the provided value.", alias="$lt")
+    lte: Optional[StrictStr] = Field(default=None, description="The field must be less than or equal to the provided value.", alias="$lte")
+    var_and: Optional[List[FilterString]] = Field(default=None, description="Provide a list of filters to be combined with a logical AND.", alias="$and")
+    var_or: Optional[List[FilterString]] = Field(default=None, description="Provide a list of filters to be combined with a logical OR.", alias="$or")
+    __properties: ClassVar[List[str]] = ["$eq", "$ne", "$in", "$nin", "$like", "$nlike", "$ilike", "$nilike", "$gt", "$gte", "$lt", "$lte", "$and", "$or"]
+
+    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 FilterString 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 var_and (list)
+        _items = []
+        if self.var_and:
+            for _item_var_and in self.var_and:
+                if _item_var_and:
+                    _items.append(_item_var_and.to_dict())
+            _dict['$and'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in var_or (list)
+        _items = []
+        if self.var_or:
+            for _item_var_or in self.var_or:
+                if _item_var_or:
+                    _items.append(_item_var_or.to_dict())
+            _dict['$or'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FilterString from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "$eq": obj.get("$eq"),
+            "$ne": obj.get("$ne"),
+            "$in": obj.get("$in"),
+            "$nin": obj.get("$nin"),
+            "$like": obj.get("$like"),
+            "$nlike": obj.get("$nlike"),
+            "$ilike": obj.get("$ilike"),
+            "$nilike": obj.get("$nilike"),
+            "$gt": obj.get("$gt"),
+            "$gte": obj.get("$gte"),
+            "$lt": obj.get("$lt"),
+            "$lte": obj.get("$lte"),
+            "$and": [FilterString.from_dict(_item) for _item in obj["$and"]] if obj.get("$and") is not None else None,
+            "$or": [FilterString.from_dict(_item) for _item in obj["$or"]] if obj.get("$or") is not None else None
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+FilterString.model_rebuild(raise_errors=False)
+

moolabs/models/filter_time.py

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.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
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FilterTime(BaseModel):
+    """
+    A filter for a time field.
+    """ # noqa: E501
+    gt: Optional[datetime] = Field(default=None, description="The field must be greater than the provided value.", alias="$gt")
+    gte: Optional[datetime] = Field(default=None, description="The field must be greater than or equal to the provided value.", alias="$gte")
+    lt: Optional[datetime] = Field(default=None, description="The field must be less than the provided value.", alias="$lt")
+    lte: Optional[datetime] = Field(default=None, description="The field must be less than or equal to the provided value.", alias="$lte")
+    var_and: Optional[List[FilterTime]] = Field(default=None, description="Provide a list of filters to be combined with a logical AND.", alias="$and")
+    var_or: Optional[List[FilterTime]] = Field(default=None, description="Provide a list of filters to be combined with a logical OR.", alias="$or")
+    __properties: ClassVar[List[str]] = ["$gt", "$gte", "$lt", "$lte", "$and", "$or"]
+
+    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 FilterTime 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 var_and (list)
+        _items = []
+        if self.var_and:
+            for _item_var_and in self.var_and:
+                if _item_var_and:
+                    _items.append(_item_var_and.to_dict())
+            _dict['$and'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in var_or (list)
+        _items = []
+        if self.var_or:
+            for _item_var_or in self.var_or:
+                if _item_var_or:
+                    _items.append(_item_var_or.to_dict())
+            _dict['$or'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FilterTime from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "$gt": obj.get("$gt"),
+            "$gte": obj.get("$gte"),
+            "$lt": obj.get("$lt"),
+            "$lte": obj.get("$lte"),
+            "$and": [FilterTime.from_dict(_item) for _item in obj["$and"]] if obj.get("$and") is not None else None,
+            "$or": [FilterTime.from_dict(_item) for _item in obj["$or"]] if obj.get("$or") is not None else None
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+FilterTime.model_rebuild(raise_errors=False)
+

moolabs/models/finance_summary.py

@@ -0,0 +1,143 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.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, Optional
+from moolabs.models.budget_pace_status import BudgetPaceStatus
+from moolabs.models.measure import Measure
+from moolabs.models.period_window import PeriodWindow
+from moolabs.models.provider_billing_reference import ProviderBillingReference
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FinanceSummary(BaseModel):
+    """
+    FinanceSummary
+    """ # noqa: E501
+    direct_gross_margin: Measure
+    budget_utilization: Measure
+    budget_amount: Measure
+    budget_headroom: Measure
+    reconciliation_coverage: Measure
+    provider_billing_references: List[ProviderBillingReference]
+    budget_period: Optional[PeriodWindow] = None
+    budget_pace_status: Optional[BudgetPaceStatus] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["direct_gross_margin", "budget_utilization", "budget_amount", "budget_headroom", "reconciliation_coverage", "provider_billing_references", "budget_period", "budget_pace_status"]
+
+    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 FinanceSummary 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of direct_gross_margin
+        if self.direct_gross_margin:
+            _dict['direct_gross_margin'] = self.direct_gross_margin.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of budget_utilization
+        if self.budget_utilization:
+            _dict['budget_utilization'] = self.budget_utilization.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of budget_amount
+        if self.budget_amount:
+            _dict['budget_amount'] = self.budget_amount.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of budget_headroom
+        if self.budget_headroom:
+            _dict['budget_headroom'] = self.budget_headroom.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of reconciliation_coverage
+        if self.reconciliation_coverage:
+            _dict['reconciliation_coverage'] = self.reconciliation_coverage.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in provider_billing_references (list)
+        _items = []
+        if self.provider_billing_references:
+            for _item_provider_billing_references in self.provider_billing_references:
+                if _item_provider_billing_references:
+                    _items.append(_item_provider_billing_references.to_dict())
+            _dict['provider_billing_references'] = _items
+        # override the default output from pydantic by calling `to_dict()` of budget_period
+        if self.budget_period:
+            _dict['budget_period'] = self.budget_period.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FinanceSummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "direct_gross_margin": Measure.from_dict(obj["direct_gross_margin"]) if obj.get("direct_gross_margin") is not None else None,
+            "budget_utilization": Measure.from_dict(obj["budget_utilization"]) if obj.get("budget_utilization") is not None else None,
+            "budget_amount": Measure.from_dict(obj["budget_amount"]) if obj.get("budget_amount") is not None else None,
+            "budget_headroom": Measure.from_dict(obj["budget_headroom"]) if obj.get("budget_headroom") is not None else None,
+            "reconciliation_coverage": Measure.from_dict(obj["reconciliation_coverage"]) if obj.get("reconciliation_coverage") is not None else None,
+            "provider_billing_references": [ProviderBillingReference.from_dict(_item) for _item in obj["provider_billing_references"]] if obj.get("provider_billing_references") is not None else None,
+            "budget_period": PeriodWindow.from_dict(obj["budget_period"]) if obj.get("budget_period") is not None else None,
+            "budget_pace_status": obj.get("budget_pace_status")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

moolabs/models/first_pass_redline_request.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.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 typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FirstPassRedlineRequest(BaseModel):
+    """
+    Optional body for POST /quotes/{id}/redlines/first-pass.
+    """ # noqa: E501
+    industry_vertical: Optional[Annotated[str, Field(strict=True, max_length=64)]] = 'ai-saas'
+    __properties: ClassVar[List[str]] = ["industry_vertical"]
+
+    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 FirstPassRedlineRequest 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 FirstPassRedlineRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "industry_vertical": obj.get("industry_vertical") if obj.get("industry_vertical") is not None else 'ai-saas'
+        })
+        return _obj
+
+

moolabs/models/first_pass_redline_response.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FirstPassRedlineResponse(BaseModel):
+    """
+    FirstPassRedlineResponse
+    """ # noqa: E501
+    count: StrictInt
+    redline_ids: List[StrictStr]
+    __properties: ClassVar[List[str]] = ["count", "redline_ids"]
+
+    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 FirstPassRedlineResponse 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 FirstPassRedlineResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "count": obj.get("count"),
+            "redline_ids": obj.get("redline_ids")
+        })
+        return _obj
+
+

moolabs/models/flag_disputed_request.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.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_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FlagDisputedRequest(BaseModel):
+    """
+    POST /cases/{id}/invoices/{inv_id}/flag-disputed — Phase 1 placeholder.
+    """ # noqa: E501
+    disputed_amount_micros: Annotated[int, Field(strict=True, ge=1)]
+    description: Annotated[str, Field(strict=True, max_length=2000)]
+    dispute_type: Optional[StrictStr] = Field(default='admin', description="Dispute type for classification")
+    __properties: ClassVar[List[str]] = ["disputed_amount_micros", "description", "dispute_type"]
+
+    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 FlagDisputedRequest 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 FlagDisputedRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "disputed_amount_micros": obj.get("disputed_amount_micros"),
+            "description": obj.get("description"),
+            "dispute_type": obj.get("dispute_type") if obj.get("dispute_type") is not None else 'admin'
+        })
+        return _obj
+
+