brynq-sdk-acerta 1.1.1__py3-none-any.whl

brynq_sdk_acerta/employees.py

@@ -0,0 +1,121 @@
+from typing import Dict, Any, Tuple
+import warnings
+import requests
+import pandas as pd
+from .family_members import FamilyMembers
+from brynq_sdk_functions import Functions
+from .schemas.employee import PersonalDetailsGet, PersonalDetailsUpdate, EmployeeCreate
+from .employees_additional_information import EmployeesAdditionalInformation
+from .addresses import Addresses
+from .contact_information import ContactInformation
+from .family_situation import FamilySituation
+from .bank_accounts import BankAccounts
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+	from .acerta import Acerta
+
+class Employees:
+	"""Resource class for Employee endpoints"""
+
+	def __init__(self, acerta):
+		self.acerta: Acerta = acerta
+		self.base_uri = "employee-data-management"
+
+		# Initialize subclass resources
+		self.addresses = Addresses(acerta)
+		self.contact_information = ContactInformation(acerta)
+		self.family_situation = FamilySituation(acerta)
+		self.bank_accounts = BankAccounts(acerta)
+		self.additional_information = EmployeesAdditionalInformation(acerta)
+		self.family_members = FamilyMembers(acerta)
+
+	def get(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
+		"""
+		GET /v2/employees/{employeeId} - Employee
+
+		Retrieves employee information including personal data, birth information, gender,
+		nationality, languages, and family situation. Address and contact information
+		are excluded (available in separate endpoints).
+
+		Args:
+			employee_id: Employee identifier
+
+		Returns:
+			Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after normalizing and validating
+		"""
+		all_dfs = []
+		for employee_id in self.acerta._employee_ids:
+			response = self.acerta.session.get(
+				url=f"{self.acerta.base_url}/{self.base_uri}/v3/employees/{employee_id}/personal-details",
+				timeout=self.acerta.TIMEOUT,
+			)
+			response.raise_for_status()
+			df = pd.json_normalize(response.json())
+			all_dfs.append(df)
+
+		employees = pd.concat(all_dfs, ignore_index=True) if all_dfs else pd.DataFrame()
+		valid_employees, invalid_employees = Functions.validate_data(employees, PersonalDetailsGet)
+
+		return valid_employees, invalid_employees
+
+	def update(self, employee_id: str, data: Dict[str, Any]) -> requests.Response:
+		"""
+		PATCH /v3/employees/{employeeId}/personal-details - Employee personal details
+
+		Update employee personal details including name, birth information, nationality,
+		languages, identification numbers, and work permits.
+
+		Args:
+			employee_id: Employee identifier
+			data: Flat dictionary with personal details data
+
+		Returns:
+			requests.Response: Raw response object
+		"""
+		# Convert flat data to nested using Functions.flat_to_nested_with_prefix
+		nested_data = Functions.flat_to_nested_with_prefix(data, PersonalDetailsUpdate)
+
+		# Validate the nested data
+		validated_data = PersonalDetailsUpdate(**nested_data)
+
+		# Make API request
+		response = self.acerta.session.patch(
+			url=f"{self.acerta.base_url}/{self.base_uri}/v3/employees/{employee_id}/personal-details",
+			json=validated_data.model_dump(by_alias=True, exclude_none=True),
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+
+		return response
+
+
+
+	def create(self, data: Dict[str, Any]) -> requests.Response:
+		"""
+		POST /v3/employees - Employee
+
+		Create an employee without an agreement. Includes personal details, addresses,
+		contact information, family situation, bank accounts, and additional information.
+
+		Args:
+			data: Flat dictionary with employee data
+
+		Returns:
+			requests.Response: Raw response object with employeeId
+		"""
+		warnings.warn("Do not use this endpoint if you need to add a contract. There is no endpoint to create contracts separately, it's only possible on in-service requests. This endpoint is only used if you want to create an employee without a contract.")
+		# Convert flat data to nested using Functions.flat_to_nested_with_prefix
+		nested_data = Functions.flat_to_nested_with_prefix(data, EmployeeCreate)
+
+		# Validate the nested data
+		validated_data = EmployeeCreate(**nested_data)
+
+		# Make API request
+		response = self.acerta.session.post(
+			url=f"{self.acerta.base_url}/{self.base_uri}/v3/employees",
+			json=validated_data.model_dump(by_alias=True, exclude_none=True),
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+
+		return response

brynq_sdk_acerta/employees_additional_information.py

@@ -0,0 +1,87 @@
+from typing import Tuple, Dict, Any
+import requests
+import pandas as pd
+from brynq_sdk_functions import Functions
+from .schemas.employee import AdditionalInformationGet, AdditionalInformationUpdate
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .acerta import Acerta
+
+
+class EmployeesAdditionalInformation:
+    """Resource class for Employee Additional Information endpoints"""
+
+    def __init__(self, acerta):
+        self.acerta: Acerta = acerta
+        self.base_uri = "employee-data-management/v3/employees"
+
+    def get(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GET /v3/employees/{employeeId}/additional-information - Employee Additional Information
+
+        Retrieves employee additional information including educational degree and leadership level
+        for all cached employees. This data is historical (segmented by periods).
+
+        Returns:
+            Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after normalizing and validating
+        """
+        try:
+            if not self.acerta._employee_ids:
+                self.acerta.agreements.get()
+
+            frames = []
+            for employee_id in self.acerta._employee_ids:
+                response = self.acerta.session.get(
+                    url=f"{self.acerta.base_url}/{self.base_uri}/{employee_id}/additional-information",
+                    timeout=self.acerta.TIMEOUT,
+                )
+                response.raise_for_status()
+                content = response.json()
+                df = pd.json_normalize(
+                    content,
+                    record_path=["additionalInformationSegments"],
+                    meta=["employeeId"],
+                    sep="."
+                )
+                external_ref_columns = [col for col in df.columns if "externalReferences" in col]
+                if external_ref_columns:
+                    df = df.drop(columns=external_ref_columns)
+                frames.append(df)
+
+            combined = pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+
+            valid_df, invalid_df = Functions.validate_data(combined, AdditionalInformationGet)
+
+            return valid_df, invalid_df
+
+        except Exception as e:
+            raise Exception(f"Failed to retrieve employee additional information: {str(e)}") from e
+
+    def update(self, employee_id: str, data: Dict[str, Any]) -> requests.Response:
+        """
+        PATCH /v3/employees/{employeeId}/additional-information - Employee Additional Information
+
+        Update employee additional information including educational degree and leadership level.
+        This data is historical.
+
+        Args:
+            employee_id: Employee identifier
+            data: Dictionary with additional information data (fromDate, educationalDegree, leadershipLevel)
+
+        Returns:
+            requests.Response: Raw response object
+        """
+        try:
+            validated_data = AdditionalInformationUpdate(**data)
+
+            response = self.acerta.session.patch(
+                url=f"{self.acerta.base_url}/{self.base_uri}/{employee_id}/additional-information",
+                json=validated_data.model_dump(by_alias=True, exclude_none=True),
+                timeout=self.acerta.TIMEOUT,
+            )
+            response.raise_for_status()
+
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to update additional information: {str(e)}") from e

brynq_sdk_acerta/employer.py

@@ -0,0 +1,179 @@
+from typing import Tuple, Optional, Literal
+import pandas as pd
+from brynq_sdk_functions import Functions
+from .schemas.employer import JointCommitteeGet, FunctionGet, SalaryCodeGet
+from .cost_centers import CostCenters
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+	from .acerta import Acerta
+
+# Type aliases for employee service types
+ServiceType = Literal[
+	'WHITE_COLLAR',
+	'LABOURER',
+	'BLUE_COLLAR',
+	'STUDENT_BLUE_COLLAR',
+	'STUDENT_WHITE_COLLAR',
+	'FLEX_BLUE_COLLAR',
+	'FLEX_WHITE_COLLAR'
+]
+
+
+class Employer:
+	"""Resource class for Employer endpoints"""
+
+	def __init__(self, acerta):
+		self.acerta: Acerta = acerta
+
+		# Initialize subclass resources
+		self.cost_centers = CostCenters(acerta)
+
+	def get_joint_committees(self, employer_id: Optional[str] = None, in_service_type: Optional[ServiceType] = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
+		"""
+		GET /employers/{employerId}/joint-committees - Joint Committees
+
+		Retrieves all active joint committees for a specific employer. The output serves as input
+		for the employee onboarding process. Can be filtered by employee classification.
+
+		Args:
+			employer_id: The ID for the employer for which the joint committees are requested
+			in_service_type: The type of employee for which the joint committees should be active (optional)
+				Options: WHITE_COLLAR, LABOURER, BLUE_COLLAR, STUDENT_BLUE_COLLAR,
+						 STUDENT_WHITE_COLLAR, FLEX_BLUE_COLLAR, FLEX_WHITE_COLLAR
+			accept_language: Response language (default: "EN")
+
+		Returns:
+			Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after validation
+
+		Raises:
+			Exception: If the retrieval fails
+		"""
+		employers = [employer_id] if employer_id else self.acerta._employer_ids
+		all_rows = []
+		for emp_id in employers:
+			params = {}
+			if in_service_type:
+				params['inServiceType'] = in_service_type
+			response = self.acerta.session.get(
+				url=f"{self.acerta.base_url}/employee-in-service-request/v1/employers/{emp_id}/joint-committees",
+				params=params,
+				timeout=self.acerta.TIMEOUT,
+			)
+			response.raise_for_status()
+			data = response.json()
+			joint_committees = data.get("_embedded", {}).get("jointCommittees", [])
+			rows = []
+			for jc in joint_committees:
+				base_data = {
+					"employerId": emp_id,
+					"code": jc.get("code"),
+					"description": jc.get("description")
+				}
+				links = jc.get("_links", [])
+				if links:
+					for link in links:
+						row = {**base_data}
+						row["_links.rel"] = link.get("rel")
+						row["_links.href"] = link.get("href")
+						row["_links.title"] = link.get("title")
+						row["_links.type"] = link.get("type")
+						row["_links.templated"] = link.get("templated")
+						rows.append(row)
+				else:
+					rows.append(base_data)
+			if rows:
+				all_rows.extend(rows)
+		df = pd.DataFrame(all_rows)
+		valid_data, invalid_data = Functions.validate_data(df, JointCommitteeGet)
+		return valid_data, invalid_data
+
+	def get_functions(self, employer_id: Optional[str] = None, from_date: str = "1900-01-01", until_date: str = "9999-12-31",
+					  size: int = 20, page: int = 0) -> Tuple[pd.DataFrame, pd.DataFrame]:
+		"""
+		GET /v1/employers/{employerId}/functions - Functions
+
+		Returns employer specific functions based on an employerId.
+
+		Args:
+			employer_id: Unique identifier of the employer (Acerta key)
+			from_date: The lower bound of the time window (default: "1900-01-01")
+			until_date: The upper bound of the time window (default: "9999-12-31")
+			size: Number of items to be returned on each page (default: 20)
+			page: Zero-based page index (default: 0)
+
+		Returns:
+			Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after validation
+
+		Raises:
+			Exception: If the retrieval fails
+		"""
+		employers = [employer_id] if employer_id else self.acerta._employer_ids
+		all_frames = []
+		for emp_id in employers:
+			params = {
+				"fromDate": from_date,
+				"untilDate": until_date,
+				"size": size,
+				"page": page
+			}
+			response = self.acerta.session.get(
+				url=f"{self.acerta.base_url}/employee-in-service-request/v1/employers/{emp_id}/functions",
+				params=params,
+				timeout=self.acerta.TIMEOUT,
+			)
+			response.raise_for_status()
+			data = response.json()
+			functions = data.get("functions", [])
+			if functions:
+				df = pd.json_normalize(functions, sep='.')
+				df["employerId"] = emp_id
+				all_frames.append(df)
+		combined = pd.concat(all_frames, ignore_index=True) if all_frames else pd.DataFrame()
+		valid_data, invalid_data = Functions.validate_data(combined, FunctionGet)
+		return valid_data, invalid_data
+
+	def get_salary_codes(self, employer_id: Optional[str] = None, from_date: str = "1900-01-01", until_date: str = "9999-12-31",
+						 size: int = 20, page: int = 0) -> Tuple[pd.DataFrame, pd.DataFrame]:
+		"""
+		GET /v1/employers/{employerId}/salary-codes - Salary codes
+
+		A salary code is an identifier used to categorize different types of earnings and deductions.
+		It exists in the salary elements of a basic salary. This endpoint returns the employer specific
+		salary codes based on an employerId.
+
+		Args:
+			employer_id: Unique identifier of the employer (Acerta key)
+			from_date: The lower bound of the time window (default: "1900-01-01")
+			until_date: The upper bound of the time window (default: "9999-12-31")
+			size: Number of items to be returned on each page (default: 20)
+			page: Zero-based page index (default: 0)
+
+		Returns:
+			Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after normalizing and validating
+
+		Raises:
+			Exception: If the retrieval fails
+		"""
+		employers = [employer_id] if employer_id else self.acerta._employer_ids
+		all_frames = []
+		for emp_id in employers:
+			params = {
+				"fromDate": from_date,
+				"untilDate": until_date,
+				"size": size,
+				"page": page
+			}
+			response = self.acerta.session.get(
+				url=f"{self.acerta.base_url}/employer-data-management/v1/employers/{emp_id}/salary-codes",
+				params=params,
+				timeout=self.acerta.TIMEOUT,
+			)
+			response.raise_for_status()
+			salary_codes_data = response.json().get("salaryCodes", [])
+			if salary_codes_data:
+				df = pd.json_normalize(salary_codes_data, sep='.')
+				df["employerId"] = emp_id
+				all_frames.append(df)
+		combined = pd.concat(all_frames, ignore_index=True) if all_frames else pd.DataFrame()
+		valid_data, invalid_data = Functions.validate_data(combined, SalaryCodeGet)
+		return valid_data, invalid_data

brynq_sdk_acerta/family_members.py

@@ -0,0 +1,99 @@
+from typing import Dict, Any, Tuple
+import requests
+import pandas as pd
+from .schemas.family import FamilyMemberGet, FamilySituationUpdate, FamilyMemberCreate, FamilySituationGet
+from brynq_sdk_functions import Functions
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+	from .acerta import Acerta
+
+class FamilyMembers:
+	"""Resource class for Family endpoints"""
+	# According to Acerta this is hardly ever used, is not relevant for payroll.
+
+	def __init__(self, acerta):
+		self.acerta: Acerta = acerta
+		self.base_uri = "employee-data-management/v2/employees"
+
+	def get(self, employee_id: str, from_date: str = "1900-01-01", until_date: str = "9999-12-31",
+				   full_segments_only: bool = False) -> Tuple[pd.DataFrame, pd.DataFrame]:
+		"""
+		GET /v2/employees/{employeeId}/family-members - Employee Family Members
+
+		Retrieves family member information including relationship, personalia (name, birth, gender),
+		and other details (dependant status, disability, insurance). Data is segmented by periods.
+
+		Args:
+			employee_id: Unique identifier for an employee
+			from_date: Lower bound of the time window (default: "1900-01-01")
+			until_date: Upper bound of the time window (default: "9999-12-31")
+			full_segments_only: If True, only return complete periods (default: False)
+
+		Returns:
+			Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after normalizing and validating
+		"""
+		# Prepare query parameters
+		params = {
+			"fromDate": from_date,
+			"untilDate": until_date,
+			"fullSegmentsOnly": full_segments_only
+		}
+
+		# Make API request
+		response = self.acerta.session.get(
+			url=f"{self.acerta.base_url}/{self.base_uri}/{employee_id}/family-members",
+			params=params,
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+		data = response.json()
+
+		# Extract and normalize data using pd.json_normalize
+		df = pd.json_normalize(
+			data,
+			record_path=['familyMembersSegments', 'familyMembers'],
+			meta=[
+				'employeeId',
+				['familyMembersSegments', 'period', 'startDate'],
+				['familyMembersSegments', 'period', 'endDate'],
+				['externalReferences', 0, 'externalReferenceType'],
+				['externalReferences', 0, 'externalReferenceNumber'],
+				['externalReferences', 0, 'companyOrganisationNumber']
+			],
+			sep='.'
+		)
+
+		# Validate with schema
+		valid_data, invalid_data = Functions.validate_data(df, FamilyMemberGet)
+
+		return valid_data, invalid_data
+
+	def create(self, employee_id: str, data: Dict[str, Any]) -> requests.Response:
+		"""
+		POST /v1/employees/{employeeId}/family-members - Employee Family Members
+
+		Create a new family member for an employee including relationship, personalia
+		(name, birth, gender), and other information (dependant status, disability, insurance).
+
+		Args:
+			employee_id: Unique identifier of an employee
+			data: Flat dictionary with family member data
+
+		Returns:
+			requests.Response: Raw response object
+		"""
+		# Convert flat data to nested using Functions.flat_to_nested_with_prefix
+		nested_data = Functions.flat_to_nested_with_prefix(data, FamilyMemberCreate)
+
+		# Validate the nested data
+		validated_data = FamilyMemberCreate(**nested_data)
+
+		# Make API request
+		response = self.acerta.session.post(
+			url=f"{self.acerta.base_url}/{self.base_uri}/{employee_id}/family-members",
+			json=validated_data.model_dump(by_alias=True, exclude_none=True),
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+
+		return response

brynq_sdk_acerta/family_situation.py

@@ -0,0 +1,99 @@
+from typing import Dict, Any, Tuple
+import requests
+import pandas as pd
+from .schemas.family import FamilyMemberGet, FamilySituationUpdate, FamilyMemberCreate, FamilySituationGet
+from brynq_sdk_functions import Functions
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+	from .acerta import Acerta
+
+class FamilySituation:
+	"""Resource class for Family endpoints"""
+
+	def __init__(self, acerta):
+		self.acerta: Acerta = acerta
+		self.base_uri = "v2"
+
+	def update(self, employee_id: str, data: Dict[str, Any]) -> requests.Response:
+		"""
+		PATCH /employee-data-management/v3/employees/{employeeId}/family-situation - Employee Family Situation
+
+		Update employee family situation including civil status, partner information,
+		dependants (children, over 65, others), and fiscal details.
+
+		Args:
+			employee_id: Unique identifier for an employee
+			data: Flat dictionary with family situation data
+
+		Returns:
+			requests.Response: Raw response object
+		"""
+		# Convert flat data to nested using Functions.flat_to_nested_with_prefix
+		nested_data = Functions.flat_to_nested_with_prefix(data, FamilySituationUpdate)
+
+		# Validate the nested data
+		validated_data = FamilySituationUpdate(**nested_data)
+
+		# Make API request
+		response = self.acerta.session.patch(
+			url=f"{self.acerta.base_url}/employee-data-management/v3/employees/{employee_id}/family-situation",
+			json=validated_data.model_dump(by_alias=True, exclude_none=True),
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+
+		return response
+
+	def get(self, employee_id: str, from_date: str = "1900-01-01", until_date: str = "9999-12-31",
+					  full_segments_only: bool = False) -> Tuple[pd.DataFrame, pd.DataFrame]:
+		"""
+		GET /employee-data-management/v3/employees/{employeeId}/family-situations - Employee Family Situations
+
+		Retrieve employee family situation history within a specified time window. Returns
+		civil status, partner information, dependants, and fiscal details with their validity periods.
+
+		Args:
+			employee_id: Unique identifier for an employee
+			from_date: Start date of the time window (default: "1900-01-01")
+			until_date: End date of the time window (default: "9999-12-31")
+			full_segments_only: If True, only return complete periods (default: False)
+
+		Returns:
+			Tuple[pd.DataFrame, pd.DataFrame]: (valid_df, invalid_df) after validation
+
+		Raises:
+			Exception: If the retrieval fails
+		"""
+		# Prepare query parameters
+		params = {
+			"fromDate": from_date,
+			"untilDate": until_date,
+			"fullSegmentsOnly": full_segments_only
+		}
+
+		# Make API request
+		response = self.acerta.session.get(
+			url=f"{self.acerta.base_url}/employee-data-management/v3/employees/{employee_id}/family-situations",
+			params=params,
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+		data = response.json()
+
+		# Normalize family situation segments data
+		df = pd.json_normalize(
+			data,
+			record_path=['familySituationSegments'],
+			meta=['employeeId'],
+			sep='.'
+		)
+
+		# Drop externalReferences columns if they exist
+		external_ref_columns = [col for col in df.columns if 'externalReferences' in col]
+		if external_ref_columns:
+			df = df.drop(columns=external_ref_columns)
+
+		# Validate with schema
+		valid_data, invalid_data = Functions.validate_data(df, FamilySituationGet)
+
+		return valid_data, invalid_data

brynq_sdk_acerta/inservice.py

@@ -0,0 +1,99 @@
+from typing import Dict, Any
+import requests
+from brynq_sdk_functions import Functions
+from .schemas.in_service import EmploymentCreate, EmploymentRehire
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+	from .acerta import Acerta
+
+
+class InService:
+	"""Unified resource for Acerta in-service (hire/rehire) requests.
+
+	- Accepts flat snake_case input and converts it to nested payloads
+	  using Functions.flat_to_nested_with_prefix and Employment* schemas
+	- Posts to the correct employee-in-service-request endpoints
+	- Polls the asynchronous status and returns parsed status data
+	"""
+
+	def __init__(self, acerta):
+		self.acerta: Acerta = acerta
+
+	def hire(self, employer_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+		"""
+		POST /employee-in-service-request/v1/employers/{employerId}/employments - New employee & agreement
+
+		Accepts flat snake_case data (preferred) or already nested data.
+		If flat, converts to nested structure, validates, posts, and polls.
+		Returns the parsed status dict.
+		"""
+		# 1) Support both flat and nested payloads
+		if isinstance(data.get("employee"), dict) and isinstance(data.get("employment"), dict):
+			nested_data = data
+		else:
+			nested_data = Functions.flat_to_nested_with_prefix(data, EmploymentCreate)
+
+		# 2) Validate against in_service schema
+		validated = EmploymentCreate(**nested_data)
+
+		# 3) Make API request
+		response = self.acerta.session.post(
+			url=f"{self.acerta.base_url}/employee-in-service-request/v1/employers/{employer_id}/employments",
+			json=validated.model_dump(by_alias=True, exclude_none=True),
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+
+		# 4) Poll status via Location header
+		location = response.headers.get("Location")
+		request_id = location.rsplit("/", 1)[-1] if location else ""
+		status = self._get_in_service_status(request_id)
+		return status
+
+	def rehire(self, employer_id: str, employee_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+		"""
+		POST /employee-in-service-request/v1/employers/{employerId}/employees/{employeeId}/employments - Existing employee
+
+		Accepts flat snake_case data (preferred) or already nested data.
+		If flat, converts to nested structure, validates, posts, and polls.
+		Returns the parsed status dict.
+		"""
+		# 1) Support both flat and nested payloads
+		if isinstance(data.get("employer"), dict) or isinstance(data.get("employment"), dict):
+			nested_data = data
+		else:
+			nested_data = Functions.flat_to_nested_with_prefix(data, EmploymentRehire)
+
+		# 2) Validate against in_service schema
+		validated = EmploymentRehire(**nested_data)
+
+		# 3) Make API request
+		response = self.acerta.session.post(
+			url=(
+				f"{self.acerta.base_url}/employee-in-service-request/v1/employers/{employer_id}/employees/{employee_id}/employments"
+			),
+			json=validated.model_dump(by_alias=True, exclude_none=True),
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+
+		# 4) Poll status via Location header
+		location = response.headers.get("Location")
+		request_id = location.rsplit("/", 1)[-1] if location else ""
+		status = self._get_in_service_status(request_id)
+		return status
+
+	def _get_in_service_status(self, request_id: str) -> Dict[str, Any]:
+		"""
+		GET /employee-in-service-request/v1/status/{requestId} - Request status
+
+		Returns parsed JSON status response for the asynchronous in-service request.
+		"""
+		endpoint = f"employee-in-service-request/v1/status/{request_id}"
+		response = self.acerta.session.get(
+			url=f"{self.acerta.base_url}/{endpoint}",
+			timeout=self.acerta.TIMEOUT,
+		)
+		response.raise_for_status()
+		data = response.json()
+		return data