weclapp-client 0.1.0a1__py3-none-any.whl

weclapp_client/__init__.py

@@ -0,0 +1,49 @@
+"""
+Typed Python client for the weclapp REST API v2, focused on the endpoints needed to synchronise employee master data.
+"""
+
+from weclapp_client._version import __version__
+from weclapp_client.client import WeclappClient
+from weclapp_client.config import WeclappConfig
+from weclapp_client.exceptions import (
+    AmbiguousResultError,
+    AuthenticationError,
+    ConflictError,
+    CustomAttributeDefinitionError,
+    InvalidQueryError,
+    NotFoundError,
+    OptimisticLockError,
+    PermissionDeniedError,
+    RateLimitError,
+    ServerError,
+    ValidationIssue,
+    WeclappApiError,
+    WeclappConfigurationError,
+    WeclappConnectionError,
+    WeclappError,
+    WeclappValidationError,
+)
+from weclapp_client.query import Filter
+
+__all__ = [
+    "AmbiguousResultError",
+    "AuthenticationError",
+    "ConflictError",
+    "CustomAttributeDefinitionError",
+    "Filter",
+    "InvalidQueryError",
+    "NotFoundError",
+    "OptimisticLockError",
+    "PermissionDeniedError",
+    "RateLimitError",
+    "ServerError",
+    "ValidationIssue",
+    "WeclappApiError",
+    "WeclappClient",
+    "WeclappConfig",
+    "WeclappConfigurationError",
+    "WeclappConnectionError",
+    "WeclappError",
+    "WeclappValidationError",
+    "__version__",
+]

weclapp_client/_converters.py

@@ -0,0 +1,70 @@
+"""
+Conversion between the weclapp representation of dates (milliseconds since the Unix epoch) and Python objects.
+
+The arithmetic uses ``timedelta`` instead of ``datetime.fromtimestamp``: birth dates before 1970 have negative
+timestamps, which ``fromtimestamp`` cannot handle on Windows.
+"""
+
+from datetime import UTC, date, datetime, timedelta
+from typing import Annotated
+
+from pydantic import BeforeValidator, PlainSerializer
+
+_EPOCH = datetime(1970, 1, 1, tzinfo=UTC)
+_ONE_MILLISECOND = timedelta(milliseconds=1)
+_HALF_DAY = timedelta(hours=12)
+
+
+def ms_to_datetime(milliseconds: int) -> datetime:
+    """Converts a weclapp timestamp to a timezone-aware ``datetime`` in UTC."""
+    return _EPOCH + timedelta(milliseconds=milliseconds)
+
+
+def datetime_to_ms(value: datetime) -> int:
+    """Converts a timezone-aware ``datetime`` to a weclapp timestamp."""
+    if value.tzinfo is None or value.utcoffset() is None:
+        raise ValueError("naive datetimes are ambiguous, please pass a timezone-aware datetime")
+    return (value - _EPOCH) // _ONE_MILLISECOND
+
+
+def ms_to_date(milliseconds: int) -> date:
+    """
+    Converts the timestamp of a date-only field (e.g. ``birthDate``) to a ``date``.
+
+    The timestamp is rounded to the nearest midnight (UTC). This yields the intended date no matter whether weclapp
+    stored midnight UTC or midnight in a local timezone such as Europe/Berlin (i.e. 22:00 or 23:00 UTC of the day
+    before).
+    """
+    return (ms_to_datetime(milliseconds) + _HALF_DAY).date()
+
+
+def date_to_ms(value: date) -> int:
+    """Converts a ``date`` to the timestamp of midnight UTC of that day."""
+    return datetime_to_ms(datetime(value.year, value.month, value.day, tzinfo=UTC))
+
+
+def _parse_date(value: object) -> object:
+    if isinstance(value, int) and not isinstance(value, bool):
+        return ms_to_date(value)
+    return value
+
+
+def _parse_datetime(value: object) -> object:
+    if isinstance(value, int) and not isinstance(value, bool):
+        return ms_to_datetime(value)
+    return value
+
+
+WeclappDate = Annotated[
+    date,
+    BeforeValidator(_parse_date),
+    PlainSerializer(date_to_ms, return_type=int, when_used="json"),
+]
+"""a date-only field; weclapp sends and expects milliseconds since the epoch"""
+
+WeclappDateTime = Annotated[
+    datetime,
+    BeforeValidator(_parse_datetime),
+    PlainSerializer(datetime_to_ms, return_type=int, when_used="json"),
+]
+"""a timestamp field; weclapp sends and expects milliseconds since the epoch"""

weclapp_client/_http.py

@@ -0,0 +1,258 @@
+"""
+HTTP transport: authentication, headers, timeouts, retries and the mapping of error responses to exceptions.
+
+Retry rules (with exponential backoff and jitter):
+
+- ``429 Too Many Requests`` and failed connection attempts are retried for every method, because weclapp did not
+  process these requests.
+- ``502``/``503``/``504`` and other network errors (e.g. read timeouts) are only retried for idempotent methods
+  (``GET``, ``PUT``, ``DELETE``). A ``POST`` might already have created the entity, so it is not repeated; callers
+  should look up an entity before creating it.
+"""
+
+import logging
+import random
+import time
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from weclapp_client._version import __version__
+from weclapp_client.config import WeclappConfig
+from weclapp_client.exceptions import (
+    AuthenticationError,
+    ConflictError,
+    NotFoundError,
+    OptimisticLockError,
+    PermissionDeniedError,
+    RateLimitError,
+    ServerError,
+    ValidationIssue,
+    WeclappApiError,
+    WeclappConnectionError,
+    WeclappError,
+    WeclappValidationError,
+)
+
+_logger = logging.getLogger("weclapp_client")
+
+QueryParams = Sequence[tuple[str, str]]
+
+_IDEMPOTENT_METHODS = frozenset({"GET", "PUT", "DELETE"})
+_RETRY_STATUS_ALWAYS = frozenset({429})
+_RETRY_STATUS_IDEMPOTENT = frozenset({429, 502, 503, 504})
+_NOT_SENT_ERRORS = (httpx.ConnectError, httpx.ConnectTimeout, httpx.PoolTimeout)
+"""transport errors that occur before the request reached weclapp"""
+_IDEMPOTENT_RETRY_ERRORS = (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError)
+_WAIT_WARNING_THRESHOLD_MS = 5000
+_MAX_MESSAGE_LENGTH = 500
+
+_ERROR_CLASSES: Mapping[int, type[WeclappApiError]] = {
+    400: WeclappValidationError,
+    401: AuthenticationError,
+    403: PermissionDeniedError,
+    404: NotFoundError,
+    409: ConflictError,
+    429: RateLimitError,
+}
+
+
+def entity_path(resource_path: str, entity_id: str) -> str:
+    """Returns the path of a single entity, e.g. ``user/id/4711``; the id is URL-encoded."""
+    return f"{resource_path}/id/{quote(entity_id, safe='')}"
+
+
+def _last_path_segment(value: object) -> str | None:
+    if not isinstance(value, str) or not value:
+        return None
+    return value.rsplit("/", 1)[-1]
+
+
+def _optional_str(value: object) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _parse_validation_issue(raw: object) -> ValidationIssue | None:
+    if not isinstance(raw, dict):
+        return None
+    allowed = raw.get("allowed")
+    return ValidationIssue(
+        type=_last_path_segment(raw.get("type")),
+        title=_optional_str(raw.get("title")),
+        detail=_optional_str(raw.get("detail")),
+        error_code=_optional_str(raw.get("errorCode")),
+        instance=_optional_str(raw.get("instance")),
+        location=_optional_str(raw.get("location")),
+        allowed=tuple(str(item) for item in allowed) if isinstance(allowed, list) else (),
+    )
+
+
+def error_from_response(response: httpx.Response) -> WeclappApiError:
+    """Maps an error response of the weclapp API to the matching :class:`WeclappApiError` subclass."""
+    status = response.status_code
+    body: object = None
+    try:
+        body = response.json()
+    except ValueError:
+        body = None
+    problem: Mapping[str, Any] = body if isinstance(body, dict) else {}
+
+    problem_type = _last_path_segment(problem.get("type"))
+    title = _optional_str(problem.get("title"))
+    detail = _optional_str(problem.get("detail"))
+    raw_issues = problem.get("validationErrors")
+    issues = tuple(
+        issue for issue in map(_parse_validation_issue, raw_issues if isinstance(raw_issues, list) else []) if issue
+    )
+    text = response.text.strip() if not problem else ""
+    message = detail or title or _optional_str(problem.get("error")) or text or response.reason_phrase or "error"
+    if len(message) > _MAX_MESSAGE_LENGTH:
+        message = message[:_MAX_MESSAGE_LENGTH] + "..."
+
+    if status == 409 and problem_type == "optimistic_lock":
+        error_class: type[WeclappApiError] = OptimisticLockError
+    elif status >= 500:
+        error_class = ServerError
+    else:
+        error_class = _ERROR_CLASSES.get(status, WeclappApiError)
+    return error_class(
+        message,
+        status_code=status,
+        problem_type=problem_type,
+        title=title,
+        detail=detail,
+        instance=_optional_str(problem.get("instance")),
+        validation_errors=issues,
+    )
+
+
+class HttpTransport:
+    """
+    Sends requests to the weclapp API. Internal; use :class:`weclapp_client.WeclappClient` instead.
+
+    :param http_client: an existing client (e.g. with a mock transport for tests); it is not closed by :meth:`close`
+    :param sleep: used to wait between retries (injectable for tests)
+    :param jitter: returns a random number in ``[0, 1)`` that randomises the backoff (injectable for tests)
+    """
+
+    def __init__(
+        self,
+        config: WeclappConfig,
+        http_client: httpx.Client | None = None,
+        *,
+        sleep: Callable[[float], None] = time.sleep,
+        jitter: Callable[[], float] = random.random,
+    ) -> None:
+        self._config = config
+        self._timeout = httpx.Timeout(config.timeout_seconds, connect=config.connect_timeout_seconds)
+        self._owns_client = http_client is None
+        self._client = http_client if http_client is not None else httpx.Client(timeout=self._timeout)
+        self._sleep = sleep
+        self._jitter = jitter
+        self._headers = {
+            "AuthenticationToken": config.api_token.get_secret_value(),
+            "Accept": "application/json",
+            "User-Agent": config.user_agent or f"weclapp-client-py/{__version__}",
+        }
+
+    def close(self) -> None:
+        """Closes the underlying HTTP client if this transport created it."""
+        if self._owns_client:
+            self._client.close()
+
+    def request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: QueryParams = (),
+        json_body: Mapping[str, Any] | None = None,
+    ) -> Any:
+        """Sends a request and returns the decoded JSON body of the successful response."""
+        response = self.request(method, path, params=params, json_body=json_body)
+        try:
+            return response.json()
+        except ValueError as error:
+            raise WeclappError(f"weclapp returned an invalid JSON body for {method} {path}") from error
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: QueryParams = (),
+        json_body: Mapping[str, Any] | None = None,
+    ) -> httpx.Response:
+        """
+        Sends a request, retries it where that is safe and returns the successful response.
+
+        :param path: path relative to the base URL, e.g. ``user/id/4711``
+        :raises WeclappApiError: (or a subclass) if weclapp answers with an error status
+        :raises WeclappConnectionError: if weclapp cannot be reached
+        """
+        method = method.upper()
+        idempotent = method in _IDEMPOTENT_METHODS
+        retry_status = _RETRY_STATUS_IDEMPOTENT if idempotent else _RETRY_STATUS_ALWAYS
+        url = self._config.base_url + path.lstrip("/")
+        attempt = 0
+        while True:
+            try:
+                response = self._client.request(
+                    method,
+                    url,
+                    params=list(params),
+                    json=json_body,
+                    headers=self._headers,
+                    timeout=self._timeout,
+                )
+            except httpx.TransportError as error:
+                retryable = isinstance(error, _NOT_SENT_ERRORS) or (
+                    idempotent and isinstance(error, _IDEMPOTENT_RETRY_ERRORS)
+                )
+                if retryable and attempt < self._config.max_retries:
+                    self._wait_before_retry(method, path, attempt, type(error).__name__)
+                    attempt += 1
+                    continue
+                raise WeclappConnectionError(f"{method} {path} failed: {type(error).__name__}") from error
+
+            self._log_response(method, path, response)
+            if response.status_code in retry_status and attempt < self._config.max_retries:
+                self._wait_before_retry(method, path, attempt, f"HTTP {response.status_code}")
+                attempt += 1
+                continue
+            if response.is_error:
+                raise error_from_response(response)
+            return response
+
+    def _wait_before_retry(self, method: str, path: str, attempt: int, reason: str) -> None:
+        delay = min(self._config.backoff_max_seconds, self._config.backoff_initial_seconds * 2**attempt)
+        delay *= 0.5 + 0.5 * self._jitter()
+        _logger.warning(
+            "Retrying %s %s after %s in %.1f s (retry %d of %d)",
+            method,
+            path,
+            reason,
+            delay,
+            attempt + 1,
+            self._config.max_retries,
+        )
+        self._sleep(delay)
+
+    @staticmethod
+    def _log_response(method: str, path: str, response: httpx.Response) -> None:
+        # only method, path and status are logged: query parameters and bodies may contain personal data
+        _logger.debug("%s %s -> %d", method, path, response.status_code)
+        wait_ms = response.headers.get("X-Weclapp-Wait-Ms")
+        if wait_ms is None or not wait_ms.isdigit():
+            return
+        level = logging.WARNING if int(wait_ms) >= _WAIT_WARNING_THRESHOLD_MS else logging.DEBUG
+        _logger.log(
+            level,
+            "weclapp delayed %s %s by %s ms (reason: %s)",
+            method,
+            path,
+            wait_ms,
+            response.headers.get("X-Weclapp-Wait-Reason", "unknown"),
+        )

weclapp_client/_version.py

@@ -0,0 +1,10 @@
+"""
+Version of the installed distribution (derived from git tags by hatch-vcs at build time).
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("weclapp-client")
+except PackageNotFoundError:  # pragma: no cover - only happens when the package is used without being installed
+    __version__ = "0.0.0"

weclapp_client/client.py

@@ -0,0 +1,52 @@
+"""
+The entry point of the package: :class:`WeclappClient`.
+"""
+
+from types import TracebackType
+from typing import Self
+
+import httpx
+
+from weclapp_client._http import HttpTransport
+from weclapp_client.config import WeclappConfig
+from weclapp_client.resources.custom_attribute_definitions import CustomAttributeDefinitionsResource
+from weclapp_client.resources.employees import EmployeesResource
+from weclapp_client.resources.users import UsersResource
+
+
+class WeclappClient:
+    """
+    Client for the weclapp REST API v2.
+
+    Use it as a context manager, so the HTTP connections are closed afterwards::
+
+        with WeclappClient(WeclappConfig.from_env()) as client:
+            user = client.users.current()
+
+    :param http_client: an existing ``httpx.Client``, e.g. with a mock transport for tests; it is not closed by the
+        weclapp client
+    """
+
+    def __init__(self, config: WeclappConfig, *, http_client: httpx.Client | None = None) -> None:
+        self._transport = HttpTransport(config, http_client)
+        self.users = UsersResource(self._transport)
+        """``/user``: the accounts that hold name and e-mail address of employees"""
+        self.employees = EmployeesResource(self._transport)
+        """``/employee``: the HR records, each linked to a user"""
+        self.custom_attribute_definitions = CustomAttributeDefinitionsResource(self._transport)
+        """``/customAttributeDefinition``: the definitions of custom attributes"""
+
+    def close(self) -> None:
+        """Closes the HTTP connections (unless the ``httpx.Client`` was passed in)."""
+        self._transport.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()

weclapp_client/config.py

@@ -0,0 +1,97 @@
+"""
+Configuration of the weclapp client.
+"""
+
+import os
+import re
+from collections.abc import Mapping
+from typing import Any, Self
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, field_validator
+
+from weclapp_client.exceptions import WeclappConfigurationError
+
+_TENANT_PATTERN = re.compile(r"^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$")
+
+ENV_BASE_URL = "WECLAPP_BASE_URL"
+ENV_TENANT = "WECLAPP_TENANT"
+ENV_API_TOKEN = "WECLAPP_API_TOKEN"
+
+
+def tenant_base_url(tenant: str) -> str:
+    """
+    Returns the base URL of the REST API v2 of the given weclapp tenant, e.g. ``"acme"`` becomes
+    ``"https://acme.weclapp.com/webapp/api/v2/"``.
+    """
+    normalized = tenant.strip().lower()
+    if not _TENANT_PATTERN.fullmatch(normalized):
+        raise WeclappConfigurationError(f"Invalid weclapp tenant name: {tenant!r}")
+    return f"https://{normalized}.weclapp.com/webapp/api/v2/"
+
+
+class WeclappConfig(BaseModel):
+    """
+    Connection settings for the weclapp REST API v2.
+
+    The API token is stored as :class:`~pydantic.SecretStr`, so it does not show up in ``repr``, logs or exceptions.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    base_url: str
+    """base URL of the REST API v2, e.g. ``https://<tenant>.weclapp.com/webapp/api/v2/``"""
+    api_token: SecretStr
+    """API token of the (technical) weclapp user, sent in the ``AuthenticationToken`` header"""
+    timeout_seconds: float = Field(default=60.0, gt=0)
+    """timeout for a single request; weclapp recommends at least one minute"""
+    connect_timeout_seconds: float = Field(default=10.0, gt=0)
+    """timeout for establishing the connection"""
+    max_retries: int = Field(default=5, ge=0)
+    """how often a request is retried if that is safe (see the README for the retry rules)"""
+    backoff_initial_seconds: float = Field(default=1.0, ge=0)
+    """delay before the first retry; it doubles with every further retry"""
+    backoff_max_seconds: float = Field(default=30.0, ge=0)
+    """upper limit for the delay between two retries"""
+    user_agent: str | None = None
+    """value of the ``User-Agent`` header; defaults to ``weclapp-client-py/<version>``"""
+
+    @field_validator("base_url")
+    @classmethod
+    def _normalize_base_url(cls, value: str) -> str:
+        normalized = value.strip()
+        if not normalized.startswith(("https://", "http://")):
+            raise ValueError("base_url must start with https:// (or http:// for local test servers)")
+        return normalized.rstrip("/") + "/"
+
+    @classmethod
+    def for_tenant(cls, tenant: str, api_token: str | SecretStr, **settings: Any) -> Self:
+        """
+        Creates the configuration for the weclapp tenant ``https://<tenant>.weclapp.com``.
+
+        :param settings: further fields of this class, e.g. ``timeout_seconds``
+        """
+        token = api_token if isinstance(api_token, SecretStr) else SecretStr(api_token)
+        return cls(base_url=tenant_base_url(tenant), api_token=token, **settings)
+
+    @classmethod
+    def from_env(cls, environ: Mapping[str, str] | None = None, **settings: Any) -> Self:
+        """
+        Creates the configuration from environment variables:
+
+        - ``WECLAPP_API_TOKEN`` (required)
+        - ``WECLAPP_BASE_URL`` or, alternatively, ``WECLAPP_TENANT``
+
+        :param environ: the variables to read from; defaults to :data:`os.environ`
+        :param settings: further fields of this class, e.g. ``timeout_seconds``
+        """
+        variables = os.environ if environ is None else environ
+        api_token = variables.get(ENV_API_TOKEN, "").strip()
+        if not api_token:
+            raise WeclappConfigurationError(f"Environment variable {ENV_API_TOKEN} is not set")
+        base_url = variables.get(ENV_BASE_URL, "").strip()
+        if base_url:
+            return cls(base_url=base_url, api_token=SecretStr(api_token), **settings)
+        tenant = variables.get(ENV_TENANT, "").strip()
+        if tenant:
+            return cls.for_tenant(tenant, api_token, **settings)
+        raise WeclappConfigurationError(f"Neither {ENV_BASE_URL} nor {ENV_TENANT} is set")

weclapp_client/exceptions.py

@@ -0,0 +1,111 @@
+"""
+Exceptions raised by the weclapp client.
+
+All exceptions derive from :class:`WeclappError`. Errors returned by the weclapp API derive from
+:class:`WeclappApiError` and carry the parsed problem details (weclapp uses a structure based on RFC 7807).
+"""
+
+from dataclasses import dataclass
+
+
+class WeclappError(Exception):
+    """Base class of all errors raised by this package."""
+
+
+class WeclappConfigurationError(WeclappError):
+    """The client configuration is incomplete or invalid (e.g. a missing environment variable)."""
+
+
+class WeclappConnectionError(WeclappError):
+    """The weclapp API could not be reached (network error or timeout), even after all retries."""
+
+
+class InvalidQueryError(WeclappError, ValueError):
+    """
+    A query uses a property that is unknown or not filterable/sortable for the resource.
+
+    weclapp silently ignores unknown filter parameters, so such a query is rejected before it is sent.
+    """
+
+
+class AmbiguousResultError(WeclappError):
+    """A lookup that expects at most one result matched several entities."""
+
+
+class CustomAttributeDefinitionError(WeclappError):
+    """A custom attribute definition does not exist or does not have the expected type."""
+
+
+@dataclass(frozen=True, kw_only=True)
+class ValidationIssue:
+    """One entry of the ``validationErrors`` list of a weclapp error response."""
+
+    type: str | None = None
+    """the problem type, i.e. the part of the weclapp ``type`` URI after the last ``/`` (e.g. ``"reference"``)"""
+    title: str | None = None
+    detail: str | None = None
+    error_code: str | None = None
+    instance: str | None = None
+    location: str | None = None
+    """JSON path of the affected property"""
+    allowed: tuple[str, ...] = ()
+
+
+class WeclappApiError(WeclappError):
+    """The weclapp API answered with an HTTP error status."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        problem_type: str | None = None,
+        title: str | None = None,
+        detail: str | None = None,
+        instance: str | None = None,
+        validation_errors: tuple[ValidationIssue, ...] = (),
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.problem_type = problem_type
+        """the part of the weclapp ``type`` URI after the last ``/`` (e.g. ``"optimistic_lock"``)"""
+        self.title = title
+        self.detail = detail
+        self.instance = instance
+        self.validation_errors = validation_errors
+
+    def __str__(self) -> str:
+        return f"{self.message} (HTTP {self.status_code})"
+
+
+class AuthenticationError(WeclappApiError):
+    """HTTP 401: the API token is missing or invalid."""
+
+
+class PermissionDeniedError(WeclappApiError):
+    """HTTP 403: the API user lacks the permission for the requested operation or property."""
+
+
+class NotFoundError(WeclappApiError):
+    """HTTP 404: the requested entity or resource does not exist."""
+
+
+class WeclappValidationError(WeclappApiError):
+    """HTTP 400: the request was rejected, see :attr:`validation_errors` for the affected properties."""
+
+
+class ConflictError(WeclappApiError):
+    """HTTP 409: the operation is not possible in the current state of the entity."""
+
+
+class OptimisticLockError(ConflictError):
+    """HTTP 409 ``optimistic_lock``: the entity was changed in the meantime, re-read it and try again."""
+
+
+class RateLimitError(WeclappApiError):
+    """HTTP 429: weclapp rejected the request due to load, even after all retries."""
+
+
+class ServerError(WeclappApiError):
+    """HTTP 5xx: weclapp failed to process the request."""

weclapp_client/models/__init__.py

@@ -0,0 +1,26 @@
+"""
+Models of the weclapp entities: read models (as returned by weclapp) and write models (for creating and updating).
+"""
+
+from weclapp_client.models.base import WeclappCreateModel, WeclappEntity, WeclappModel, WeclappUpdateModel
+from weclapp_client.models.custom_attribute import CustomAttribute, CustomAttributeDefinition, CustomAttributeType
+from weclapp_client.models.employee import Employee, EmployeeCreate, EmployeeUpdate, EmploymentStatus
+from weclapp_client.models.user import User, UserCreate, UserStatus, UserUpdate
+
+__all__ = [
+    "CustomAttribute",
+    "CustomAttributeDefinition",
+    "CustomAttributeType",
+    "Employee",
+    "EmployeeCreate",
+    "EmployeeUpdate",
+    "EmploymentStatus",
+    "User",
+    "UserCreate",
+    "UserStatus",
+    "UserUpdate",
+    "WeclappCreateModel",
+    "WeclappEntity",
+    "WeclappModel",
+    "WeclappUpdateModel",
+]