moolabs 0.3.0__py3-none-any.whl

moolabs/models/invoice_pending_line_create_response.py

@@ -0,0 +1,107 @@
+# 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, StrictBool
+from typing import Any, ClassVar, Dict, List
+from moolabs.models.invoice import Invoice
+from moolabs.models.invoice_line import InvoiceLine
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvoicePendingLineCreateResponse(BaseModel):
+    """
+    InvoicePendingLineCreateResponse represents the response from the create pending line endpoint.
+    """ # noqa: E501
+    lines: List[InvoiceLine] = Field(description="The lines that were created.")
+    invoice: Invoice = Field(description="The invoice containing the created lines.")
+    is_invoice_new: StrictBool = Field(description="Whether the invoice was newly created.", alias="isInvoiceNew")
+    __properties: ClassVar[List[str]] = ["lines", "invoice", "isInvoiceNew"]
+
+    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 InvoicePendingLineCreateResponse 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.
+        """
+        excluded_fields: Set[str] = set([
+            "invoice",
+            "is_invoice_new",
+        ])
+
+        _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 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 invoice
+        if self.invoice:
+            _dict['invoice'] = self.invoice.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvoicePendingLineCreateResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "lines": [InvoiceLine.from_dict(_item) for _item in obj["lines"]] if obj.get("lines") is not None else None,
+            "invoice": Invoice.from_dict(obj["invoice"]) if obj.get("invoice") is not None else None,
+            "isInvoiceNew": obj.get("isInvoiceNew")
+        })
+        return _obj
+
+

moolabs/models/invoice_pending_lines_action_filters_input.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvoicePendingLinesActionFiltersInput(BaseModel):
+    """
+    InvoicePendingLinesActionFiltersInput specifies which lines to include in the invoice.
+    """ # noqa: E501
+    line_ids: Optional[List[Annotated[str, Field(strict=True)]]] = Field(default=None, description="The pending line items to include in the invoice, if not provided: - all line items that have invoice_at < asOf will be included - [progressive billing only] all usage based line items will be included up to asOf, new usage-based line items will be staged for the rest of the billing cycle  All lineIDs present in the list, must exists and must be invoicable as of asOf, or the action will fail.", alias="lineIds")
+    __properties: ClassVar[List[str]] = ["lineIds"]
+
+    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 InvoicePendingLinesActionFiltersInput 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 InvoicePendingLinesActionFiltersInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "lineIds": obj.get("lineIds")
+        })
+        return _obj
+
+

moolabs/models/invoice_pending_lines_action_input.py

@@ -0,0 +1,106 @@
+# 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, StrictBool, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from moolabs.models.invoice_pending_lines_action_filters_input import InvoicePendingLinesActionFiltersInput
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvoicePendingLinesActionInput(BaseModel):
+    """
+    BillingInvoiceActionInput is the input for creating an invoice.  Invoice creation is always based on already pending line items created by the billingCreateLineByCustomer operation. Empty invoices are not allowed.
+    """ # noqa: E501
+    filters: Optional[InvoicePendingLinesActionFiltersInput] = Field(default=None, description="Filters to apply when creating the invoice.")
+    as_of: Optional[datetime] = Field(default=None, description="The time as of which the invoice is created.  If not provided, the current time is used.", alias="asOf")
+    customer_id: Annotated[str, Field(strict=True)] = Field(description="The customer ID for which to create the invoice.", alias="customerId")
+    progressive_billing_override: Optional[StrictBool] = Field(default=None, description="Override the progressive billing setting of the customer.  Can be used to disable/enable progressive billing in case the business logic requires it, if not provided the billing profile's progressive billing setting will be used.", alias="progressiveBillingOverride")
+    __properties: ClassVar[List[str]] = ["filters", "asOf", "customerId", "progressiveBillingOverride"]
+
+    @field_validator('customer_id')
+    def customer_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
+
+    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 InvoicePendingLinesActionInput 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 filters
+        if self.filters:
+            _dict['filters'] = self.filters.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvoicePendingLinesActionInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "filters": InvoicePendingLinesActionFiltersInput.from_dict(obj["filters"]) if obj.get("filters") is not None else None,
+            "asOf": obj.get("asOf"),
+            "customerId": obj.get("customerId"),
+            "progressiveBillingOverride": obj.get("progressiveBillingOverride")
+        })
+        return _obj
+
+

moolabs/models/invoice_reference.py

@@ -0,0 +1,101 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvoiceReference(BaseModel):
+    """
+    Reference to an invoice.
+    """ # noqa: E501
+    id: Annotated[str, Field(strict=True)] = Field(description="The ID of the invoice.")
+    number: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=256)]] = Field(default=None, description="The number of the invoice.")
+    __properties: ClassVar[List[str]] = ["id", "number"]
+
+    @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
+
+    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 InvoiceReference 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.
+        """
+        excluded_fields: Set[str] = set([
+            "id",
+            "number",
+        ])
+
+        _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 InvoiceReference 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"),
+            "number": obj.get("number")
+        })
+        return _obj
+
+

moolabs/models/invoice_replace_update.py

@@ -0,0 +1,117 @@
+# 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 moolabs.models.billing_party_replace_update import BillingPartyReplaceUpdate
+from moolabs.models.invoice_line_replace_update import InvoiceLineReplaceUpdate
+from moolabs.models.invoice_workflow_replace_update import InvoiceWorkflowReplaceUpdate
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvoiceReplaceUpdate(BaseModel):
+    """
+    InvoiceReplaceUpdate represents the update model for an invoice.
+    """ # noqa: E501
+    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.")
+    supplier: BillingPartyReplaceUpdate = Field(description="The supplier of the lines included in the invoice.")
+    customer: BillingPartyReplaceUpdate = Field(description="The customer the invoice is sent to.")
+    lines: List[InvoiceLineReplaceUpdate] = Field(description="The lines included in the invoice.")
+    workflow: InvoiceWorkflowReplaceUpdate = Field(description="The workflow settings for the invoice.")
+    __properties: ClassVar[List[str]] = ["description", "metadata", "supplier", "customer", "lines", "workflow"]
+
+    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 InvoiceReplaceUpdate 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 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 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 workflow
+        if self.workflow:
+            _dict['workflow'] = self.workflow.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvoiceReplaceUpdate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "description": obj.get("description"),
+            "metadata": obj.get("metadata"),
+            "supplier": BillingPartyReplaceUpdate.from_dict(obj["supplier"]) if obj.get("supplier") is not None else None,
+            "customer": BillingPartyReplaceUpdate.from_dict(obj["customer"]) if obj.get("customer") is not None else None,
+            "lines": [InvoiceLineReplaceUpdate.from_dict(_item) for _item in obj["lines"]] if obj.get("lines") is not None else None,
+            "workflow": InvoiceWorkflowReplaceUpdate.from_dict(obj["workflow"]) if obj.get("workflow") is not None else None
+        })
+        return _obj
+
+

moolabs/models/invoice_simulation_input.py

@@ -0,0 +1,107 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from moolabs.models.invoice_simulation_line import InvoiceSimulationLine
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvoiceSimulationInput(BaseModel):
+    """
+    InvoiceSimulationInput is the input for simulating an invoice.
+    """ # noqa: E501
+    number: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=256)]] = Field(default=None, description="The number of the invoice.")
+    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.")
+    lines: List[InvoiceSimulationLine] = Field(description="Lines to be included in the generated invoice.")
+    __properties: ClassVar[List[str]] = ["number", "currency", "lines"]
+
+    @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 InvoiceSimulationInput 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 lines (list)
+        _items = []
+        if self.lines:
+            for _item_lines in self.lines:
+                if _item_lines:
+                    _items.append(_item_lines.to_dict())
+            _dict['lines'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvoiceSimulationInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "number": obj.get("number"),
+            "currency": obj.get("currency"),
+            "lines": [InvoiceSimulationLine.from_dict(_item) for _item in obj["lines"]] if obj.get("lines") is not None else None
+        })
+        return _obj
+
+