valentina-python-client 2.1.0__tar.gz → 2.3.0__tar.gz

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valentina-python-client
-Version: 2.1.0
+Version: 2.3.0
 Summary: Async Python client library for the Valentina Noir API
 Author: Nate Landau
 Author-email: Nate Landau <github@natenate.org>

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/pyproject.toml

@@ -16,7 +16,7 @@
     name = "valentina-python-client"
     readme = "README.md"
     requires-python = ">=3.13"
-    version = "2.1.0"
+    version = "2.3.0"
 
     [project.optional-dependencies]
         testing = ["polyfactory>=3.3.0"]

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/__init__.py

@@ -113,4 +113,4 @@ __all__ = (
     "users_service",
 )
 
-__version__ = "2.1.0"
+__version__ = "2.3.0"

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/_sync/registry.py

@@ -160,7 +160,7 @@ def sync_global_admin_service() -> "SyncGlobalAdminService":
     Example:
         ```python
         admins = sync_global_admin_service()
-        developers = await admins.list_all()
+        developers = await admins.list_all_developers()
         ```
     """
     from vclient._sync.services.global_admin import SyncGlobalAdminService

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/_sync/services/base.py

@@ -381,17 +381,24 @@ class SyncBaseService:
             return None
         return SyncBaseService._parse_rate_limit_header_value(rate_limit_header, "r")
 
-    def _get(self, path: str, *, params: dict[str, Any] | None = None) -> httpx.Response:
+    def _get(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> httpx.Response:
         """Make a GET request.
 
         Args:
             path: API endpoint path.
             params: Query parameters.
+            headers: Additional headers (e.g. an Accept override for binary downloads).
 
         Returns:
             The HTTP response.
         """
-        return self._request("GET", path, params=params)
+        return self._request("GET", path, params=params, headers=headers)
 
     def _merge_on_behalf_of_header(self, headers: dict[str, str] | None) -> dict[str, str] | None:
         """Merge the On-Behalf-Of header into headers when _on_behalf_of is set.

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/_sync/services/global_admin.py

@@ -1,13 +1,27 @@
 # AUTO-GENERATED — do not edit. Run 'uv run duty generate_sync' to regenerate.
 """Service for interacting with the Global Admin API."""
 
+import re
 from collections.abc import Iterator, Sequence
 from datetime import datetime
 
 from vclient._sync.services.base import SyncBaseService
-from vclient.constants import DEFAULT_PAGE_LIMIT, AuditEntityType, AuditLogInclude, AuditOperation
+from vclient.constants import (
+    DEFAULT_LOG_TAIL_LIMIT,
+    DEFAULT_PAGE_LIMIT,
+    MAX_LOG_TAIL_LIMIT,
+    MIN_LOG_TAIL_LIMIT,
+    AuditEntityType,
+    AuditLogInclude,
+    AuditOperation,
+    LogLevel,
+    UserRole,
+)
 from vclient.endpoints import Endpoints
 from vclient.models import (
+    AdminUser,
+    AdminUserCreate,
+    AdminUserUpdate,
     AuditLog,
     AuditLogDetail,
     Developer,
@@ -15,23 +29,48 @@ from vclient.models import (
     DeveloperUpdate,
     DeveloperWithApiKey,
     PaginatedResponse,
+    ServerLogArchive,
+    ServerLogEntry,
 )
 from vclient.services._audit_params import _build_audit_params
 
+_CONTENT_DISPOSITION_FILENAME = re.compile('filename=(?:"([^"]+)"|([^;]+))', re.IGNORECASE)
+
+
+def _filename_from_content_disposition(header: str | None, *, fallback: str) -> str:
+    """Extract the attachment filename from a Content-Disposition header.
+
+    Return ``fallback`` when the header is absent or contains no filename so callers
+    always get a usable name for the downloaded archive.
+
+    Args:
+        header: The raw Content-Disposition header value, or None.
+        fallback: Filename to return when none can be parsed.
+
+    Returns:
+        The parsed filename, or the fallback.
+    """
+    if not header:
+        return fallback
+    match = _CONTENT_DISPOSITION_FILENAME.search(header)
+    if not match:
+        return fallback
+    return (match.group(1) or match.group(2)).strip()
+
 
 class SyncGlobalAdminService(SyncBaseService):
     """Service for global admin operations in the Valentina API.
 
-    Provides methods to create, retrieve, update, and delete developer accounts,
-    as well as manage API keys. Requires global admin privileges.
+    Provides cross-company management of developer accounts and their API keys,
+    plus server log access. Requires global admin privileges.
 
     Example:
         >>> async with SyncVClient() as client:
-        ...     developers = await client.global_admin.list_all()
-        ...     developer = await client.global_admin.get("developer_id")
+        ...     developers = await client.global_admin.list_all_developers()
+        ...     developer = await client.global_admin.get_developer("developer_id")
     """
 
-    def get_page(
+    def get_developer_page(
         self,
         *,
         limit: int = DEFAULT_PAGE_LIMIT,
@@ -55,11 +94,11 @@ class SyncGlobalAdminService(SyncBaseService):
             Endpoints.ADMIN_DEVELOPERS, Developer, limit=limit, offset=offset, params=params
         )
 
-    def list_all(self, *, is_global_admin: bool | None = None) -> list[Developer]:
+    def list_all_developers(self, *, is_global_admin: bool | None = None) -> list[Developer]:
         """Retrieve all developer accounts.
 
-        Automatically paginates through all results. Use `get_page()` for paginated access
-        or `iter_all()` for memory-efficient streaming of large datasets.
+        Automatically paginates through all results. Use `get_developer_page()` for paginated
+        access or `iter_all_developers()` for memory-efficient streaming of large datasets.
 
         Args:
             is_global_admin: Optional filter by global admin status.
@@ -67,9 +106,11 @@ class SyncGlobalAdminService(SyncBaseService):
         Returns:
             A list of all Developer objects.
         """
-        return [developer for developer in self.iter_all(is_global_admin=is_global_admin)]
+        return [
+            developer for developer in self.iter_all_developers(is_global_admin=is_global_admin)
+        ]
 
-    def iter_all(
+    def iter_all_developers(
         self, *, limit: int = 100, is_global_admin: bool | None = None
     ) -> Iterator[Developer]:
         """Iterate through all developer accounts.
@@ -85,18 +126,14 @@ class SyncGlobalAdminService(SyncBaseService):
             Individual Developer objects.
 
         Example:
-            >>> async for developer in client.global_admin.iter_all():
+            >>> async for developer in client.global_admin.iter_all_developers():
             ...     print(developer.username)
         """
-        params = {}
-        if is_global_admin is not None:
-            params["is_global_admin"] = is_global_admin
-        for item in self._iter_all_pages(
-            Endpoints.ADMIN_DEVELOPERS, limit=limit, params=params or None
-        ):
+        params = self._build_params(is_global_admin=is_global_admin)
+        for item in self._iter_all_pages(Endpoints.ADMIN_DEVELOPERS, limit=limit, params=params):
             yield Developer.model_validate(item)
 
-    def get(self, developer_id: str) -> Developer:
+    def get_developer(self, developer_id: str) -> Developer:
         """Retrieve detailed information about a specific developer.
 
         Args:
@@ -112,7 +149,7 @@ class SyncGlobalAdminService(SyncBaseService):
         response = self._get(Endpoints.ADMIN_DEVELOPER.format(developer_id=developer_id))
         return Developer.model_validate(response.json())
 
-    def create(self, request: DeveloperCreate | None = None, **kwargs) -> Developer:
+    def create_developer(self, request: DeveloperCreate | None = None, **kwargs) -> Developer:
         """Create a new developer account.
 
         This creates the account but does not create an API key or grant access to any
@@ -139,7 +176,7 @@ class SyncGlobalAdminService(SyncBaseService):
         )
         return Developer.model_validate(response.json())
 
-    def update(
+    def update_developer(
         self, developer_id: str, request: DeveloperUpdate | None = None, **kwargs
     ) -> Developer:
         """Modify a developer account's properties.
@@ -169,7 +206,7 @@ class SyncGlobalAdminService(SyncBaseService):
         )
         return Developer.model_validate(response.json())
 
-    def delete(self, developer_id: str) -> None:
+    def delete_developer(self, developer_id: str) -> None:
         """Remove a developer account from the system.
 
         The developer's API key will be invalidated immediately.
@@ -183,6 +220,165 @@ class SyncGlobalAdminService(SyncBaseService):
         """
         self._delete(Endpoints.ADMIN_DEVELOPER.format(developer_id=developer_id))
 
+    def get_user_page(
+        self,
+        *,
+        company_id: str | None = None,
+        role: UserRole | None = None,
+        email: str | None = None,
+        is_archived: bool | None = None,
+        limit: int = DEFAULT_PAGE_LIMIT,
+        offset: int = 0,
+    ) -> PaginatedResponse[AdminUser]:
+        """Retrieve a paginated page of users across all companies.
+
+        Authenticates with the global-admin API key only; no On-Behalf-Of header
+        is sent. Archived (soft-deleted) users are included when
+        ``is_archived=True``.
+
+        Args:
+            company_id: Filter to a single company.
+            role: Filter by user role.
+            email: Filter by exact email match.
+            is_archived: Filter by archived state.
+            limit: Maximum number of items to return (0-100, default 10).
+            offset: Number of items to skip from the beginning (default 0).
+
+        Returns:
+            A PaginatedResponse containing AdminUser objects and pagination metadata.
+        """
+        params = self._build_params(
+            company_id=company_id, role=role, email=email, is_archived=is_archived
+        )
+        return self._get_paginated_as(
+            Endpoints.ADMIN_USERS, AdminUser, limit=limit, offset=offset, params=params
+        )
+
+    def list_all_users(
+        self,
+        *,
+        company_id: str | None = None,
+        role: UserRole | None = None,
+        email: str | None = None,
+        is_archived: bool | None = None,
+    ) -> list[AdminUser]:
+        """Retrieve all users across all companies.
+
+        Automatically paginates through all results. Use ``get_user_page()`` for
+        paginated access or ``iter_all_users()`` for memory-efficient streaming.
+
+        Args:
+            company_id: Filter to a single company.
+            role: Filter by user role.
+            email: Filter by exact email match.
+            is_archived: Filter by archived state.
+
+        Returns:
+            A list of all matching AdminUser objects.
+        """
+        return [
+            user
+            for user in self.iter_all_users(
+                company_id=company_id, role=role, email=email, is_archived=is_archived
+            )
+        ]
+
+    def iter_all_users(
+        self,
+        *,
+        limit: int = 100,
+        company_id: str | None = None,
+        role: UserRole | None = None,
+        email: str | None = None,
+        is_archived: bool | None = None,
+    ) -> Iterator[AdminUser]:
+        """Iterate through all users across all companies.
+
+        Yields individual users, automatically fetching subsequent pages until all
+        matching users have been retrieved.
+
+        Args:
+            limit: Items per page (default 100 for efficiency).
+            company_id: Filter to a single company.
+            role: Filter by user role.
+            email: Filter by exact email match.
+            is_archived: Filter by archived state.
+
+        Yields:
+            Individual AdminUser objects.
+        """
+        params = self._build_params(
+            company_id=company_id, role=role, email=email, is_archived=is_archived
+        )
+        for item in self._iter_all_pages(Endpoints.ADMIN_USERS, limit=limit, params=params):
+            yield AdminUser.model_validate(item)
+
+    def get_user(self, user_id: str) -> AdminUser:
+        """Retrieve a single user by ID, including archived users.
+
+        Args:
+            user_id: The ID of the user to retrieve.
+
+        Returns:
+            The AdminUser object, with ``is_archived`` reflecting soft-delete state.
+        """
+        response = self._get(Endpoints.ADMIN_USER.format(user_id=user_id))
+        return AdminUser.model_validate(response.json())
+
+    def create_user(self, request: AdminUserCreate | None = None, **kwargs) -> AdminUser:
+        """Create a user in a target company.
+
+        The role assignment matrix enforced on company-scoped endpoints does not
+        apply here, but the server still rejects ``UNAPPROVED``/``DEACTIVATED`` on
+        create.
+
+        Args:
+            request: An AdminUserCreate model, OR pass fields as keyword arguments.
+            **kwargs: Fields for AdminUserCreate if request is not provided.
+                Requires: company_id, username, email, role.
+
+        Returns:
+            The newly created AdminUser object.
+        """
+        body = request if request is not None else self._validate_request(AdminUserCreate, **kwargs)
+        response = self._post(
+            Endpoints.ADMIN_USERS,
+            json=body.model_dump(exclude_none=True, exclude_unset=True, mode="json"),
+        )
+        return AdminUser.model_validate(response.json())
+
+    def update_user(
+        self, user_id: str, request: AdminUserUpdate | None = None, **kwargs
+    ) -> AdminUser:
+        """Update any user by ID, bypassing the company-scoped role hierarchy.
+
+        Set ``is_archived=False`` to restore a soft-deleted user.
+
+        Args:
+            user_id: The ID of the user to update.
+            request: An AdminUserUpdate model, OR pass fields as keyword arguments.
+            **kwargs: Fields for AdminUserUpdate if request is not provided.
+
+        Returns:
+            The updated AdminUser object.
+        """
+        body = request if request is not None else self._validate_request(AdminUserUpdate, **kwargs)
+        response = self._patch(
+            Endpoints.ADMIN_USER.format(user_id=user_id),
+            json=body.model_dump(exclude_none=True, exclude_unset=True, mode="json"),
+        )
+        return AdminUser.model_validate(response.json())
+
+    def delete_user(self, user_id: str) -> None:
+        """Soft-delete a user by ID.
+
+        The deletion is reversible via ``update_user(user_id, is_archived=False)``.
+
+        Args:
+            user_id: The ID of the user to soft-delete.
+        """
+        self._delete(Endpoints.ADMIN_USER.format(user_id=user_id))
+
     def create_api_key(self, developer_id: str) -> DeveloperWithApiKey:
         """Generate a new API key for a developer.
 
@@ -404,3 +600,47 @@ class SyncGlobalAdminService(SyncBaseService):
             params=params,
         ):
             yield model.model_validate(item)
+
+    def tail_logs(
+        self, *, level: LogLevel | None = None, limit: int = DEFAULT_LOG_TAIL_LIMIT
+    ) -> list[ServerLogEntry]:
+        """Tail the most recent server log entries, newest first.
+
+        Inspect on-disk server logs without shelling into the host. Requires global
+        admin privileges and that file logging is enabled on the server.
+
+        Args:
+            level: Minimum log level to include. Defaults to the server's configured
+                level when omitted.
+            limit: Maximum number of entries to return. Clamped to 1-500 (default 100).
+
+        Returns:
+            A list of ServerLogEntry objects, newest first.
+
+        Raises:
+            AuthorizationError: If you don't have global admin privileges.
+            ConflictError: If file logging is not enabled on the server.
+        """
+        clamped_limit = min(max(limit, MIN_LOG_TAIL_LIMIT), MAX_LOG_TAIL_LIMIT)
+        params = self._build_params(level=level, limit=clamped_limit)
+        response = self._get(Endpoints.ADMIN_LOGS, params=params)
+        return [ServerLogEntry.model_validate(item) for item in response.json()]
+
+    def download_logs(self) -> ServerLogArchive:
+        """Download a zip archive of the server log files.
+
+        Stream the active log file plus rotated backups as a single zip. Requires
+        global admin privileges and that file logging is enabled on the server.
+
+        Returns:
+            A ServerLogArchive with the server-provided filename and raw zip bytes.
+
+        Raises:
+            AuthorizationError: If you don't have global admin privileges.
+            ConflictError: If file logging is not enabled or no log files exist.
+        """
+        response = self._get(Endpoints.ADMIN_LOGS_DOWNLOAD, headers={"Accept": "application/zip"})
+        filename = _filename_from_content_disposition(
+            response.headers.get("Content-Disposition"), fallback="vapi-logs.zip"
+        )
+        return ServerLogArchive(filename=filename, content=response.content)

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/constants.py

@@ -21,6 +21,11 @@ IDEMPOTENT_HTTP_METHODS: frozenset[str] = frozenset({"GET", "PUT", "DELETE"})
 DEFAULT_PAGE_LIMIT = 10
 MAX_PAGE_LIMIT = 100
 
+# Server log tail defaults
+DEFAULT_LOG_TAIL_LIMIT = 100
+MIN_LOG_TAIL_LIMIT = 1
+MAX_LOG_TAIL_LIMIT = 500
+
 # HTTP Status Code Ranges (5xx Server Errors)
 HTTP_500_INTERNAL_SERVER_ERROR = 500
 HTTP_600_UPPER_BOUND = 600
@@ -70,14 +75,16 @@ CharacterInventoryType = Literal[
     "WEAPON",
 ]
 CharacterStatus = Literal["ALIVE", "DEAD"]
-CharacterType = Literal["PLAYER", "NPC", "STORYTELLER", "DEVELOPER"]
+CharacterType = Literal["PLAYER", "NPC", "STORYTELLER"]
 DiceSize = Literal[4, 6, 8, 10, 20, 100]
 FreeTraitChangesPermission = Literal["UNRESTRICTED", "WITHIN_24_HOURS", "STORYTELLER"]
 GameVersion = Literal["V4", "V5"]
 GrantXPPermission = Literal["UNRESTRICTED", "PLAYER", "STORYTELLER"]
 HunterCreed = Literal["ENTREPRENEURIAL", "FAITHFUL", "INQUISITIVE", "MARTIAL", "UNDERGROUND"]
 HunterEdgeType = Literal["ASSETS", "APTITUDES", "ENDOWMENTS"]
+LogLevel = Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
 ManageCampaignPermission = Literal["UNRESTRICTED", "STORYTELLER"]
+ManageNPCPermission = Literal["UNRESTRICTED", "STORYTELLER"]
 PermissionLevel = Literal["USER", "ADMIN", "OWNER", "REVOKE"]
 RecoupXPPermission = Literal["UNRESTRICTED", "DENIED", "WITHIN_SESSION"]
 RollResultType = Literal["SUCCESS", "FAILURE", "BOTCH", "CRITICAL", "OTHER"]

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/endpoints.py

@@ -27,6 +27,10 @@ class Endpoints:
     ADMIN_DEVELOPER = f"{_BASE}/admin/developers/{{developer_id}}"
     ADMIN_DEVELOPER_NEW_KEY = f"{_BASE}/admin/developers/{{developer_id}}/new-key"
     ADMIN_DEVELOPER_AUDIT_LOGS = f"{ADMIN_DEVELOPER}/audit-logs"
+    ADMIN_LOGS = f"{_BASE}/admin/logs"
+    ADMIN_LOGS_DOWNLOAD = f"{ADMIN_LOGS}/download"
+    ADMIN_USERS = f"{_BASE}/admin/users"
+    ADMIN_USER = f"{_BASE}/admin/users/{{user_id}}"
 
     # Developer endpoints (self-service)
     DEVELOPER_ME = f"{_BASE}/developers/me"

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/models/__init__.py

@@ -107,6 +107,8 @@ from .global_admin import (
     DeveloperCreate,
     DeveloperUpdate,
     DeveloperWithApiKey,
+    ServerLogArchive,
+    ServerLogEntry,
 )
 from .pagination import PaginatedResponse
 from .shared import (
@@ -125,6 +127,9 @@ from .user_lookup import (
     UserLookupResult,
 )
 from .users import (
+    AdminUser,
+    AdminUserCreate,
+    AdminUserUpdate,
     CampaignExperience,
     DiscordProfile,
     DiscordProfileUpdate,
@@ -144,6 +149,9 @@ from .users import (
 )
 
 __all__ = [
+    "AdminUser",
+    "AdminUserCreate",
+    "AdminUserUpdate",
     "Asset",
     "AuditLog",
     "AuditLogDetail",
@@ -222,6 +230,8 @@ __all__ = [
     "QuickrollCreate",
     "QuickrollUpdate",
     "RollStatistics",
+    "ServerLogArchive",
+    "ServerLogEntry",
     "SheetSection",
     "SystemHealth",
     "Trait",

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/models/characters.py

@@ -190,8 +190,12 @@ class Character(BaseModel):
     concept_name: str | None = Field(default=None, description="Name of the character concept.")
 
     # Relationships
-    user_creator_id: str = Field(..., description="ID of the user who created the character.")
-    user_player_id: str = Field(..., description="ID of the user who plays the character.")
+    user_creator_id: str | None = Field(
+        default=None, description="ID of the user who created the character."
+    )
+    user_player_id: str | None = Field(
+        default=None, description="ID of the user who plays the character."
+    )
     company_id: str = Field(..., description="ID of the company.")
     campaign_id: str = Field(..., description="ID of the campaign.")
 

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/models/companies.py

@@ -9,6 +9,7 @@ from vclient.constants import (
     FreeTraitChangesPermission,
     GrantXPPermission,
     ManageCampaignPermission,
+    ManageNPCPermission,
     PermissionLevel,
     RecoupXPPermission,
 )
@@ -27,6 +28,7 @@ class CompanySettings(BaseModel):
     character_autogen_num_choices: int
     character_autogen_starting_points: int
     permission_manage_campaign: ManageCampaignPermission
+    permission_manage_npc: ManageNPCPermission
     permission_grant_xp: GrantXPPermission
     permission_free_trait_changes: FreeTraitChangesPermission
     permission_recoup_xp: RecoupXPPermission
@@ -42,6 +44,7 @@ class CompanySettingsCreate(BaseModel):
     character_autogen_num_choices: int | None = None
     character_autogen_starting_points: int | None = None
     permission_manage_campaign: ManageCampaignPermission | None = None
+    permission_manage_npc: ManageNPCPermission | None = None
     permission_grant_xp: GrantXPPermission | None = None
     permission_free_trait_changes: FreeTraitChangesPermission | None = None
     permission_recoup_xp: RecoupXPPermission | None = None
@@ -57,6 +60,7 @@ class CompanySettingsUpdate(BaseModel):
     character_autogen_num_choices: int | None = None
     character_autogen_starting_points: int | None = None
     permission_manage_campaign: ManageCampaignPermission | None = None
+    permission_manage_npc: ManageNPCPermission | None = None
     permission_grant_xp: GrantXPPermission | None = None
     permission_free_trait_changes: FreeTraitChangesPermission | None = None
     permission_recoup_xp: RecoupXPPermission | None = None

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/models/global_admin.py

@@ -1,8 +1,10 @@
 """Pydantic models for Global Admin API responses."""
 
+from dataclasses import dataclass
 from datetime import datetime
+from typing import Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from vclient.constants import PermissionLevel
 
@@ -70,10 +72,40 @@ class DeveloperUpdate(BaseModel):
     is_global_admin: bool | None = None
 
 
+class ServerLogEntry(BaseModel):
+    """A single parsed server log entry from the admin logs tail endpoint.
+
+    Every field is nullable because individual log lines may omit values or fail
+    to parse as structured JSON (in which case ``raw`` holds the original line).
+    """
+
+    timestamp: str | None = None
+    level: str | None = None
+    name: str | None = None
+    message: str | None = None
+    exception: str | None = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+    raw: str | None = None
+
+
+@dataclass(frozen=True)
+class ServerLogArchive:
+    """A downloaded server-log zip archive.
+
+    Pairs the server-provided ``Content-Disposition`` filename with the raw zip
+    bytes so callers can write the archive straight to disk.
+    """
+
+    filename: str
+    content: bytes
+
+
 __all__ = [
     "Developer",
     "DeveloperCompanyPermission",
     "DeveloperCreate",
     "DeveloperUpdate",
     "DeveloperWithApiKey",
+    "ServerLogArchive",
+    "ServerLogEntry",
 ]

{valentina_python_client-2.1.0 → valentina_python_client-2.3.0}/src/vclient/models/users.py

@@ -122,6 +122,17 @@ class UserDetail(User):
     )
 
 
+class AdminUser(User):
+    """Response model for a user returned by the global-admin user endpoints.
+
+    Extends the tenant-scoped ``User`` with ``is_archived``, which is always
+    present on the admin endpoints so callers can identify soft-deleted users
+    directly from the response body.
+    """
+
+    is_archived: bool
+
+
 # -----------------------------------------------------------------------------
 # User Request Models
 # -----------------------------------------------------------------------------
@@ -194,6 +205,27 @@ class UserUpdate(BaseModel):
     github_profile: GitHubProfile | None = None
 
 
+class AdminUserCreate(UserCreate):
+    """Request body for creating a user as a global admin.
+
+    Extends the tenant-scoped ``UserCreate`` with an explicit ``company_id`` for
+    the target company. The server rejects ``UNAPPROVED``/``DEACTIVATED`` roles
+    on create, so no client-side role restriction is applied here.
+    """
+
+    company_id: str
+
+
+class AdminUserUpdate(UserUpdate):
+    """Request body for updating any user as a global admin.
+
+    Extends the tenant-scoped ``UserUpdate`` with ``is_archived``. Set it to
+    ``False`` to restore a soft-deleted user.
+    """
+
+    is_archived: bool | None = None
+
+
 class UserApproveDTO(BaseModel):
     """Approve an unapproved user and assign a role."""
 
@@ -262,6 +294,9 @@ class _ExperienceAddRemove(BaseModel):
 
 
 __all__ = [
+    "AdminUser",
+    "AdminUserCreate",
+    "AdminUserUpdate",
     "CampaignExperience",
     "DiscordProfile",
     "GitHubProfile",