brynq-sdk-nmbrs 2.3.1.dev0__py3-none-any.whl → 2.3.2.dev0__py3-none-any.whl

brynq_sdk_nmbrs/__init__.py

@@ -21,17 +21,18 @@ from .costunit import Costunit
 from .days import FixedDays, VariableDays
 from .debtors import Debtors
 from .department import Departments, EmployeeDepartment
-from .document import Payslip
+from .document import EmployeeDocument, Payslip
 from .employee_wage_tax_settings import EmployeeWageTaxSettings
 from .employees import Employees
 from .employment import Employment
 from .function import EmployeeFunction, Functions
 from .hours import FixedHours, VariableHours
+from .leave import Leave, LeaveBalance, LeaveGroup
 from .manager import EmployeeManager, Manager
 from .salaries import Salaries
 from .salary_tables import SalaryScales, SalarySteps, SalaryTables
 from .schedules import Schedule
-from .wage_tax import WageTax
+from .wage_tax import WageTax, WageTaxSettings
 from .wagecomponents import EmployeeFixedWageComponents, EmployeeVariableWageComponents
 
 
@@ -43,21 +44,42 @@ class Nmbrs(BrynQ):
         Args:
             label: The label of the system in BrynQ. legacy
             debug: Whether to print debug information
-11            mock_mode: If true, data will NOT be sent to Nmbrs but only be tested for validity against Pydantic schemas
+            mock_mode: If true, data will NOT be sent to Nmbrs but only be tested for validity against Pydantic schemas
         """
         self.mock_mode = mock_mode
         self.debug = debug
         self.timeout = 3600
         self.system_type = system_type
+
+        # Initialize classes that work in both mock and real mode
+        self.address = Address(self)
+        self.bank = Bank(self)
+        self.children = Children(self)
+        self.contract = Contract(self)
+        self.leave = Leave(self)
+        self.leave_group = LeaveGroup(self)
+        self.function = EmployeeFunction(self)
+        self.functions = Functions(self)
+        self.employee_document = EmployeeDocument(self)
+        self.departments = Departments(self)
+        self.debtor = Debtors(self)
+        self.companies = Companies(self)
+
         if mock_mode is False:
+            # Initialize BrynQ parent class for REST API credentials
             super().__init__()
             self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
+
+            # Get credentials once and store
+            self._credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
+            self._custom_config = self._credentials.get("custom_data", {})
+
             headers = self._get_request_headers()
             self.base_url = "https://api.nmbrsapp.com/api/"
             self.session = requests.Session()
             self.session.headers.update(headers)
 
-            # Initialize SOAP client
+            # Initialize SOAP clients
             self.soap_settings = Settings(
                 strict=False,
                 xml_huge_tree=True,
@@ -71,11 +93,24 @@ class Nmbrs(BrynQ):
                 'https://api.nmbrs.nl/soap/v3/EmployeeService.asmx?wsdl',
                 settings=self.soap_settings
             )
-            self.soap_auth_header = self._get_soap_auth_header_companies()
-            self.soap_auth_header_employees = self._get_soap_auth_header_employees()
-            # Following methods can only be used if the SOAP authentication header is set (optional, this is not always in scope for all integrations)
+            self.soap_client_debtors = Client(
+                'https://api.nmbrs.nl/soap/v3/DebtorService.asmx?wsdl',
+                settings=self.soap_settings
+            )
+            # Create auth headers for each service (namespace must match)
+            self.soap_auth_header = self._create_soap_auth_header(self.soap_client_companies)
+            self.soap_auth_header_employees = self._create_soap_auth_header(self.soap_client_employees)
+            self.soap_auth_header_debtors = self._create_soap_auth_header(self.soap_client_debtors)
+
+            # REST API dependent classes
+            self.employee_department = EmployeeDepartment(self)
+
+            debtors, _ = self.debtor.get()
+            self.debtor_ids = debtors['debtor_id'].to_list()
+            self.company_ids = self.companies.get()['companyId'].to_list()
+
+            # SOAP dependent on REST - companies must be defined first
             if self.soap_auth_header is not None:
-                self.companies = Companies(self)
                 self.employees = Employees(self)
                 self.soap_company_ids = self.companies.get_soap_ids()
                 self.soap_employee_ids = self.employees.get_soap_ids()
@@ -84,96 +119,67 @@ class Nmbrs(BrynQ):
                 self.salary_steps = SalarySteps(self)
                 self.wage_tax = WageTax(self)
                 self.absence = Absence(self)
-                self.children = Children(self)
-
-        self.address = Address(self)
-        self.bank = Bank(self)
-        self.children = Children(self)
-        self.debtor = Debtors(self)
-        self.companies = Companies(self)
-        self.contract = Contract(self)
-        self.employee_department = EmployeeDepartment(self)
-        self.department = Departments(self)
-        debtors, _ = self.debtor.get()
-        self.debtor_ids = debtors['debtor_id'].to_list()
-        self.company_ids = self.companies.get()['companyId'].to_list()
-        self.employees = Employees(self)
-        self.employment = Employment(self)
-        self.employee_function = EmployeeFunction(self)
-        self.functions = Functions(self)
-        self.fixed_hours = FixedHours(self)
-        self.fixed_days = FixedDays(self)
-        self.variable_hours = VariableHours(self)
-        self.variable_days = VariableDays(self)
-        self.manager = Manager(self)
-        self.employee_manager = EmployeeManager(self)
-        self.salaries = Salaries(self)
-        self.schedule = Schedule(self)
-        self.cost_center = Costcenter(self)
-        self.employee_cost_center = EmployeeCostcenter(self)
-        self.cost_unit = Costunit(self)
-        self.employee_wage_tax_settings = EmployeeWageTaxSettings(self)
-        self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
-        self.variable_wagecomponents = EmployeeVariableWageComponents(self)
-        self.current_period = self.companies.get_current_period()
 
+            self.employees = Employees(self)
+            self.employment = Employment(self)
+            self.wage_tax_settings = WageTaxSettings(self)
+            self.fixed_hours = FixedHours(self)
+            self.fixed_days = FixedDays(self)
+            self.variable_hours = VariableHours(self)
+            self.variable_days = VariableDays(self)
+            self.manager = Manager(self)
+            self.employee_manager = EmployeeManager(self)
+            self.salaries = Salaries(self)
+            self.schedule = Schedule(self)
+            self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
+            self.variable_wagecomponents = EmployeeVariableWageComponents(self)
+            self.current_period = self.companies.get_current_period()
+            self.cost_center = Costcenter(self)
+            self.employee_cost_center = EmployeeCostcenter(self)
+            self.cost_unit = Costunit(self)
+            self.employee_wage_tax_settings = EmployeeWageTaxSettings(self)
     def _get_request_headers(self):
-        credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
+        access_token = self._credentials.get('data').get('access_token')
+        subscription_key = self._custom_config.get("subscription_key")
         headers = {
             "accept": "application/json",
-            "Authorization": f"Bearer {credentials.get('data').get('access_token')}",
+            "Authorization": f"Bearer {access_token.strip() if access_token else ''}",
             # partner identifier
-            "X-Subscription-Key": credentials.get("custom_data").get("subscription_key")
+            "X-Subscription-Key": subscription_key.strip() if subscription_key else ''
         }
 
         return headers
 
-    def _get_soap_auth_header_companies(self):
+    def _create_soap_auth_header(self, soap_client):
         """
-        Creates the SOAP authentication header using credentials from initial_credentials.
-
-        Returns:
-            AuthHeaderWithDomainType: The authentication header for SOAP requests
-        """
-        initial_credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
-        config = initial_credentials.get("custom_data", {})
-
-        if 'soap_api_token' not in config.keys():
-            return None
-        else:
-            # Get the AuthHeaderWithDomain type from the WSDL
-            AuthHeaderWithDomainType = self.soap_client_companies.get_element('ns0:AuthHeaderWithDomain')
-
-            # Create the auth header using credentials from config
-            auth_header = AuthHeaderWithDomainType(
-                Username=config.get("soap_api_username"),
-                Token=config.get("soap_api_token"),
-                Domain=config.get("soap_api_domain")
-            )
-
-            return auth_header
+        Creates SOAP authentication header for a specific SOAP client.
+        Each service needs its own auth header with matching namespace.
 
-    def _get_soap_auth_header_employees(self):
-        """
-        Creates the SOAP authentication header using credentials from initial_credentials.
+        Args:
+            soap_client: The zeep SOAP client to create auth header for
 
         Returns:
-            AuthHeaderWithDomainType: The authentication header for SOAP requests
+            AuthHeaderWithDomainType: The authentication header for SOAP requests,
+            or None if SOAP credentials are not configured.
         """
-        initial_credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
-        custom_data = initial_credentials.get("custom_data", {})
+        if 'soap_api_token' not in self._custom_config.keys():
+            return None
 
-        # Get the AuthHeaderWithDomain type from the WSDL
-        AuthHeaderWithDomainType = self.soap_client_employees.get_element('ns0:AuthHeaderWithDomain')
+        AuthHeaderWithDomainType = soap_client.get_element('ns0:AuthHeaderWithDomain')
 
-        # Create the auth header using credentials from config
-        auth_header = AuthHeaderWithDomainType(
-            Username=custom_data.get("soap_api_username"),
-            Token=custom_data.get("soap_api_token"),
-            Domain=custom_data.get("soap_api_domain")
+        return AuthHeaderWithDomainType(
+            Username=self._custom_config.get("soap_api_username"),
+            Token=self._custom_config.get("soap_api_token"),
+            Domain=self._custom_config.get("soap_api_domain")
         )
 
-        return auth_header
+    def _get_soap_auth_header(self):
+        """Legacy method - use _create_soap_auth_header instead."""
+        return self._create_soap_auth_header(self.soap_client_companies)
+
+    def _get_soap_auth_header_employees(self):
+        """Legacy method - use soap_auth_header_employees instead."""
+        return self.soap_auth_header_employees
 
     def get_paginated_result(self, request: requests.Request) -> List:
         has_next_page = True

brynq_sdk_nmbrs/address.py

@@ -1,9 +1,10 @@
 import pandas as pd
 import requests
-from typing import Dict, Any
-from .schemas.address import AddressCreate, AddressGet, Period
+from typing import Dict, Any, Union
+from .schemas.address import AddressCreate, AddressGet, AddressDelete, AddressUpdate, Period
 from brynq_sdk_functions import Functions
 
+
 class Address:
     def __init__(self, nmbrs):
         self.nmbrs = nmbrs
@@ -64,3 +65,82 @@ class Address:
             timeout=self.nmbrs.timeout
         )
         return resp
+
+    def delete(self, employee_id: Union[int, str], address_id: Union[int, str]) -> bool:
+        """
+        Delete an address for an employee using SOAP API.
+        
+        REST API does not support address deletion, so we use SOAP as interim solution.
+
+        Args:
+            employee_id: The ID of the employee
+            address_id: The ID of the address to delete
+
+        Returns:
+            bool: True if deletion was successful
+            
+        Raises:
+            Exception: If SOAP client is not available or deletion fails
+        """
+        # Validate input using Pydantic schema
+        delete_model = AddressDelete(employeeId=int(employee_id), addressId=int(address_id))
+
+        if self.nmbrs.mock_mode:
+            return delete_model
+
+        # Call SOAP Address_Delete using EmployeeService auth header
+        resp = self.nmbrs.soap_client_employees.service.Address_Delete(
+            EmployeeId=delete_model.employee_id,
+            AddressID=delete_model.address_id,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        
+        return resp
+
+    def update(self, employee_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Update an address for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing address data with fields matching AddressUpdate schema:
+                - id: Address ID to update
+                - street: Street name
+                - house_number: House number (optional)
+                - house_number_addition: House number addition (optional)
+                - postal_code: Postal code (optional)
+                - city: City name
+                - state_province: State or province (optional)
+                - country_iso_code: Country ISO code (e.g., "NL")
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        address_model = AddressUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return address_model
+
+        # Create EmployeeAddress type
+        AddressType = self.nmbrs.soap_client_employees.get_type('ns0:EmployeeAddress')
+        soap_address = AddressType(
+            Id=address_model.id,
+            Default=address_model.default,
+            Street=address_model.street,
+            HouseNumber=address_model.house_number or '',
+            HouseNumberAddition=address_model.house_number_addition or '',
+            PostalCode=address_model.postal_code or '',
+            City=address_model.city,
+            StateProvince=address_model.state_province or '',
+            CountryISOCode=address_model.country_iso_code,
+            Type=address_model.address_type
+        )
+
+        # Call SOAP Address_Update
+        result = self.nmbrs.soap_client_employees.service.Address_Update(
+            EmployeeId=int(employee_id),
+            Address=soap_address,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return result

brynq_sdk_nmbrs/children.py

@@ -1,24 +1,14 @@
-from datetime import datetime
+from typing import Union, Dict, Any
 
-from zeep import Client
-from zeep.transports import Transport
 import requests
 import pandas as pd
 
+from .schemas.children import ChildCreate, ChildDelete, ChildUpdate
+
 
 class Children:
     def __init__(self, nmbrs):
         self.nmbrs = nmbrs
-        self.client = Client(wsdl='https://api.nmbrs.nl/soap/v3/EmployeeService.asmx?wsdl') #, transport=Transport(session=self.nmbrs.session))
-        # self.client.set_default_soapheaders([auth_header])
-        AuthHeaderWithDomainType = self.client.get_element('ns0:AuthHeaderWithDomain')
-
-        auth_header = AuthHeaderWithDomainType(
-            Username="erwin.vink@brynq.com",
-            Token="cc358715f5c14cda8add964deef99ba3",
-            Domain="extdev-brynq"
-        )
-        self.client.set_default_soapheaders([auth_header])
 
     def get(self,
             company_id: str,
@@ -42,59 +32,104 @@ class Children:
 
         return df
 
+    def create(self, employee_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Create a new child for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing child data with fields matching ChildCreate schema
+
+        Returns:
+            Response from the API (child ID)
+        """
+        # Validate with Pydantic model
+        child_model = ChildCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return child_model
+
+        ChildType = self.nmbrs.soap_client_employees.get_type('ns0:Child')
+        child = ChildType(
+            Id=0,  # Use 0 for new child
+            Name=child_model.name,
+            FirstName=child_model.first_name,
+            Initials=child_model.initials or '',
+            Gender=child_model.gender,
+            Birthday=child_model.birthday
+        )
+
+        # Make the API call
+        result = self.nmbrs.soap_client_employees.service.Children_Insert(
+            EmployeeId=int(employee_id),
+            child=child,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return result
+
+    def delete(self, employee_id: Union[int, str], child_id: Union[int, str]):
+        """
+        Delete a child for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            child_id: The ID of the child to delete
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        delete_model = ChildDelete(employeeId=int(employee_id), childId=int(child_id))
+
+        if self.nmbrs.mock_mode:
+            return delete_model
 
-    def create(self,
-               employee_id: str,
-               data: dict):
+        # Call SOAP Child_Delete
+        resp = self.nmbrs.soap_client_employees.service.Child_Delete(
+            EmployeeId=delete_model.employee_id,
+            ChildId=delete_model.child_id,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return resp
+
+    def update(self, employee_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Update a child for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing child data with fields matching ChildUpdate schema:
+                - id: Child ID to update
+                - name: Last name
+                - first_name: First name
+                - initials: Initials (optional)
+                - gender: Gender (male/female/unknown/undefined)
+                - birthday: Birthday
 
-        required_fields = ["first_name", "period", "function_id"]
-        allowed_fields = {}
-        # self.nmbrs.check_fields(data=data, required_fields=required_fields, allowed_fields=list(allowed_fields.keys()))
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        child_model = ChildUpdate(**data)
 
-        ChildType = self.client.get_type('ns0:Child')
+        if self.nmbrs.mock_mode:
+            return child_model
+
+        ChildType = self.nmbrs.soap_client_employees.get_type('ns0:Child')
         child = ChildType(
-            Id=1,  # Use 0 or omit if adding a new child
-            Name='Doe',
-            FirstName='John',
-            Initials='J.D.',
-            Gender='male',  # Options: 'male', 'female', 'unknown', 'undefined'
-            Birthday=datetime(2020, 1, 1)  # Using a datetime object
+            Id=child_model.id,
+            Name=child_model.name,
+            FirstName=child_model.first_name,
+            Initials=child_model.initials or '',
+            Gender=child_model.gender,
+            Birthday=child_model.birthday
         )
 
         # Make the API call
-        result = self.client.service.Children_Insert(
-            EmployeeId=employee_id,
-            child=child
+        result = self.nmbrs.soap_client_employees.service.Children_Update(
+            EmployeeId=int(employee_id),
+            child=child,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
         )
-        print("Child inserted successfully. Result:", result)
-
-
-# <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:emp="https://api.nmbrs.nl/soap/v3/EmployeeService">
-#    <soap:Header>
-#       <emp:AuthHeaderWithDomain>
-#          <!--Optional:-->
-#          <emp:Username>erwin.vink@brynq.com</emp:Username>
-#          <!--Optional:-->
-#          <emp:Token>cc358715f5c14cda8add964deef99ba3</emp:Token>
-#          <!--Optional:-->
-#          <emp:Domain>extdev-brynq</emp:Domain>
-#       </emp:AuthHeaderWithDomain>
-#    </soap:Header>
-#    <soap:Body>
-#       <emp:Children_Insert>
-#          <emp:EmployeeId>11</emp:EmployeeId>
-#          <!--Optional:-->
-#          <emp:child>
-#             <emp:Id>1</emp:Id>
-#             <!--Optional:-->
-#             <emp:Name>Doe</emp:Name>
-#             <!--Optional:-->
-#             <emp:FirstName>John</emp:FirstName>
-#             <!--Optional:-->
-#             <emp:Initials>J.</emp:Initials>
-#             <emp:Gender>male</emp:Gender>
-#             <emp:Birthday>2020-01-01T00:00:00</emp:Birthday>
-#          </emp:child>
-#       </emp:Children_Insert>
-#    </soap:Body>
-# </soap:Envelope>
+        return result
+

brynq_sdk_nmbrs/companies.py

@@ -1,6 +1,7 @@
 import pandas as pd
 import requests
 import logging
+from typing import Dict, Any
 
 from .leave import LeaveGroup
 from .costcenter import Costcenter
@@ -8,6 +9,7 @@ from .costunit import Costunit
 from .hours import Hours
 from .bank import Bank
 from .function import Functions
+from .schemas.company import CompanyCreate
 from zeep.exceptions import Fault
 from zeep.helpers import serialize_object
 
@@ -19,10 +21,13 @@ class Companies:
         self.costunits = Costunit(nmbrs)
         self.hours = Hours(nmbrs)
         self.banks = Bank(nmbrs)
-        self.soap_client_companies = nmbrs.soap_client_companies
         self.logger = logging.getLogger(__name__)
         self.leave_groups = LeaveGroup(nmbrs)
 
+    @property
+    def soap_client_companies(self):
+        return self.nmbrs.soap_client_companies
+
     def get(self) -> pd.DataFrame:
         try:
             request = requests.Request(method='GET',
@@ -91,3 +96,42 @@ class Companies:
         except Exception as e:
             self.logger.exception("Exception occurred:")
             raise Exception(f"Failed to get current period: {str(e)}")
+
+    def create(self, data: Dict[str, Any]) -> int:
+        """
+        Create a new company using SOAP API.
+
+        Args:
+            data: Dictionary containing company data with fields matching CompanyCreate schema:
+                - debtor_id: Debtor ID
+                - company_name: Company name
+                - period_type: Period type (1=Monthly, 2=4-Weekly, 3=Weekly, 4=Quarterly)
+                - default_company_id: Default company ID to copy settings from (0 for none)
+                - labour_agreement_settings_group_guid: Labour agreement settings group GUID
+                - pay_in_advance: Pay in advance
+
+        Returns:
+            The ID of the newly created company.
+        """
+        company_model = CompanyCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return 12345  # Mock ID
+
+        try:
+            response = self.soap_client_companies.service.Company_Insert(
+                DebtorId=company_model.debtor_id,
+                CompanyName=company_model.company_name,
+                PeriodType=company_model.period_type,
+                DefaultCompanyId=company_model.default_company_id,
+                LabourAgreementSettingsGroupGuid=company_model.labour_agreement_settings_group_guid or "00000000-0000-0000-0000-000000000000",
+                PayInAdvance=company_model.pay_in_advance,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to create company: {str(e)}")

brynq_sdk_nmbrs/debtors.py

@@ -1,9 +1,11 @@
 import pandas as pd
 import requests
+from typing import Dict, Any
+from zeep.exceptions import Fault
 from brynq_sdk_functions import Functions
 from .department import Departments
 from .function import Functions as NmbrsFunctions
-from .schemas.debtor import DebtorsGet
+from .schemas.debtor import DebtorsGet, DebtorCreate, DebtorUpdate
 
 
 class Debtors:
@@ -12,7 +14,6 @@ class Debtors:
         self.departments = Departments(nmbrs)
         self.functions = NmbrsFunctions(nmbrs)
 
-
     def get(self) -> (pd.DataFrame, pd.DataFrame):
         request = requests.Request(method='GET',
                                    url=f"{self.nmbrs.base_url}debtors")
@@ -23,3 +24,76 @@ class Debtors:
         valid_debtors, invalid_debtors = Functions.validate_data(df=df, schema=DebtorsGet, debug=True)
 
         return valid_debtors, invalid_debtors
+
+    def create(self, data: Dict[str, Any]) -> int:
+        """
+        Create a new debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing debtor data with fields matching DebtorCreate schema:
+                - number: Debtor number
+                - name: Debtor name
+
+        Returns:
+            The ID of the newly created debtor.
+        """
+        debtor_model = DebtorCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return 12345  # Mock ID
+
+        try:
+            DebtorType = self.nmbrs.soap_client_debtors.get_type('ns0:Debtor')
+            soap_debtor = DebtorType(
+                Id=0,  # 0 for new debtor
+                Number=debtor_model.number,
+                Name=debtor_model.name
+            )
+
+            response = self.nmbrs.soap_client_debtors.service.Debtor_Insert(
+                Debtor=soap_debtor,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to create Debtor: {str(e)}")
+
+    def update(self, data: Dict[str, Any]):
+        """
+        Update a debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing debtor data with fields matching DebtorUpdate schema:
+                - debtor_id: Debtor ID to update
+                - number: Debtor number
+                - name: Debtor name
+
+        Returns:
+            Response from the API
+        """
+        debtor_model = DebtorUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return debtor_model
+
+        try:
+            DebtorType = self.nmbrs.soap_client_debtors.get_type('ns0:Debtor')
+            soap_debtor = DebtorType(
+                Id=debtor_model.debtor_id,
+                Number=debtor_model.number,
+                Name=debtor_model.name
+            )
+
+            response = self.nmbrs.soap_client_debtors.service.Debtor_Update(
+                Debtor=soap_debtor,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to update Debtor: {str(e)}")