moolabs 0.3.0__py3-none-any.whl

moolabs/models/insight_card.py

@@ -0,0 +1,111 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from moolabs.models.card_type import CardType
+from moolabs.models.priority import Priority
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InsightCard(BaseModel):
+    """
+    InsightCard
+    """ # noqa: E501
+    id: StrictStr
+    type: CardType
+    title: StrictStr
+    description: StrictStr
+    cta_label: StrictStr
+    cta_route: StrictStr
+    priority: Priority
+    icon: StrictStr
+    icon_color: StrictStr
+    icon_bg: StrictStr
+    persona: List[StrictStr]
+    metric_value: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "type", "title", "description", "cta_label", "cta_route", "priority", "icon", "icon_color", "icon_bg", "persona", "metric_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 InsightCard 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 InsightCard from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "type": obj.get("type"),
+            "title": obj.get("title"),
+            "description": obj.get("description"),
+            "cta_label": obj.get("cta_label"),
+            "cta_route": obj.get("cta_route"),
+            "priority": obj.get("priority"),
+            "icon": obj.get("icon"),
+            "icon_color": obj.get("icon_color"),
+            "icon_bg": obj.get("icon_bg"),
+            "persona": obj.get("persona"),
+            "metric_value": obj.get("metric_value")
+        })
+        return _obj
+
+

moolabs/models/install_method.py

@@ -0,0 +1,38 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class InstallMethod(str, Enum):
+    """
+    Install method of the application.
+    """
+
+    """
+    allowed enum values
+    """
+    WITH_OAUTH2 = 'with_oauth2'
+    WITH_API_KEY = 'with_api_key'
+    NO_CREDENTIALS_REQUIRED = 'no_credentials_required'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of InstallMethod from a JSON string"""
+        return cls(json.loads(json_str))
+
+

moolabs/models/integration_update.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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IntegrationUpdate(BaseModel):
+    """
+    IntegrationUpdate
+    """ # noqa: E501
+    status: Optional[StrictStr] = None
+    config: Optional[Dict[str, Any]] = None
+    __properties: ClassVar[List[str]] = ["status", "config"]
+
+    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 IntegrationUpdate 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 IntegrationUpdate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "status": obj.get("status"),
+            "config": obj.get("config")
+        })
+        return _obj
+
+

moolabs/models/invalidate_portal_token_request.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvalidatePortalTokenRequest(BaseModel):
+    """
+    Request to invalidate portal token(s).
+    """ # noqa: E501
+    token: Optional[StrictStr] = Field(default=None, description="Plaintext token to revoke")
+    subject: Optional[StrictStr] = Field(default=None, description="Revoke all tokens for subject")
+    __properties: ClassVar[List[str]] = ["token", "subject"]
+
+    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 InvalidatePortalTokenRequest 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 InvalidatePortalTokenRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "token": obj.get("token"),
+            "subject": obj.get("subject")
+        })
+        return _obj
+
+

moolabs/models/invalidate_portal_tokens_request.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvalidatePortalTokensRequest(BaseModel):
+    """
+    InvalidatePortalTokensRequest
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="Invalidate a portal token by ID.")
+    subject: Optional[StrictStr] = Field(default=None, description="Invalidate all portal tokens for a subject.")
+    __properties: ClassVar[List[str]] = ["id", "subject"]
+
+    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 InvalidatePortalTokensRequest 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 InvalidatePortalTokensRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "subject": obj.get("subject")
+        })
+        return _obj
+
+

moolabs/models/invoice.py

@@ -0,0 +1,249 @@
+# 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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from moolabs.models.billing_invoice_customer_extended_details import BillingInvoiceCustomerExtendedDetails
+from moolabs.models.billing_party import BillingParty
+from moolabs.models.credit_note_original_invoice_ref import CreditNoteOriginalInvoiceRef
+from moolabs.models.invoice_app_external_ids import InvoiceAppExternalIds
+from moolabs.models.invoice_line import InvoiceLine
+from moolabs.models.invoice_payment_terms import InvoicePaymentTerms
+from moolabs.models.invoice_status import InvoiceStatus
+from moolabs.models.invoice_status_details import InvoiceStatusDetails
+from moolabs.models.invoice_totals import InvoiceTotals
+from moolabs.models.invoice_type import InvoiceType
+from moolabs.models.invoice_workflow_settings import InvoiceWorkflowSettings
+from moolabs.models.period import Period
+from moolabs.models.validation_issue import ValidationIssue
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Invoice(BaseModel):
+    """
+    Invoice represents an invoice in the system.
+    """ # noqa: E501
+    id: Annotated[str, Field(strict=True)] = Field(description="A unique identifier for the resource.")
+    description: Optional[Annotated[str, Field(strict=True, max_length=1024)]] = Field(default=None, description="Optional description of the resource. Maximum 1024 characters.")
+    metadata: Optional[Dict[str, StrictStr]] = Field(default=None, description="Additional metadata for the resource.")
+    created_at: datetime = Field(description="Timestamp of when the resource was created.", alias="createdAt")
+    updated_at: datetime = Field(description="Timestamp of when the resource was last updated.", alias="updatedAt")
+    deleted_at: Optional[datetime] = Field(default=None, description="Timestamp of when the resource was permanently deleted.", alias="deletedAt")
+    type: InvoiceType = Field(description="Type of the invoice.  The type of invoice determines the purpose of the invoice and how it should be handled.  Supported types: - standard: A regular commercial invoice document between a supplier and customer. - credit_note: Reflects a refund either partial or complete of the preceding document. A credit note effectively *extends* the previous document.")
+    supplier: BillingParty = Field(description="The taxable entity supplying the goods or services.")
+    customer: BillingInvoiceCustomerExtendedDetails = Field(description="Legal entity receiving the goods or services.")
+    number: Annotated[str, Field(min_length=1, strict=True, max_length=256)] = Field(description="Number specifies the human readable key used to reference this Invoice.  The invoice number can change in the draft phases, as we are allocating temporary draft invoice numbers, but it's final as soon as the invoice gets finalized (issued state).  Please note that the number is (depending on the upstream settings) either unique for the whole organization or unique for the customer, or in multi (stripe) account setups unique for the account.")
+    currency: Annotated[str, Field(min_length=3, strict=True, max_length=3)] = Field(description="Currency for all invoice line items.  Multi currency invoices are not supported yet.")
+    preceding: Optional[List[CreditNoteOriginalInvoiceRef]] = Field(default=None, description="Key information regarding previous invoices and potentially details as to why they were corrected.")
+    totals: InvoiceTotals = Field(description="Summary of all the invoice totals, including taxes (calculated).")
+    status: InvoiceStatus = Field(description="The status of the invoice.  This field only conatins a simplified status, for more detailed information use the statusDetails field.")
+    status_details: InvoiceStatusDetails = Field(description="The details of the current invoice status.", alias="statusDetails")
+    issued_at: Optional[datetime] = Field(default=None, description="The time the invoice was issued.  Depending on the status of the invoice this can mean multiple things: - draft, gathering: The time the invoice will be issued based on the workflow settings. - issued: The time the invoice was issued.", alias="issuedAt")
+    draft_until: Optional[datetime] = Field(default=None, description="The time until the invoice is in draft status.  On draft invoice creation it is calculated from the workflow settings.  If manual approval is required, the draftUntil time is set.", alias="draftUntil")
+    quantity_snapshoted_at: Optional[datetime] = Field(default=None, description="The time when the quantity snapshots on the invoice lines were taken.", alias="quantitySnapshotedAt")
+    collection_at: Optional[datetime] = Field(default=None, description="The time when the invoice will be/has been collected.", alias="collectionAt")
+    due_at: Optional[datetime] = Field(default=None, description="Due time of the fulfillment of the invoice (if available).", alias="dueAt")
+    period: Optional[Period] = Field(default=None, description="The period the invoice covers. If the invoice has no line items, it's not set.")
+    voided_at: Optional[datetime] = Field(default=None, description="The time the invoice was voided.  If the invoice was voided, this field will be set to the time the invoice was voided.", alias="voidedAt")
+    sent_to_customer_at: Optional[datetime] = Field(default=None, description="The time the invoice was sent to customer.", alias="sentToCustomerAt")
+    workflow: InvoiceWorkflowSettings = Field(description="The workflow associated with the invoice.  It is always a snapshot of the workflow settings at the time of invoice creation. The field is optional as it should be explicitly requested with expand options.")
+    lines: Optional[List[InvoiceLine]] = Field(default=None, description="List of invoice lines representing each of the items sold to the customer.")
+    payment: Optional[InvoicePaymentTerms] = Field(default=None, description="Information on when, how, and to whom the invoice should be paid.")
+    validation_issues: Optional[List[ValidationIssue]] = Field(default=None, description="Validation issues reported by the invoice workflow.", alias="validationIssues")
+    external_ids: Optional[InvoiceAppExternalIds] = Field(default=None, description="External IDs of the invoice in other apps such as Stripe.", alias="externalIds")
+    __properties: ClassVar[List[str]] = ["id", "description", "metadata", "createdAt", "updatedAt", "deletedAt", "type", "supplier", "customer", "number", "currency", "preceding", "totals", "status", "statusDetails", "issuedAt", "draftUntil", "quantitySnapshotedAt", "collectionAt", "dueAt", "period", "voidedAt", "sentToCustomerAt", "workflow", "lines", "payment", "validationIssues", "externalIds"]
+
+    @field_validator('id')
+    def id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$", value):
+            raise ValueError(r"must validate the regular expression /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/")
+        return value
+
+    @field_validator('currency')
+    def currency_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[A-Z]{3}$", value):
+            raise ValueError(r"must validate the regular expression /^[A-Z]{3}$/")
+        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 Invoice 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.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "id",
+            "created_at",
+            "updated_at",
+            "deleted_at",
+            "type",
+            "number",
+            "totals",
+            "status",
+            "status_details",
+            "issued_at",
+            "quantity_snapshoted_at",
+            "collection_at",
+            "due_at",
+            "voided_at",
+            "sent_to_customer_at",
+            "payment",
+            "external_ids",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of supplier
+        if self.supplier:
+            _dict['supplier'] = self.supplier.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of customer
+        if self.customer:
+            _dict['customer'] = self.customer.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in preceding (list)
+        _items = []
+        if self.preceding:
+            for _item_preceding in self.preceding:
+                if _item_preceding:
+                    _items.append(_item_preceding.to_dict())
+            _dict['preceding'] = _items
+        # override the default output from pydantic by calling `to_dict()` of totals
+        if self.totals:
+            _dict['totals'] = self.totals.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of status_details
+        if self.status_details:
+            _dict['statusDetails'] = self.status_details.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of period
+        if self.period:
+            _dict['period'] = self.period.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of workflow
+        if self.workflow:
+            _dict['workflow'] = self.workflow.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in lines (list)
+        _items = []
+        if self.lines:
+            for _item_lines in self.lines:
+                if _item_lines:
+                    _items.append(_item_lines.to_dict())
+            _dict['lines'] = _items
+        # override the default output from pydantic by calling `to_dict()` of payment
+        if self.payment:
+            _dict['payment'] = self.payment.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in validation_issues (list)
+        _items = []
+        if self.validation_issues:
+            for _item_validation_issues in self.validation_issues:
+                if _item_validation_issues:
+                    _items.append(_item_validation_issues.to_dict())
+            _dict['validationIssues'] = _items
+        # override the default output from pydantic by calling `to_dict()` of external_ids
+        if self.external_ids:
+            _dict['externalIds'] = self.external_ids.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Invoice from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "description": obj.get("description"),
+            "metadata": obj.get("metadata"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt"),
+            "deletedAt": obj.get("deletedAt"),
+            "type": obj.get("type"),
+            "supplier": BillingParty.from_dict(obj["supplier"]) if obj.get("supplier") is not None else None,
+            "customer": BillingInvoiceCustomerExtendedDetails.from_dict(obj["customer"]) if obj.get("customer") is not None else None,
+            "number": obj.get("number"),
+            "currency": obj.get("currency"),
+            "preceding": [CreditNoteOriginalInvoiceRef.from_dict(_item) for _item in obj["preceding"]] if obj.get("preceding") is not None else None,
+            "totals": InvoiceTotals.from_dict(obj["totals"]) if obj.get("totals") is not None else None,
+            "status": obj.get("status"),
+            "statusDetails": InvoiceStatusDetails.from_dict(obj["statusDetails"]) if obj.get("statusDetails") is not None else None,
+            "issuedAt": obj.get("issuedAt"),
+            "draftUntil": obj.get("draftUntil"),
+            "quantitySnapshotedAt": obj.get("quantitySnapshotedAt"),
+            "collectionAt": obj.get("collectionAt"),
+            "dueAt": obj.get("dueAt"),
+            "period": Period.from_dict(obj["period"]) if obj.get("period") is not None else None,
+            "voidedAt": obj.get("voidedAt"),
+            "sentToCustomerAt": obj.get("sentToCustomerAt"),
+            "workflow": InvoiceWorkflowSettings.from_dict(obj["workflow"]) if obj.get("workflow") is not None else None,
+            "lines": [InvoiceLine.from_dict(_item) for _item in obj["lines"]] if obj.get("lines") is not None else None,
+            "payment": InvoicePaymentTerms.from_dict(obj["payment"]) if obj.get("payment") is not None else None,
+            "validationIssues": [ValidationIssue.from_dict(_item) for _item in obj["validationIssues"]] if obj.get("validationIssues") is not None else None,
+            "externalIds": InvoiceAppExternalIds.from_dict(obj["externalIds"]) if obj.get("externalIds") is not None else None
+        })
+        return _obj
+
+