lago-python-client 1.43.0__tar.gz → 1.45.0__tar.gz

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lago-python-client
-Version: 1.43.0
+Version: 1.45.0
 Summary: Lago Python API Client
 Home-page: https://github.com/getlago/lago-python-client
 Author: Lovro Colic

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/customers/clients.py

@@ -1,7 +1,9 @@
+import json
 from collections.abc import Mapping
-from typing import Any, ClassVar, Optional, Type
+from typing import Any, ClassVar, Optional, Type, Union
 
 from ..base_client import BaseClient
+from ..functools_ext import callable_cached_property
 from ..mixins import (
     CreateCommandMixin,
     DestroyCommandMixin,
@@ -18,6 +20,7 @@ from ..services.response import (
     prepare_index_response,
     prepare_object_response,
 )
+from .wallet_client import CustomerWalletClient
 
 
 class CustomerClient(
@@ -31,12 +34,31 @@ class CustomerClient(
     RESPONSE_MODEL: ClassVar[Type[CustomerResponse]] = CustomerResponse
     ROOT_NAME: ClassVar[str] = "customer"
 
+    @callable_cached_property
+    def wallets(self) -> CustomerWalletClient:
+        return CustomerWalletClient(self.base_url, self.api_key)
+
     def current_usage(
-        self, resource_id: str, external_subscription_id: str, apply_taxes: Optional[str] = None
+        self,
+        resource_id: str,
+        external_subscription_id: str,
+        apply_taxes: Optional[str] = None,
+        filter_by_charge_id: Optional[str] = None,
+        filter_by_charge_code: Optional[str] = None,
+        filter_by_group: Optional[dict] = None,
+        full_usage: Optional[bool] = None,
     ) -> CustomerUsageResponse:
-        query_params = {"external_subscription_id": external_subscription_id}
+        query_params: dict[str, Union[str, bool]] = {"external_subscription_id": external_subscription_id}
         if apply_taxes is not None:
             query_params["apply_taxes"] = apply_taxes
+        if filter_by_charge_id is not None:
+            query_params["filter_by_charge_id"] = filter_by_charge_id
+        if filter_by_charge_code is not None:
+            query_params["filter_by_charge_code"] = filter_by_charge_code
+        if filter_by_group is not None:
+            query_params["filter_by_group"] = json.dumps(filter_by_group)
+        if full_usage is not None:
+            query_params["full_usage"] = str(full_usage).lower()
 
         api_response: Response = send_get_request(
             url=make_url(

lago_python_client-1.45.0/lago_python_client/customers/wallet_client.py

@@ -0,0 +1,42 @@
+from typing import ClassVar, Type
+
+from ..base_client import BaseClient
+from ..functools_ext import callable_cached_property
+from ..mixins import (
+    NestedCreateCommandMixin,
+    NestedDestroyCommandMixin,
+    NestedFindAllCommandMixin,
+    NestedFindCommandMixin,
+    NestedUpdateCommandMixin,
+)
+from ..models.wallet import WalletResponse
+from .wallets.alert_client import CustomerWalletAlertClient
+from .wallets.metadata_client import CustomerWalletMetadataClient
+
+
+class CustomerWalletClient(
+    NestedCreateCommandMixin[WalletResponse],
+    NestedUpdateCommandMixin[WalletResponse],
+    NestedDestroyCommandMixin[WalletResponse],
+    NestedFindCommandMixin[WalletResponse],
+    NestedFindAllCommandMixin[WalletResponse],
+    BaseClient,
+):
+    API_RESOURCE: ClassVar[str] = "wallets"
+    RESPONSE_MODEL: ClassVar[Type[WalletResponse]] = WalletResponse
+    ROOT_NAME: ClassVar[str] = "wallet"
+
+    def api_resource(self, customer_id: str) -> tuple[str]:
+        return (
+            "customers",
+            customer_id,
+            "wallets",
+        )
+
+    @callable_cached_property
+    def metadata(self) -> CustomerWalletMetadataClient:
+        return CustomerWalletMetadataClient(self.base_url, self.api_key)
+
+    @callable_cached_property
+    def alerts(self) -> CustomerWalletAlertClient:
+        return CustomerWalletAlertClient(self.base_url, self.api_key)

lago_python_client-1.45.0/lago_python_client/customers/wallets/alert_client.py

@@ -0,0 +1,64 @@
+from typing import ClassVar, Type
+
+from ...base_client import BaseClient
+from ...mixins import (
+    NestedCreateCommandMixin,
+    NestedDestroyCommandMixin,
+    NestedFindAllCommandMixin,
+    NestedFindCommandMixin,
+    NestedUpdateCommandMixin,
+)
+from ...models.alert import AlertResponse, AlertsList
+from ...services.json import to_json
+from ...services.request import (
+    make_headers,
+    make_url,
+    send_delete_request,
+    send_post_request,
+)
+from ...services.response import (
+    Response,
+    get_response_data,
+    prepare_index_response,
+    verify_response,
+)
+
+
+class CustomerWalletAlertClient(
+    NestedCreateCommandMixin[AlertResponse],
+    NestedUpdateCommandMixin[AlertResponse],
+    NestedDestroyCommandMixin[AlertResponse],
+    NestedFindCommandMixin[AlertResponse],
+    NestedFindAllCommandMixin[AlertResponse],
+    BaseClient,
+):
+    API_RESOURCE: ClassVar[str] = "alerts"
+    RESPONSE_MODEL: ClassVar[Type[AlertResponse]] = AlertResponse
+    ROOT_NAME: ClassVar[str] = "alert"
+
+    def api_resource(self, customer_id: str, wallet_code: str) -> tuple[str]:
+        return ("customers", customer_id, "wallets", wallet_code, "alerts")
+
+    def create_batch(self, customer_id: str, wallet_code: str, input_object: AlertsList) -> None:
+        api_response: Response = send_post_request(
+            url=make_url(origin=self.base_url, path_parts=self.api_resource(customer_id, wallet_code)),
+            content=to_json(input_object.dict()),
+            headers=make_headers(api_key=self.api_key),
+        )
+
+        return prepare_index_response(
+            api_resource="alerts",
+            response_model=AlertResponse,
+            data=get_response_data(response=api_response),
+        )
+
+    def destroy_all(self, customer_id: str, wallet_code: str) -> None:
+        api_response: Response = send_delete_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(customer_id, wallet_code),
+            ),
+            headers=make_headers(api_key=self.api_key),
+        )
+
+        verify_response(api_response)

lago_python_client-1.45.0/lago_python_client/customers/wallets/metadata_client.py

@@ -0,0 +1,74 @@
+from typing import ClassVar, Dict, Optional
+
+from ...base_client import BaseClient
+from ...services.json import to_json
+from ...services.request import (
+    make_headers,
+    make_url,
+    send_delete_request,
+    send_patch_request,
+    send_post_request,
+)
+from ...services.response import (
+    Response,
+    get_response_data,
+)
+
+
+class CustomerWalletMetadataClient(BaseClient):
+    API_RESOURCE: ClassVar[str] = "metadata"
+    RESPONSE_MODEL: ClassVar[Dict] = Dict[str, Optional[str]]
+    ROOT_NAME: ClassVar[str] = "metadata"
+
+    def api_resource(self, customer_id: str, wallet_code: str) -> tuple:
+        return ("customers", customer_id, "wallets", wallet_code, "metadata")
+
+    def replace(
+        self, customer_id: str, wallet_code: str, metadata: Dict[str, Optional[str]]
+    ) -> Optional[Dict[str, Optional[str]]]:
+        api_response: Response = send_post_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(customer_id, wallet_code),
+            ),
+            content=to_json({"metadata": metadata}),
+            headers=make_headers(api_key=self.api_key),
+        )
+
+        return get_response_data(response=api_response, key="metadata")
+
+    def merge(
+        self, customer_id: str, wallet_code: str, metadata: Dict[str, Optional[str]]
+    ) -> Optional[Dict[str, Optional[str]]]:
+        api_response: Response = send_patch_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(customer_id, wallet_code),
+            ),
+            content=to_json({"metadata": metadata}),
+            headers=make_headers(api_key=self.api_key),
+        )
+
+        return get_response_data(response=api_response, key="metadata")
+
+    def delete_all(self, customer_id: str, wallet_code: str) -> Optional[Dict[str, Optional[str]]]:
+        api_response: Response = send_delete_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(customer_id, wallet_code),
+            ),
+            headers=make_headers(api_key=self.api_key),
+        )
+
+        return get_response_data(response=api_response, key="metadata")
+
+    def delete_key(self, customer_id: str, wallet_code: str, key: str) -> Optional[Dict[str, Optional[str]]]:
+        api_response: Response = send_delete_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(customer_id, wallet_code) + (key,),
+            ),
+            headers=make_headers(api_key=self.api_key),
+        )
+
+        return get_response_data(response=api_response, key="metadata")

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/customers/wallets_client.py

@@ -1,9 +1,9 @@
 from typing import ClassVar, Type
 
 from ..base_client import BaseClient
+from ..client import CustomerClient
 from ..mixins import FindAllChildrenCommandMixin
 from ..models.wallet import WalletResponse
-from .clients import CustomerClient
 
 
 class CustomerWalletsClient(FindAllChildrenCommandMixin, BaseClient):

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/mixins.py

@@ -1,4 +1,4 @@
-from typing import Any, Generic, Optional, Type, TypeVar
+from typing import Any, Generic, Optional, Type, TypeVar, Union
 
 import httpx
 
@@ -31,6 +31,8 @@ from .services.response import (
 _PM_co = TypeVar("_PM_co", covariant=True)
 _M = TypeVar("_M", bound=BaseModel)
 
+DEFAULT_TIMEOUT = httpx.Timeout(10.0)
+
 
 class _ClientMixin(Protocol[_PM_co]):
     @property
@@ -53,7 +55,7 @@ class CreateCommandMixin(Generic[_M]):
     def create(
         self: _ClientMixin[_M],
         input_object: BaseModel,
-        timeout: Optional[httpx.Timeout] = None,
+        timeout: Optional[httpx.Timeout] = DEFAULT_TIMEOUT,
     ) -> Optional[_M]:
         """Execute `create` command."""
         # Send request and save response
@@ -89,7 +91,7 @@ class DestroyCommandMixin(Generic[_M]):
         self: _ClientMixin[_M],
         resource_id: str,
         options: QueryPairs = None,
-        timeout: Optional[httpx.Timeout] = None,
+        timeout: Optional[httpx.Timeout] = DEFAULT_TIMEOUT,
     ) -> BaseModel:
         """Execute `destroy` command."""
         # Send request and save response
@@ -118,7 +120,7 @@ class FindAllCommandMixin(Generic[_M]):
     def find_all(
         self: _ClientMixin[_M],
         options: QueryPairs = None,
-        timeout: Optional[httpx.Timeout] = None,
+        timeout: Optional[httpx.Timeout] = DEFAULT_TIMEOUT,
     ) -> Mapping[str, Any]:
         """Execute `find all` command."""
         # Send request and save response
@@ -181,8 +183,11 @@ class FindChildCommandMixin(Generic[_M]):
         self: _ClientMixin[_M],
         parent_id: str,
         child_id: str,
+        options: QueryPairs = None,
     ) -> _M:
         """Execute `find` child command."""
+        if options is None:
+            options = {}
         api_response: Response = send_get_request(
             url=make_url(
                 origin=self.base_url,
@@ -192,6 +197,7 @@ class FindChildCommandMixin(Generic[_M]):
                     self.API_RESOURCE,
                     child_id,
                 ),
+                query_pairs=options,
             ),
             headers=make_headers(api_key=self.api_key),
         )
@@ -209,8 +215,11 @@ class CreateChildCommandMixin(Generic[_M]):
         self: _ClientMixin[_M],
         parent_id: str,
         input_object: BaseModel,
+        options: QueryPairs = None,
     ) -> _M:
         """Execute `create` child command."""
+        if options is None:
+            options = {}
         api_response: Response = send_post_request(
             url=make_url(
                 origin=self.base_url,
@@ -219,6 +228,7 @@ class CreateChildCommandMixin(Generic[_M]):
                     parent_id,
                     self.API_RESOURCE,
                 ),
+                query_pairs=options,
             ),
             content=to_json({self.ROOT_NAME: input_object.dict(exclude_none=True)}),
             headers=make_headers(api_key=self.api_key),
@@ -238,8 +248,11 @@ class UpdateChildCommandMixin(Generic[_M]):
         parent_id: str,
         child_id: str,
         input_object: BaseModel,
+        options: QueryPairs = None,
     ) -> _M:
         """Execute `update` child command."""
+        if options is None:
+            options = {}
         api_response: Response = send_put_request(
             url=make_url(
                 origin=self.base_url,
@@ -249,6 +262,7 @@ class UpdateChildCommandMixin(Generic[_M]):
                     self.API_RESOURCE,
                     child_id,
                 ),
+                query_pairs=options,
             ),
             content=to_json({self.ROOT_NAME: input_object.dict(exclude_none=True)}),
             headers=make_headers(api_key=self.api_key),
@@ -267,8 +281,11 @@ class DestroyChildCommandMixin(Generic[_M]):
         self: _ClientMixin[_M],
         parent_id: str,
         child_id: str,
+        options: QueryPairs = None,
     ) -> _M:
         """Execute `destroy` child command."""
+        if options is None:
+            options = {}
         api_response: Response = send_delete_request(
             url=make_url(
                 origin=self.base_url,
@@ -278,6 +295,7 @@ class DestroyChildCommandMixin(Generic[_M]):
                     self.API_RESOURCE,
                     child_id,
                 ),
+                query_pairs=options,
             ),
             headers=make_headers(api_key=self.api_key),
         )
@@ -295,7 +313,7 @@ class FindCommandMixin(Generic[_M]):
         self: _ClientMixin[_M],
         resource_id: str,
         params: QueryPairs = None,
-        timeout: Optional[httpx.Timeout] = None,
+        timeout: Optional[httpx.Timeout] = DEFAULT_TIMEOUT,
     ) -> _M:
         """Execute `find` command."""
         # Send request and save response
@@ -325,7 +343,7 @@ class UpdateCommandMixin(Generic[_M]):
         self: _ClientMixin[_M],
         input_object: BaseModel,
         identifier: Optional[str] = None,
-        timeout: Optional[httpx.Timeout] = None,
+        timeout: Optional[httpx.Timeout] = DEFAULT_TIMEOUT,
     ) -> _M:
         """Execute `update` command."""
         # Send request and save response
@@ -348,3 +366,155 @@ class UpdateCommandMixin(Generic[_M]):
             response_model=self.RESPONSE_MODEL,
             data=get_response_data(response=api_response, key=self.ROOT_NAME),
         )
+
+
+class NestedCreateCommandMixin(Generic[_M]):
+    """Client mixin with `create` command."""
+
+    def create(
+        self: _ClientMixin[_M],
+        *args: Union[str, BaseModel],
+        timeout: Optional[httpx.Timeout] = None,
+    ) -> Optional[_M]:
+        """Execute `create` command."""
+        *parent_ids, input_object = args
+
+        # Send request and save response
+        api_response: Response = send_post_request(
+            url=make_url(origin=self.base_url, path_parts=self.api_resource(*parent_ids)),
+            content=to_json(
+                {
+                    self.ROOT_NAME: input_object.dict(exclude_none=True),
+                }
+            ),
+            headers=make_headers(api_key=self.api_key),
+            timeout=timeout,
+        )
+
+        # Process response data
+        response_data = get_response_data(response=api_response, key=self.ROOT_NAME)
+        if not response_data:
+            return None
+
+        return prepare_object_response(
+            response_model=self.RESPONSE_MODEL,
+            data=response_data,
+        )
+
+
+class NestedUpdateCommandMixin(Generic[_M]):
+    """Client mixin with `update` command."""
+
+    def update(
+        self: _ClientMixin[_M],
+        *args: Union[str, BaseModel],
+        timeout: Optional[httpx.Timeout] = None,
+    ) -> _M:
+        """Execute `update` command."""
+        *parent_ids, resource_id, input_object = args
+
+        # Send request and save response
+        api_response: Response = send_put_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(*parent_ids) + (resource_id,),
+            ),
+            content=to_json(
+                {
+                    self.ROOT_NAME: input_object.dict(exclude_none=True),
+                }
+            ),
+            headers=make_headers(api_key=self.api_key),
+            timeout=timeout,
+        )
+
+        # Process response data
+        return prepare_object_response(
+            response_model=self.RESPONSE_MODEL,
+            data=get_response_data(response=api_response, key=self.ROOT_NAME),
+        )
+
+
+class NestedDestroyCommandMixin(Generic[_M]):
+    """Client mixin with `destroy` command."""
+
+    def destroy(
+        self: _ClientMixin[_M],
+        *args: str,
+        timeout: Optional[httpx.Timeout] = None,
+    ) -> BaseModel:
+        """Execute `destroy` command."""
+        *parent_ids, resource_id = args
+
+        # Send request and save response
+        api_response: Response = send_delete_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(*parent_ids) + (resource_id,),
+            ),
+            headers=make_headers(api_key=self.api_key),
+            timeout=timeout,
+        )
+
+        # Process response data
+        return prepare_object_response(
+            response_model=self.RESPONSE_MODEL,
+            data=get_response_data(response=api_response, key=self.ROOT_NAME),
+        )
+
+
+class NestedFindCommandMixin(Generic[_M]):
+    """Client mixin with `find` command."""
+
+    def find(
+        self: _ClientMixin[_M],
+        *args: str,
+        timeout: Optional[httpx.Timeout] = None,
+    ) -> _M:
+        """Execute `find` command."""
+        *parent_ids, resource_id = args
+
+        # Send request and save response
+        api_response: Response = send_get_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(*parent_ids) + (resource_id,),
+            ),
+            headers=make_headers(api_key=self.api_key),
+            timeout=timeout,
+        )
+
+        # Process response data
+        return prepare_object_response(
+            response_model=self.RESPONSE_MODEL,
+            data=get_response_data(response=api_response, key=self.ROOT_NAME),
+        )
+
+
+class NestedFindAllCommandMixin(Generic[_M]):
+    """Client mixin with `find_all` command."""
+
+    def find_all(
+        self: _ClientMixin[_M],
+        *parent_ids: str,
+        options: QueryPairs = None,
+        timeout: Optional[httpx.Timeout] = None,
+    ) -> Mapping[str, Any]:
+        """Execute `find all` command."""
+        # Send request and save response
+        api_response: Response = send_get_request(
+            url=make_url(
+                origin=self.base_url,
+                path_parts=self.api_resource(*parent_ids),
+                query_pairs=options,
+            ),
+            headers=make_headers(api_key=self.api_key),
+            timeout=timeout,
+        )
+
+        # Process response data
+        return prepare_index_response(
+            api_resource=self.API_RESOURCE,
+            response_model=self.RESPONSE_MODEL,
+            data=get_response_data(response=api_response),
+        )

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/__init__.py

@@ -189,6 +189,15 @@ from .invoice import (
 from .invoice import (
     OneOffInvoice as OneOffInvoice,
 )
+from .invoice_custom_section import (
+    AppliedInvoiceCustomSection as AppliedInvoiceCustomSection,
+)
+from .invoice_custom_section import (
+    AppliedInvoiceCustomSections as AppliedInvoiceCustomSections,
+)
+from .invoice_custom_section import (
+    InvoiceCustomSectionInput as InvoiceCustomSectionInput,
+)
 from .invoice_custom_section import (
     InvoiceCustomSectionResponse as InvoiceCustomSectionResponse,
 )

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/alert.py

@@ -15,11 +15,11 @@ class AlertThresholdList(BaseModel):
 
 
 class Alert(BaseModel):
-    alert_type: str
-    code: str
+    alert_type: Optional[str]
+    code: Optional[str]
     name: Optional[str]
+    thresholds: Optional[AlertThresholdList]
     billable_metric_code: Optional[str]
-    thresholds: AlertThresholdList
 
 
 class AlertsList(BaseModel):
@@ -39,10 +39,13 @@ class AlertThresholdResponseList(BaseResponseModel):
 class AlertResponse(BaseResponseModel):
     lago_id: str
     lago_organization_id: str
-    external_subscription_id: str
+    external_subscription_id: Optional[str]
+    lago_wallet_id: Optional[str]
+    wallet_code: Optional[str]
     alert_type: str
     code: str
     name: Optional[str]
+    direction: Optional[str]
     previous_value: Optional[str]
     last_processed_at: Optional[str]
     thresholds: AlertThresholdResponseList

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/customer.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from lago_python_client.base_model import BaseModel
 
 from ..base_model import BaseResponseModel
+from .error_detail import ErrorDetailsResponse
 from .invoice_custom_section import InvoiceCustomSectionsResponseList
 from .tax import TaxesResponse
 
@@ -145,3 +146,4 @@ class CustomerResponse(BaseResponseModel):
     skip_invoice_custom_sections: Optional[bool]
     applicable_invoice_custom_sections: Optional[InvoiceCustomSectionsResponseList]
     billing_entity_code: Optional[str]
+    error_details: Optional[ErrorDetailsResponse]

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/error_detail.py

@@ -6,7 +6,7 @@ from ..base_model import BaseResponseModel
 
 
 class ErrorDetailResponse(BaseModel):
-    organization_id: str
+    lago_id: str
     error_code: str
     details: Optional[Dict[str, Any]]
 

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/invoice.py

@@ -9,6 +9,7 @@ from .credit import CreditsResponse
 from .customer import Customer, CustomerResponse
 from .error_detail import ErrorDetailsResponse
 from .fee import FeesResponse
+from .invoice_custom_section import InvoiceCustomSectionInput
 from .payment_method import PaymentMethod
 from .subscription import Subscriptions, SubscriptionsResponse
 from .usage_threshold import UsageThreshold
@@ -55,6 +56,7 @@ class OneOffInvoice(BaseModel):
     fees: Optional[InvoiceFeesList]
     error_details: Optional[ErrorDetailsResponse]
     payment_method: Optional[PaymentMethod]
+    invoice_custom_section: Optional[InvoiceCustomSectionInput]
 
 
 class InvoicePreview(BaseModel):
@@ -131,6 +133,8 @@ class InvoiceResponse(BaseResponseModel):
     total_amount_cents: int
     total_due_amount_cents: int
     prepaid_credit_amount_cents: int
+    prepaid_granted_credit_amount_cents: Optional[int]
+    prepaid_purchased_credit_amount_cents: Optional[int]
 
     file_url: Optional[str]
     customer: Optional[CustomerResponse]

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/invoice_custom_section.py

@@ -1,8 +1,25 @@
 from typing import List, Optional
 
+from lago_python_client.base_model import BaseModel
+
 from ..base_model import BaseResponseModel
 
 
+class InvoiceCustomSectionInput(BaseModel):
+    skip_invoice_custom_sections: Optional[bool]
+    invoice_custom_section_codes: Optional[List[str]]
+
+
+class AppliedInvoiceCustomSection(BaseResponseModel):
+    lago_id: Optional[str]
+    invoice_custom_section_id: Optional[str]
+    created_at: Optional[str]
+
+
+class AppliedInvoiceCustomSections(BaseResponseModel):
+    __root__: List[AppliedInvoiceCustomSection]
+
+
 class InvoiceCustomSectionResponse(BaseResponseModel):
     lago_id: Optional[str]
     code: Optional[str]

{lago_python_client-1.43.0 → lago_python_client-1.45.0}/lago_python_client/models/payment.py

@@ -13,6 +13,7 @@ class Payment(BaseModel):
 class PaymentResponse(BaseResponseModel):
     lago_id: str
     invoice_ids: List[str]
+    invoice_numbers: List[str]
     amount_cents: int
     amount_currency: str
     payment_status: str