pluggy-sdk 1.0.0.post13__py3-none-any.whl → 1.0.0.post15__py3-none-any.whl

pluggy_sdk/models/benefit_response.py

@@ -20,8 +20,8 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional, Union
+from pluggy_sdk.models.benefit_loan import BenefitLoan
 from pluggy_sdk.models.benefit_response_paying_institution import BenefitResponsePayingInstitution
-from pluggy_sdk.models.payroll_loan import PayrollLoan
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -34,12 +34,12 @@ class BenefitResponse(BaseModel):
     beneficiary_name: StrictStr = Field(description="Beneficiary name", alias="beneficiaryName")
     available_margin_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Available margin value", alias="availableMarginValue")
     margin_base_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Base margin value", alias="marginBaseValue")
-    payroll_deductible_available_margin_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Payroll deductible available margin value", alias="payrollDeductibleAvailableMarginValue")
+    deductible_available_margin_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Deductible available margin value", alias="deductibleAvailableMarginValue")
     used_margin_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Used margin value", alias="usedMarginValue")
     reserved_margin_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Reserved margin value", alias="reservedMarginValue")
     paying_institution: Optional[BenefitResponsePayingInstitution] = Field(default=None, alias="payingInstitution")
-    payroll_loans: Optional[List[PayrollLoan]] = Field(default=None, description="List of payroll loans", alias="payrollLoans")
-    __properties: ClassVar[List[str]] = ["id", "itemId", "beneficiaryName", "availableMarginValue", "marginBaseValue", "payrollDeductibleAvailableMarginValue", "usedMarginValue", "reservedMarginValue", "payingInstitution", "payrollLoans"]
+    loans: Optional[List[BenefitLoan]] = Field(default=None, description="List of benefit loans")
+    __properties: ClassVar[List[str]] = ["id", "itemId", "beneficiaryName", "availableMarginValue", "marginBaseValue", "deductibleAvailableMarginValue", "usedMarginValue", "reservedMarginValue", "payingInstitution", "loans"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -83,13 +83,13 @@ class BenefitResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of paying_institution
         if self.paying_institution:
             _dict['payingInstitution'] = self.paying_institution.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in payroll_loans (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in loans (list)
         _items = []
-        if self.payroll_loans:
-            for _item in self.payroll_loans:
+        if self.loans:
+            for _item in self.loans:
                 if _item:
                     _items.append(_item.to_dict())
-            _dict['payrollLoans'] = _items
+            _dict['loans'] = _items
         return _dict
 
     @classmethod
@@ -107,11 +107,11 @@ class BenefitResponse(BaseModel):
             "beneficiaryName": obj.get("beneficiaryName"),
             "availableMarginValue": obj.get("availableMarginValue"),
             "marginBaseValue": obj.get("marginBaseValue"),
-            "payrollDeductibleAvailableMarginValue": obj.get("payrollDeductibleAvailableMarginValue"),
+            "deductibleAvailableMarginValue": obj.get("deductibleAvailableMarginValue"),
             "usedMarginValue": obj.get("usedMarginValue"),
             "reservedMarginValue": obj.get("reservedMarginValue"),
             "payingInstitution": BenefitResponsePayingInstitution.from_dict(obj["payingInstitution"]) if obj.get("payingInstitution") is not None else None,
-            "payrollLoans": [PayrollLoan.from_dict(_item) for _item in obj["payrollLoans"]] if obj.get("payrollLoans") is not None else None
+            "loans": [BenefitLoan.from_dict(_item) for _item in obj["loans"]] if obj.get("loans") is not None else None
         })
         return _obj
 

pluggy_sdk/models/connector.py

@@ -45,7 +45,9 @@ class Connector(BaseModel):
     health: Optional[ConnectorHealth] = None
     is_open_finance: Optional[StrictBool] = Field(default=None, description="Indicates if the connector uses the regulated Open Finance APIs", alias="isOpenFinance")
     supports_payment_initiation: Optional[StrictBool] = Field(default=None, description="Indicates if the connector supports the payment initiation API", alias="supportsPaymentInitiation")
-    __properties: ClassVar[List[str]] = ["id", "name", "institutionUrl", "imageUrl", "primaryColor", "type", "country", "credentials", "hasMFA", "products", "oauth", "oauthUrl", "resetPasswordUrl", "health", "isOpenFinance", "supportsPaymentInitiation"]
+    supports_scheduled_payments: Optional[StrictBool] = Field(default=None, description="Indicates if the connector supports scheduled payments", alias="supportsScheduledPayments")
+    supports_smart_transfers: Optional[StrictBool] = Field(default=None, description="Indicates if the connector supports smart transfers", alias="supportsSmartTransfers")
+    __properties: ClassVar[List[str]] = ["id", "name", "institutionUrl", "imageUrl", "primaryColor", "type", "country", "credentials", "hasMFA", "products", "oauth", "oauthUrl", "resetPasswordUrl", "health", "isOpenFinance", "supportsPaymentInitiation", "supportsScheduledPayments", "supportsSmartTransfers"]
 
     @field_validator('products')
     def products_validate_enum(cls, value):
@@ -134,7 +136,9 @@ class Connector(BaseModel):
             "resetPasswordUrl": obj.get("resetPasswordUrl"),
             "health": ConnectorHealth.from_dict(obj["health"]) if obj.get("health") is not None else None,
             "isOpenFinance": obj.get("isOpenFinance"),
-            "supportsPaymentInitiation": obj.get("supportsPaymentInitiation")
+            "supportsPaymentInitiation": obj.get("supportsPaymentInitiation"),
+            "supportsScheduledPayments": obj.get("supportsScheduledPayments"),
+            "supportsSmartTransfers": obj.get("supportsSmartTransfers")
         })
         return _obj
 

pluggy_sdk/models/custom.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+    Pluggy API
+
+    Pluggy's main API to review data and execute connectors
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: hello@pluggy.ai
+    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 date
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CUSTOM(BaseModel):
+    """
+    Schedule atribute to generate custom payments in the future
+    """ # noqa: E501
+    type: StrictStr = Field(description="Scheduled type")
+    dates: List[date]
+    additional_information: Optional[StrictStr] = Field(default=None, description="Additional information about the custom schedule", alias="additionalInformation")
+    __properties: ClassVar[List[str]] = ["type", "dates", "additionalInformation"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['CUSTOM']):
+            raise ValueError("must be one of enum values ('CUSTOM')")
+        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 CUSTOM 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 CUSTOM from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "dates": obj.get("dates"),
+            "additionalInformation": obj.get("additionalInformation")
+        })
+        return _obj
+
+

pluggy_sdk/models/daily.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    Pluggy API
+
+    Pluggy's main API to review data and execute connectors
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: hello@pluggy.ai
+    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 date
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DAILY(BaseModel):
+    """
+    Schedule atribute to generate daily payments
+    """ # noqa: E501
+    type: StrictStr = Field(description="Scheduled type")
+    start_date: date = Field(description="The start date of the validity of the scheduled payment authorization.", alias="startDate")
+    occurrences: Optional[Union[Annotated[float, Field(le=59, strict=True, ge=3)], Annotated[int, Field(le=59, strict=True, ge=3)]]] = Field(default=None, description="Under the specified schedule frequency, how many payments will be scheduled to occur.")
+    __properties: ClassVar[List[str]] = ["type", "startDate", "occurrences"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['DAILY']):
+            raise ValueError("must be one of enum values ('DAILY')")
+        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 DAILY 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 DAILY from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "startDate": obj.get("startDate"),
+            "occurrences": obj.get("occurrences")
+        })
+        return _obj
+
+

pluggy_sdk/models/monthly.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+    Pluggy API
+
+    Pluggy's main API to review data and execute connectors
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: hello@pluggy.ai
+    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 date
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MONTHLY(BaseModel):
+    """
+    Schedule atribute to generate monthly payments
+    """ # noqa: E501
+    type: StrictStr = Field(description="Scheduled type")
+    start_date: date = Field(alias="startDate")
+    day_of_month: Union[Annotated[float, Field(le=30, strict=True, ge=2)], Annotated[int, Field(le=30, strict=True, ge=2)]] = Field(description="Day of the month on which each payment will occur. For example, if '10', the first payment will occur on the next 10th day of the month after the start date, or the same day if it is already 10th, and every 10th day after that.", alias="dayOfMonth")
+    occurrences: Optional[Union[Annotated[float, Field(le=23, strict=True, ge=3)], Annotated[int, Field(le=23, strict=True, ge=3)]]] = Field(default=None, description="Under the specified schedule frequency, how many payments will be scheduled to occur.")
+    __properties: ClassVar[List[str]] = ["type", "startDate", "dayOfMonth", "occurrences"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['MONTHLY']):
+            raise ValueError("must be one of enum values ('MONTHLY')")
+        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 MONTHLY 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 MONTHLY from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "startDate": obj.get("startDate"),
+            "dayOfMonth": obj.get("dayOfMonth"),
+            "occurrences": obj.get("occurrences")
+        })
+        return _obj
+
+

pluggy_sdk/models/payment_request_schedule.py

@@ -18,33 +18,33 @@ import json
 import pprint
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
 from typing import Any, List, Optional
-from pluggy_sdk.models.schedule_type_custom import ScheduleTypeCustom
-from pluggy_sdk.models.schedule_type_daily import ScheduleTypeDaily
-from pluggy_sdk.models.schedule_type_monthly import ScheduleTypeMonthly
-from pluggy_sdk.models.schedule_type_single import ScheduleTypeSingle
-from pluggy_sdk.models.schedule_type_weekly import ScheduleTypeWeekly
+from pluggy_sdk.models.custom import CUSTOM
+from pluggy_sdk.models.daily import DAILY
+from pluggy_sdk.models.monthly import MONTHLY
+from pluggy_sdk.models.single import SINGLE
+from pluggy_sdk.models.weekly import WEEKLY
 from pydantic import StrictStr, Field
 from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
-PAYMENTREQUESTSCHEDULE_ONE_OF_SCHEMAS = ["ScheduleTypeCustom", "ScheduleTypeDaily", "ScheduleTypeMonthly", "ScheduleTypeSingle", "ScheduleTypeWeekly"]
+PAYMENTREQUESTSCHEDULE_ONE_OF_SCHEMAS = ["CUSTOM", "DAILY", "MONTHLY", "SINGLE", "WEEKLY"]
 
 class PaymentRequestSchedule(BaseModel):
     """
     PaymentRequestSchedule
     """
-    # data type: ScheduleTypeSingle
-    oneof_schema_1_validator: Optional[ScheduleTypeSingle] = None
-    # data type: ScheduleTypeDaily
-    oneof_schema_2_validator: Optional[ScheduleTypeDaily] = None
-    # data type: ScheduleTypeWeekly
-    oneof_schema_3_validator: Optional[ScheduleTypeWeekly] = None
-    # data type: ScheduleTypeMonthly
-    oneof_schema_4_validator: Optional[ScheduleTypeMonthly] = None
-    # data type: ScheduleTypeCustom
-    oneof_schema_5_validator: Optional[ScheduleTypeCustom] = None
-    actual_instance: Optional[Union[ScheduleTypeCustom, ScheduleTypeDaily, ScheduleTypeMonthly, ScheduleTypeSingle, ScheduleTypeWeekly]] = None
-    one_of_schemas: Set[str] = { "ScheduleTypeCustom", "ScheduleTypeDaily", "ScheduleTypeMonthly", "ScheduleTypeSingle", "ScheduleTypeWeekly" }
+    # data type: SINGLE
+    oneof_schema_1_validator: Optional[SINGLE] = None
+    # data type: DAILY
+    oneof_schema_2_validator: Optional[DAILY] = None
+    # data type: WEEKLY
+    oneof_schema_3_validator: Optional[WEEKLY] = None
+    # data type: MONTHLY
+    oneof_schema_4_validator: Optional[MONTHLY] = None
+    # data type: CUSTOM
+    oneof_schema_5_validator: Optional[CUSTOM] = None
+    actual_instance: Optional[Union[CUSTOM, DAILY, MONTHLY, SINGLE, WEEKLY]] = None
+    one_of_schemas: Set[str] = { "CUSTOM", "DAILY", "MONTHLY", "SINGLE", "WEEKLY" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -70,37 +70,37 @@ class PaymentRequestSchedule(BaseModel):
         instance = PaymentRequestSchedule.model_construct()
         error_messages = []
         match = 0
-        # validate data type: ScheduleTypeSingle
-        if not isinstance(v, ScheduleTypeSingle):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `ScheduleTypeSingle`")
+        # validate data type: SINGLE
+        if not isinstance(v, SINGLE):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `SINGLE`")
         else:
             match += 1
-        # validate data type: ScheduleTypeDaily
-        if not isinstance(v, ScheduleTypeDaily):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `ScheduleTypeDaily`")
+        # validate data type: DAILY
+        if not isinstance(v, DAILY):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `DAILY`")
         else:
             match += 1
-        # validate data type: ScheduleTypeWeekly
-        if not isinstance(v, ScheduleTypeWeekly):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `ScheduleTypeWeekly`")
+        # validate data type: WEEKLY
+        if not isinstance(v, WEEKLY):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `WEEKLY`")
         else:
             match += 1
-        # validate data type: ScheduleTypeMonthly
-        if not isinstance(v, ScheduleTypeMonthly):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `ScheduleTypeMonthly`")
+        # validate data type: MONTHLY
+        if not isinstance(v, MONTHLY):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MONTHLY`")
         else:
             match += 1
-        # validate data type: ScheduleTypeCustom
-        if not isinstance(v, ScheduleTypeCustom):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `ScheduleTypeCustom`")
+        # validate data type: CUSTOM
+        if not isinstance(v, CUSTOM):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CUSTOM`")
         else:
             match += 1
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when setting `actual_instance` in PaymentRequestSchedule with oneOf schemas: ScheduleTypeCustom, ScheduleTypeDaily, ScheduleTypeMonthly, ScheduleTypeSingle, ScheduleTypeWeekly. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when setting `actual_instance` in PaymentRequestSchedule with oneOf schemas: CUSTOM, DAILY, MONTHLY, SINGLE, WEEKLY. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when setting `actual_instance` in PaymentRequestSchedule with oneOf schemas: ScheduleTypeCustom, ScheduleTypeDaily, ScheduleTypeMonthly, ScheduleTypeSingle, ScheduleTypeWeekly. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when setting `actual_instance` in PaymentRequestSchedule with oneOf schemas: CUSTOM, DAILY, MONTHLY, SINGLE, WEEKLY. Details: " + ", ".join(error_messages))
         else:
             return v
 
@@ -115,43 +115,43 @@ class PaymentRequestSchedule(BaseModel):
         error_messages = []
         match = 0
 
-        # deserialize data into ScheduleTypeSingle
+        # deserialize data into SINGLE
         try:
-            instance.actual_instance = ScheduleTypeSingle.from_json(json_str)
+            instance.actual_instance = SINGLE.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into ScheduleTypeDaily
+        # deserialize data into DAILY
         try:
-            instance.actual_instance = ScheduleTypeDaily.from_json(json_str)
+            instance.actual_instance = DAILY.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into ScheduleTypeWeekly
+        # deserialize data into WEEKLY
         try:
-            instance.actual_instance = ScheduleTypeWeekly.from_json(json_str)
+            instance.actual_instance = WEEKLY.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into ScheduleTypeMonthly
+        # deserialize data into MONTHLY
         try:
-            instance.actual_instance = ScheduleTypeMonthly.from_json(json_str)
+            instance.actual_instance = MONTHLY.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into ScheduleTypeCustom
+        # deserialize data into CUSTOM
         try:
-            instance.actual_instance = ScheduleTypeCustom.from_json(json_str)
+            instance.actual_instance = CUSTOM.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
 
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when deserializing the JSON string into PaymentRequestSchedule with oneOf schemas: ScheduleTypeCustom, ScheduleTypeDaily, ScheduleTypeMonthly, ScheduleTypeSingle, ScheduleTypeWeekly. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when deserializing the JSON string into PaymentRequestSchedule with oneOf schemas: CUSTOM, DAILY, MONTHLY, SINGLE, WEEKLY. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when deserializing the JSON string into PaymentRequestSchedule with oneOf schemas: ScheduleTypeCustom, ScheduleTypeDaily, ScheduleTypeMonthly, ScheduleTypeSingle, ScheduleTypeWeekly. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when deserializing the JSON string into PaymentRequestSchedule with oneOf schemas: CUSTOM, DAILY, MONTHLY, SINGLE, WEEKLY. Details: " + ", ".join(error_messages))
         else:
             return instance
 
@@ -165,7 +165,7 @@ class PaymentRequestSchedule(BaseModel):
         else:
             return json.dumps(self.actual_instance)
 
-    def to_dict(self) -> Optional[Union[Dict[str, Any], ScheduleTypeCustom, ScheduleTypeDaily, ScheduleTypeMonthly, ScheduleTypeSingle, ScheduleTypeWeekly]]:
+    def to_dict(self) -> Optional[Union[Dict[str, Any], CUSTOM, DAILY, MONTHLY, SINGLE, WEEKLY]]:
         """Returns the dict representation of the actual instance"""
         if self.actual_instance is None:
             return None

pluggy_sdk/models/single.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    Pluggy API
+
+    Pluggy's main API to review data and execute connectors
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: hello@pluggy.ai
+    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 date
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SINGLE(BaseModel):
+    """
+    Schedule atribute to generate one payment in the future
+    """ # noqa: E501
+    type: StrictStr = Field(description="Scheduled type")
+    var_date: date = Field(alias="date")
+    __properties: ClassVar[List[str]] = ["type", "date"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['SINGLE']):
+            raise ValueError("must be one of enum values ('SINGLE')")
+        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 SINGLE 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 SINGLE from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "date": obj.get("date")
+        })
+        return _obj
+
+