altrepo: add all API methods and models

src/altrepo/api/methods.py

@@ -20,10 +20,12 @@ class BaseAPI:
                 return await resp.json()
             case 400:
                 raise errors.RequestValidationError(
-                    "Request parameters validation error (400)")
+                    "Request parameters validation error (400)"
+                )
             case 404:
                 raise errors.DataNotFoundError(
-                    "Requested data not found in database (404)")
+                    "Requested data not found in database (404)"
+                )
             case 429:
                 raise errors.TooManyRequests("Too Many Requests (429)")
             case _:
@@ -36,8 +38,12 @@ class BaseAPI:
     async def get(self, path: str, params: dict = None):
         url = f"{self.BASE_URL}/{path.lstrip('/')}"
         if params:
-            query = urlencode({k: ",".join(v) if isinstance(
-                v, list) else v for k, v in params.items()})
+            query = urlencode(
+                {
+                    k: ",".join(v) if isinstance(v, list) else v
+                    for k, v in params.items()
+                }
+            )
             url += f"?{query}"
         async with self.session.get(url) as resp:
             return await self._handle_response(resp)
@@ -48,6 +54,36 @@ class BaseAPI:
         async with self.session.post(url, data=data, json=json) as resp:
             return await self._handle_response(resp)
 
+    async def get_text(self, path: str, params: dict = None) -> str:
+        url = f"{self.BASE_URL}/{path.lstrip('/')}"
+        if params:
+            query = urlencode(
+                {
+                    k: ",".join(v) if isinstance(v, list) else v
+                    for k, v in params.items()
+                }
+            )
+            url += f"?{query}"
+        async with self.session.get(url) as resp:
+            if resp.status == 200:
+                return await resp.text()
+            await self._handle_response(resp)
+
+    async def get_bytes(self, path: str, params: dict = None) -> bytes:
+        url = f"{self.BASE_URL}/{path.lstrip('/')}"
+        if params:
+            query = urlencode(
+                {
+                    k: ",".join(v) if isinstance(v, list) else v
+                    for k, v in params.items()
+                }
+            )
+            url += f"?{query}"
+        async with self.session.get(url) as resp:
+            if resp.status == 200:
+                return await resp.read()
+            await self._handle_response(resp)
+
 
 class APIInfo:
     def __init__(self, client: BaseAPI):
@@ -61,7 +97,7 @@ class APIInfo:
 class TaskProcessInfo:
     def __init__(self, client: BaseAPI):
         self.client = client
-        
+
     async def find_tasks(
         self,
         input: list[str],
@@ -72,29 +108,224 @@ class TaskProcessInfo:
         by_package: bool = False,
     ) -> models.TasksListModel:
         params = {
-            k : v for k, v in {
+            k: v
+            for k, v in {
                 "input": input,
                 "owner": owner,
                 "branch": branch,
                 "state": state,
                 "tasks_limit": tasks_limit,
-                "by_package": by_package
-            }.items() if v is not None
+                "by_package": by_package,
+            }.items()
+            if v is not None
         }
         data = await self.client.get("/task/progress/find_tasks", params)
         return models.TasksListModel(**data)
-    
-    
+
     async def task_info(self, task_id: int) -> models.TaskProgressTaskInfoModel:
         data = await self.client.get(f"/task/progress/task_info/{task_id}")
         return models.TaskProgressTaskInfoModel(**data)
 
+    async def all_packagesets(self) -> models.AllTasksBranchesModel:
+        data = await self.client.get("/task/progress/all_packagesets")
+        return models.AllTasksBranchesModel(**data)
+
+    async def all_tasks_branches(self) -> models.AllTasksBranchesModel:
+        data = await self.client.get("/task/progress/all_tasks_branches")
+        return models.AllTasksBranchesModel(**data)
+
+    async def find_tasks_lookup(
+        self,
+        input: list[str],
+        branch: str | None = None,
+        tasks_limit: int = 10,
+    ) -> models.FindTasksModel:
+        params = {
+            k: v
+            for k, v in {
+                "input": input,
+                "branch": branch,
+                "tasks_limit": tasks_limit,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/task/progress/find_tasks_lookup", params)
+        return models.FindTasksModel(**data)
+
+    async def last_tasks(
+        self, branch: str | None = None, tasks_limit: int = 10
+    ) -> models.TasksListModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "tasks_limit": tasks_limit,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/task/progress/last_tasks", params)
+        return models.TasksListModel(**data)
+
 
 class TaskInfo:
     def __init__(self, client: BaseAPI):
         self.client = client
         self.progress = TaskProcessInfo(self.client)
 
+    async def build_dependency_set(
+        self, task_id: int, arch: str = "x86_64"
+    ) -> models.BuildDependencySetModel:
+        data = await self.client.get(
+            f"/task/build_dependency_set/{task_id}", {"arch": arch}
+        )
+        return models.BuildDependencySetModel(**data)
+
+    async def check_images(self, payload: dict) -> models.CheckImagesOutputModel:
+        data = await self.client.post("/task/check_images", json=payload)
+        return models.CheckImagesOutputModel(**data)
+
+    async def find_images(self, task_id: int) -> models.FindImagesByTaskModel:
+        data = await self.client.get(f"/task/find_images/{task_id}")
+        return models.FindImagesByTaskModel(**data)
+
+    async def find_packageset(
+        self, task_id: int, branches: list[str] | None = None
+    ) -> models.TaskFindPackagesetModel:
+        params = {
+            k: v
+            for k, v in {
+                "branches": branches,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(f"/task/find_packageset/{task_id}", params or None)
+        return models.TaskFindPackagesetModel(**data)
+
+    async def misconflict(
+        self, task_id: int, archs: list[str] | None = None, no_cache: str | None = None
+    ) -> models.TaskMisconflictPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "archs": archs,
+                "no_cache": no_cache,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(f"/task/misconflict/{task_id}", params or None)
+        return models.TaskMisconflictPackagesModel(**data)
+
+    async def needs_approval(
+        self,
+        acl_group: Literal["maint", "tester"],
+        branches: list[str] | None = None,
+        before: str | None = None,
+    ) -> models.NeedsApprovalModel:
+        params = {
+            k: v
+            for k, v in {
+                "acl_group": acl_group,
+                "branches": branches,
+                "before": before,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/task/needs_approval", params)
+        return models.NeedsApprovalModel(**data)
+
+    async def packages(self, task_id: int) -> models.TaskPackagesModel:
+        data = await self.client.get(f"/task/packages/{task_id}")
+        return models.TaskPackagesModel(**data)
+
+    async def task_diff(self, task_id: int) -> models.TaskDiffModel:
+        data = await self.client.get(f"/task/task_diff/{task_id}")
+        return models.TaskDiffModel(**data)
+
+    async def task_history(
+        self,
+        branch: str,
+        start_task: int = 0,
+        end_task: int = 0,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> models.TaskHistoryModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "start_task": start_task,
+                "end_task": end_task,
+                "start_date": start_date,
+                "end_date": end_date,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/task/task_history", params)
+        return models.TaskHistoryModel(**data)
+
+    async def task_info(
+        self,
+        task_id: int,
+        try_: int | None = None,
+        iteration: int | None = None,
+        no_cache: str | None = None,
+        states: list[str] | None = None,
+    ) -> models.TaskInfoModel:
+        params = {
+            k: v
+            for k, v in {
+                "try": try_,
+                "iteration": iteration,
+                "no_cache": no_cache,
+                "states": states,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(f"/task/task_info/{task_id}", params or None)
+        return models.TaskInfoModel(**data)
+
+    async def task_repo(
+        self, task_id: int, include_task_packages: bool = False
+    ) -> models.TaskRepoModel:
+        data = await self.client.get(
+            f"/task/task_repo/{task_id}",
+            {"include_task_packages": include_task_packages},
+        )
+        return models.TaskRepoModel(**data)
+
+    async def what_depends_src(
+        self,
+        task_id: int,
+        depth: int = 1,
+        dptype: Literal["both", "source", "binary"] = "both",
+        archs: list[str] | None = None,
+        leaf: str | None = None,
+        finite_package: bool = False,
+        filter_by_package: list[str] | None = None,
+        filter_by_source: str | None = None,
+        oneandhalf: bool = False,
+        no_cache: str | None = None,
+    ) -> models.TaskBuildDependencyModel:
+        params = {
+            k: v
+            for k, v in {
+                "depth": depth,
+                "dptype": dptype,
+                "archs": archs,
+                "leaf": leaf,
+                "finite_package": finite_package,
+                "filter_by_package": filter_by_package,
+                "filter_by_source": filter_by_source,
+                "oneandhalf": oneandhalf,
+                "no_cache": no_cache,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(
+            f"/task/what_depends_src/{task_id}", params or None
+        )
+        return models.TaskBuildDependencyModel(**data)
+
 
 class PackageInfo:
     def __init__(self, client: BaseAPI):
@@ -115,7 +346,8 @@ class PackageInfo:
         full: bool | None = None,
     ) -> models.PackageInfoModel:
         params = {
-            k: v for k, v in {
+            k: v
+            for k, v in {
                 "name": name,
                 "version": version,
                 "release": release,
@@ -127,20 +359,185 @@ class PackageInfo:
                 "packager": packager,
                 "packager_email": packager_email,
                 "full": full,
-            }.items() if v is not None
+            }.items()
+            if v is not None
         }
         data = await self.client.get("/package/package_info", params)
         return models.PackageInfoModel(**data)
 
-    async def packages_by_file_names(self, files: List[str], branch: str, arch: str | None = None) -> models.PackageByFileNameModel:
-        data = {"files": files, "branch": branch}
+    async def packages_by_file_names(
+        self, files: List[str], branch: str, arch: str | None = None
+    ) -> models.PackageByFileNameModel:
+        payload = models.PackagesByFileNamesJsonModel(
+            files=files, branch=branch, arch=arch
+        )
+        data = await self.client.post(
+            "/package/packages_by_file_names",
+            json=payload.model_dump(exclude_none=True),
+        )
+        return models.PackageByFileNameModel(**data)
+
+    async def build_dependency_set(
+        self,
+        branch: str,
+        packages: list[str],
+        arch: str = "x86_64",
+    ) -> models.BuildDependencySetModel:
+        data = await self.client.get(
+            "/package/build_dependency_set",
+            {"branch": branch, "packages": packages, "arch": arch},
+        )
+        return models.BuildDependencySetModel(**data)
+
+    async def find_packageset(
+        self, packages: list[str], branches: list[str] | None = None
+    ) -> models.PackageFindPackagesetModel:
+        params = {
+            k: v
+            for k, v in {
+                "packages": packages,
+                "branches": branches,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/package/find_packageset", params)
+        return models.PackageFindPackagesetModel(**data)
+
+    async def maintainer_score(
+        self, branch: str, name: str
+    ) -> models.MaintainerScoreModel:
+        data = await self.client.get(
+            "/package/maintainer_score", {"branch": branch, "name": name}
+        )
+        return models.MaintainerScoreModel(**data)
+
+    async def misconflict(
+        self,
+        packages: list[str],
+        branch: str,
+        archs: list[str] | None = None,
+    ) -> models.PackageMisconflictPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "packages": packages,
+                "branch": branch,
+                "archs": archs,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/package/misconflict", params)
+        return models.PackageMisconflictPackagesModel(**data)
 
-        if arch:
-            data["arch"] = arch
+    async def package_by_file_md5(
+        self, branch: str, md5: str, arch: str = "x86_64"
+    ) -> models.PackageByFileNameModel:
+        data = await self.client.get(
+            "/package/package_by_file_md5", {"branch": branch, "md5": md5, "arch": arch}
+        )
+        return models.PackageByFileNameModel(**data)
 
-        data = await self.client.post("/package/packages_by_file_names", json=data)
+    async def package_by_file_name(
+        self, file: str, branch: str, arch: str = "x86_64"
+    ) -> models.PackageByFileNameModel:
+        data = await self.client.get(
+            "/package/package_by_file_name",
+            {"file": file, "branch": branch, "arch": arch},
+        )
         return models.PackageByFileNameModel(**data)
 
+    async def package_files(self, pkghash: int) -> models.PackageFilesModel:
+        data = await self.client.get(f"/package/package_files/{pkghash}")
+        return models.PackageFilesModel(**data)
+
+    async def repocop(
+        self,
+        branch: str,
+        package_name: str,
+        package_version: str | None = None,
+        package_release: str | None = None,
+        bin_package_arch: str | None = None,
+        package_type: Literal["source", "binary"] = "source",
+    ) -> models.RepocopJsonGetListModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "package_name": package_name,
+                "package_version": package_version,
+                "package_release": package_release,
+                "bin_package_arch": bin_package_arch,
+                "package_type": package_type,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/package/repocop", params)
+        return models.RepocopJsonGetListModel(**data)
+
+    async def repocop_post(self, packages: list[dict]) -> None:
+        await self.client.post("/package/repocop", json={"packages": packages})
+
+    async def specfile_by_hash(self, pkghash: int) -> models.PackageSpecfileModel:
+        data = await self.client.get(f"/package/specfile_by_hash/{pkghash}")
+        return models.PackageSpecfileModel(**data)
+
+    async def specfile_by_name(
+        self, branch: str, name: str
+    ) -> models.PackageSpecfileModel:
+        data = await self.client.get(
+            "/package/specfile_by_name", {"branch": branch, "name": name}
+        )
+        return models.PackageSpecfileModel(**data)
+
+    async def unpackaged_dirs(
+        self, branch: str, packager: str, archs: list[str] | None = None
+    ) -> models.UnpackagedDirsModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "packager": packager,
+                "archs": archs,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/package/unpackaged_dirs", params)
+        return models.UnpackagedDirsModel(**data)
+
+    async def what_depends_src(
+        self,
+        packages: list[str],
+        branch: str,
+        depth: int = 1,
+        dptype: Literal["both", "source", "binary"] = "both",
+        archs: list[str] | None = None,
+        leaf: str | None = None,
+        finite_package: bool = False,
+        filter_by_package: list[str] | None = None,
+        filter_by_source: str | None = None,
+        oneandhalf: bool = False,
+        use_last_tasks: bool = False,
+    ) -> models.PackageBuildDependencyModel:
+        params = {
+            k: v
+            for k, v in {
+                "packages": packages,
+                "branch": branch,
+                "depth": depth,
+                "dptype": dptype,
+                "archs": archs,
+                "leaf": leaf,
+                "finite_package": finite_package,
+                "filter_by_package": filter_by_package,
+                "filter_by_source": filter_by_source,
+                "oneandhalf": oneandhalf,
+                "use_last_tasks": use_last_tasks,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/package/what_depends_src", params)
+        return models.PackageBuildDependencyModel(**data)
+
 
 class PackagesetInfo:
     def __init__(self, client: BaseAPI):
@@ -150,13 +547,71 @@ class PackagesetInfo:
         data = await self.client.get("/packageset/active_packagesets")
         return models.PackageSetActivePackageSetsModel(**data)
 
-    async def repository_statistics(self, branch: str | None = None) -> models.RepositoryStatisticsModel:
+    async def repository_statistics(
+        self, branch: str | None = None
+    ) -> models.RepositoryStatisticsModel:
         if branch:
-            data = await self.client.get("/packageset/repository_statistics", {"branch": branch})
+            data = await self.client.get(
+                "/packageset/repository_statistics", {"branch": branch}
+            )
         else:
             data = await self.client.get("/packageset")
         return models.RepositoryStatisticsModel(**data)
 
+    async def compare_packagesets(
+        self, pkgset1: str, pkgset2: str
+    ) -> models.PackagesetCompareModel:
+        data = await self.client.get(
+            "/packageset/compare_packagesets", {"pkgset1": pkgset1, "pkgset2": pkgset2}
+        )
+        return models.PackagesetCompareModel(**data)
+
+    async def maintainer_scores(self, branch: str) -> models.MaintainerScoresBatchModel:
+        data = await self.client.get(
+            "/packageset/maintainer_scores", {"branch": branch}
+        )
+        return models.MaintainerScoresBatchModel(**data)
+
+    async def packages_by_component(
+        self, branch: str, arch: str, component: str
+    ) -> models.PackagesByUuidModel:
+        data = await self.client.get(
+            "/packageset/packages_by_component",
+            {"branch": branch, "arch": arch, "component": component},
+        )
+        return models.PackagesByUuidModel(**data)
+
+    async def packages_by_uuid(self, uuid: str) -> models.PackagesByUuidModel:
+        data = await self.client.get("/packageset/packages_by_uuid", {"uuid": uuid})
+        return models.PackagesByUuidModel(**data)
+
+    async def pkgset_status_get(self) -> models.PackageSetStatusGetModel:
+        data = await self.client.get("/packageset/pkgset_status")
+        return models.PackageSetStatusGetModel(**data)
+
+    async def pkgset_status_post(self, payload: dict) -> None:
+        await self.client.post("/packageset/pkgset_status", json=payload)
+
+    async def repository_packages(
+        self,
+        branch: str,
+        package_type: Literal["all", "source", "binary"] = "all",
+        archs: list[str] | None = None,
+        include_done_tasks: bool = False,
+    ) -> models.PackagesetPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "package_type": package_type,
+                "archs": archs,
+                "include_done_tasks": include_done_tasks,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/packageset/repository_packages", params)
+        return models.PackagesetPackagesModel(**data)
+
 
 class AclInfo:
     def __init__(self, client: BaseAPI):
@@ -167,12 +622,33 @@ class AclInfo:
         if name:
             data["name"] = name
 
-        data = await self.client.get(
-            "/acl/groups",
-            data
-        )
+        data = await self.client.get("/acl/groups", data)
         return models.AclGroupsModel(**data)
 
+    async def by_packages(
+        self, branch: str, packages_names: list[str]
+    ) -> models.AclByPackagesModel:
+        params = {
+            "branch": branch,
+            "packages_names": packages_names,
+        }
+        data = await self.client.get("/acl/by_packages", params)
+        return models.AclByPackagesModel(**data)
+
+    async def maintainer_groups(
+        self, nickname: str, branch: list[str] | None = None
+    ) -> models.AclMaintainerGroupsModel:
+        params = {
+            k: v
+            for k, v in {
+                "nickname": nickname,
+                "branch": branch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/acl/maintainer_groups", params)
+        return models.AclMaintainerGroupsModel(**data)
+
 
 class BugInfo:
     def __init__(self, client: BaseAPI):
@@ -184,33 +660,69 @@ class BugInfo:
         try:
             data = await self.client.get(
                 "/bug/bugzilla_by_maintainer",
-                {"maintainer_nickname": maintainer_nickname,
-                    "by_acl": by_acl if by_acl else "none"}
+                {
+                    "maintainer_nickname": maintainer_nickname,
+                    "by_acl": by_acl if by_acl else "none",
+                },
             )
         except errors.DataNotFoundError:
             return None
         return models.BugzillaInfoModel(**data)
 
+    async def bugzilla_by_package(
+        self,
+        package_name: str,
+        package_type: Literal["source", "binary"] = "source",
+    ) -> models.BugzillaInfoModel:
+        data = await self.client.get(
+            "/bug/bugzilla_by_package",
+            {"package_name": package_name, "package_type": package_type},
+        )
+        return models.BugzillaInfoModel(**data)
+
+    async def bugzilla_by_image_edition(
+        self, branch: str, edition: str
+    ) -> models.BugzillaInfoModel:
+        data = await self.client.get(
+            "/bug/bugzilla_by_image_edition", {"branch": branch, "edition": edition}
+        )
+        return models.BugzillaInfoModel(**data)
+
 
 class FileInfo:
     def __init__(self, client: BaseAPI):
         self.client = client
 
-    async def packages_by_file(self, branch: str, file_name: str) -> models.FilePackagesByFileModel:
+    async def packages_by_file(
+        self, branch: str, file_name: str
+    ) -> models.FilePackagesByFileModel:
         data = await self.client.get(
-            "/file/packages_by_file",
-            {"branch": branch, "file_name": file_name}
+            "/file/packages_by_file", {"branch": branch, "file_name": file_name}
         )
         return models.FilePackagesByFileModel(**data)
 
-    async def search(self, branch: str, file_name: str, limit: int | None = None) -> models.FilesModel:
+    async def search(
+        self, branch: str, file_name: str, limit: int | None = None
+    ) -> models.FilesModel:
         data = await self.client.get(
             "/file/search",
-            {"branch": branch, "file_name": file_name,
-                "limit": limit if limit else 1000}
+            {
+                "branch": branch,
+                "file_name": file_name,
+                "limit": limit if limit else 1000,
+            },
         )
         return models.FilesModel(**data)
 
+    async def fast_lookup(
+        self, branch: str, file_name: str, limit: int = 10
+    ) -> models.FastFileSearchModel:
+        data = await self.client.get(
+            "/file/fast_lookup",
+            {"branch": branch, "file_name": file_name, "limit": limit},
+        )
+        return models.FastFileSearchModel(**data)
+
 
 class SiteInfo:
     def __init__(self, client: BaseAPI):
@@ -219,24 +731,28 @@ class SiteInfo:
     async def all_maintainers(self, branch: str) -> models.AllMaintainersModel:
         return await self.all_maintainers_with_nicknames(branch)
 
-    async def all_maintainers_with_nicknames(self, branch: str) -> models.AllMaintainersModel:
+    async def all_maintainers_with_nicknames(
+        self, branch: str
+    ) -> models.AllMaintainersModel:
         data = await self.client.get(
-            "/site/all_maintainers_with_nicknames",
-            {"branch": branch}
+            "/site/all_maintainers_with_nicknames", {"branch": branch}
         )
         return models.AllMaintainersModel(**data)
 
-    async def find_source_package(self, branch: str, name: str) -> models.FindSourcePackageInBranch:
+    async def find_source_package(
+        self, branch: str, name: str
+    ) -> models.FindSourcePackageInBranch:
         data = await self.client.get(
-            "/site/find_source_package",
-            {"branch": branch, "name": name}
+            "/site/find_source_package", {"branch": branch, "name": name}
         )
         return models.FindSourcePackageInBranch(**data)
 
-    async def maintainer_info(self, branch: str, maintainer_nickname: str) -> models.MaintainerInfoModel:
+    async def maintainer_info(
+        self, branch: str, maintainer_nickname: str
+    ) -> models.MaintainerInfoModel:
         data = await self.client.get(
             "/site/maintainer_info",
-            {"branch": branch, "maintainer_nickname": maintainer_nickname}
+            {"branch": branch, "maintainer_nickname": maintainer_nickname},
         )
         return models.MaintainerInfoModel(**data)
 
@@ -245,11 +761,15 @@ class SiteInfo:
         branch: str,
         pkghash: int,
         changelog_last: int = 3,
-        package_type: Literal["source", "binary"] = "source"
+        package_type: Literal["source", "binary"] = "source",
     ) -> models.SitePackageInfoModel:
         data = await self.client.get(
             f"/site/package_info/{pkghash}",
-            {"branch": branch, "changelog_last": changelog_last, "package_type": package_type}
+            {
+                "branch": branch,
+                "changelog_last": changelog_last,
+                "package_type": package_type,
+            },
         )
         return models.SitePackageInfoModel(**data)
 
@@ -262,23 +782,1035 @@ class SiteInfo:
         )
         return models.SitePackagesetPackageHashModel(**data)
 
-    async def pkghash_by_name(self, branch: str, name: str) -> models.SitePackagesetPackageHashModel:
+    async def pkghash_by_name(
+        self, branch: str, name: str
+    ) -> models.SitePackagesetPackageHashModel:
         data = await self.client.get(
-            "/site/pkghash_by_name",
-            {"branch": branch, "name": name}
+            "/site/pkghash_by_name", {"branch": branch, "name": name}
         )
         return models.SitePackagesetPackageHashModel(**data)
 
-    async def watch_by_maintainer(self, maintainer_nickname: str) -> models.SiteWatchByMaintainerModel | None:
+    async def watch_by_maintainer(
+        self, maintainer_nickname: str
+    ) -> models.SiteWatchByMaintainerModel | None:
         try:
             data = await self.client.get(
                 "/site/watch_by_maintainer",
-                {"maintainer_nickname": maintainer_nickname}
+                {"maintainer_nickname": maintainer_nickname},
             )
         except errors.DataNotFoundError:
             return None
         return models.SiteWatchByMaintainerModel(**data)
 
+    async def all_pkgset_archs(self, branch: str) -> models.SiteAllArchsModel:
+        data = await self.client.get("/site/all_pkgset_archs", {"branch": branch})
+        return models.SiteAllArchsModel(**data)
+
+    async def all_pkgset_archs_with_src_count(
+        self, branch: str
+    ) -> models.SiteAllArchsModel:
+        data = await self.client.get(
+            "/site/all_pkgset_archs_with_src_count", {"branch": branch}
+        )
+        return models.SiteAllArchsModel(**data)
+
+    async def all_pkgsets(self) -> models.SiteAllPackagasetsModel:
+        data = await self.client.get("/site/all_pkgsets")
+        return models.SiteAllPackagasetsModel(**data)
+
+    async def all_pkgsets_summary(self) -> models.SiteAllPackagesetsSummaryModel:
+        data = await self.client.get("/site/all_pkgsets_summary")
+        return models.SiteAllPackagesetsSummaryModel(**data)
+
+    async def all_pkgsets_with_src_count(self) -> models.SiteAllPackagasetsModel:
+        data = await self.client.get("/site/all_pkgsets_with_src_count")
+        return models.SiteAllPackagasetsModel(**data)
+
+    async def beehive_errors_by_maintainer(
+        self,
+        branch: str,
+        maintainer_nickname: str,
+        by_acl: str = "none",
+    ) -> models.SiteBeehiveByMaintainerModel:
+        data = await self.client.get(
+            "/site/beehive_errors_by_maintainer",
+            {
+                "branch": branch,
+                "maintainer_nickname": maintainer_nickname,
+                "by_acl": by_acl,
+            },
+        )
+        return models.SiteBeehiveByMaintainerModel(**data)
+
+    async def binary_package_archs_and_versions(
+        self, branch: str, name: str
+    ) -> models.SitePackagesBinaryListModel:
+        data = await self.client.get(
+            "/site/binary_package_archs_and_versions", {"branch": branch, "name": name}
+        )
+        return models.SitePackagesBinaryListModel(**data)
+
+    async def binary_package_scripts(
+        self, pkghash: int
+    ) -> models.SiteBinPackageScriptsModel:
+        data = await self.client.get(f"/site/binary_package_scripts/{pkghash}")
+        return models.SiteBinPackageScriptsModel(**data)
+
+    async def deleted_package_info(
+        self,
+        branch: str,
+        name: str,
+        package_type: Literal["source", "binary"] = "source",
+        arch: str | None = None,
+    ) -> models.SiteDeletedPackageModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "name": name,
+                "package_type": package_type,
+                "arch": arch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/deleted_package_info", params)
+        return models.SiteDeletedPackageModel(**data)
+
+    async def fast_packages_search_lookup(
+        self, name: list[str], branch: str | None = None
+    ) -> models.SiteFastPackagesSearchModel:
+        params = {
+            k: v
+            for k, v in {
+                "name": name,
+                "branch": branch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/fast_packages_search_lookup", params)
+        return models.SiteFastPackagesSearchModel(**data)
+
+    async def find_packages(
+        self,
+        name: list[str],
+        branch: str | None = None,
+        arch: list[str] | None = None,
+    ) -> models.SiteFingPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "name": name,
+                "branch": branch,
+                "arch": arch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/find_packages", params)
+        return models.SiteFingPackagesModel(**data)
+
+    async def last_packages(
+        self,
+        branch: str,
+        tasks_limit: int = 10,
+        task_owner: str | None = None,
+    ) -> models.SiteLastPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "tasks_limit": tasks_limit,
+                "task_owner": task_owner,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/last_packages", params)
+        return models.SiteLastPackagesModel(**data)
+
+    async def last_packages_by_branch(
+        self,
+        branch: str,
+        packages_limit: int = 10,
+        packager: str | None = None,
+    ) -> models.SiteLastBranchPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "packages_limit": packages_limit,
+                "packager": packager,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/last_packages_by_branch", params)
+        return models.SiteLastBranchPackagesModel(**data)
+
+    async def last_packages_by_tasks(
+        self,
+        branch: str,
+        tasks_limit: int = 10,
+        task_owner: str | None = None,
+    ) -> models.SiteLastPackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "tasks_limit": tasks_limit,
+                "task_owner": task_owner,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/last_packages_by_tasks", params)
+        return models.SiteLastPackagesModel(**data)
+
+    async def last_packages_with_cve_fixed(
+        self, branch: str
+    ) -> models.SiteLastPackagesWithCVEFixesModel:
+        data = await self.client.get(
+            "/site/last_packages_with_cve_fixed", {"branch": branch}
+        )
+        return models.SiteLastPackagesWithCVEFixesModel(**data)
+
+    async def maintainer_branches(
+        self, maintainer_nickname: str
+    ) -> models.MaintainerBranchesModel:
+        data = await self.client.get(
+            "/site/maintainer_branches", {"maintainer_nickname": maintainer_nickname}
+        )
+        return models.MaintainerBranchesModel(**data)
+
+    async def maintainer_packages(
+        self,
+        branch: str,
+        maintainer_nickname: str,
+        by_acl: str = "none",
+    ) -> models.MaintainerPackagesModel:
+        data = await self.client.get(
+            "/site/maintainer_packages",
+            {
+                "branch": branch,
+                "maintainer_nickname": maintainer_nickname,
+                "by_acl": by_acl,
+            },
+        )
+        return models.MaintainerPackagesModel(**data)
+
+    async def package_changelog(
+        self, pkghash: int, changelog_last: int = 3
+    ) -> models.SiteChangelogModel:
+        data = await self.client.get(
+            f"/site/package_changelog/{pkghash}", {"changelog_last": changelog_last}
+        )
+        return models.SiteChangelogModel(**data)
+
+    async def package_downloads(
+        self, pkghash: int, branch: str
+    ) -> models.SitePackagesDownloadsModel:
+        data = await self.client.get(
+            f"/site/package_downloads/{pkghash}", {"branch": branch}
+        )
+        return models.SitePackagesDownloadsModel(**data)
+
+    async def package_downloads_bin(
+        self, pkghash: int, branch: str, arch: str
+    ) -> models.SitePackagesDownloadsModel:
+        data = await self.client.get(
+            f"/site/package_downloads_bin/{pkghash}", {"branch": branch, "arch": arch}
+        )
+        return models.SitePackagesDownloadsModel(**data)
+
+    async def package_downloads_src(
+        self, pkghash: int, branch: str
+    ) -> models.SitePackagesDownloadsModel:
+        data = await self.client.get(
+            f"/site/package_downloads_src/{pkghash}", {"branch": branch}
+        )
+        return models.SitePackagesDownloadsModel(**data)
+
+    async def package_info_brief(
+        self, pkghash: int
+    ) -> models.SiteBriefPackageInfoModel:
+        data = await self.client.get(f"/site/package_info_brief/{pkghash}")
+        return models.SiteBriefPackageInfoModel(**data)
+
+    async def package_log_bin(self, pkghash: int) -> models.BinPackageLogElementModel:
+        data = await self.client.get(f"/site/package_log_bin/{pkghash}")
+        return models.BinPackageLogElementModel(**data)
+
+    async def package_misconflict(
+        self, pkghash: int, branch: str
+    ) -> models.PackageMisconflictBySrcModel:
+        data = await self.client.get(
+            f"/site/package_misconflict/{pkghash}", {"branch": branch}
+        )
+        return models.PackageMisconflictBySrcModel(**data)
+
+    async def package_name_from_repology(
+        self, branch: str, name: str
+    ) -> models.PackageNameFromRepologyModel:
+        data = await self.client.get(
+            "/site/package_name_from_repology", {"branch": branch, "name": name}
+        )
+        return models.PackageNameFromRepologyModel(**data)
+
+    async def package_nvr_by_hash(
+        self, pkghash: int, name: str | None = None
+    ) -> models.PackageNVRByHashModel:
+        params = {
+            k: v
+            for k, v in {
+                "name": name,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(
+            f"/site/package_nvr_by_hash/{pkghash}", params or None
+        )
+        return models.PackageNVRByHashModel(**data)
+
+    async def package_versions(
+        self,
+        name: str,
+        package_type: Literal["source", "binary"] = "source",
+        arch: str | None = None,
+    ) -> models.SiteSourcePackagesVersionsModel:
+        params = {
+            k: v
+            for k, v in {
+                "name": name,
+                "package_type": package_type,
+                "arch": arch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/package_versions", params)
+        return models.SiteSourcePackagesVersionsModel(**data)
+
+    async def package_versions_from_images(
+        self, name: str, branch: str, edition: str, type: str
+    ) -> models.SiteImagePackageVersionsModel:
+        data = await self.client.get(
+            "/site/package_versions_from_images",
+            {"name": name, "branch": branch, "edition": edition, "type": type},
+        )
+        return models.SiteImagePackageVersionsModel(**data)
+
+    async def package_versions_from_tasks(
+        self, name: str, branch: str | None = None
+    ) -> models.SItePackagesVersionsFromTasksModel:
+        params = {
+            k: v
+            for k, v in {
+                "name": name,
+                "branch": branch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/package_versions_from_tasks", params)
+        return models.SItePackagesVersionsFromTasksModel(**data)
+
+    async def packagesets_by_hash(
+        self, pkghash: int
+    ) -> models.SitePackagesetsByHashModel:
+        data = await self.client.get(f"/site/packagesets_by_hash/{pkghash}")
+        return models.SitePackagesetsByHashModel(**data)
+
+    async def pkghash_by_nvr(
+        self, name: str, branch: str, version: str, release: str
+    ) -> models.SitePackagesetPackageHashByNameVersionRelease:
+        data = await self.client.get(
+            "/site/pkghash_by_nvr",
+            {"name": name, "branch": branch, "version": version, "release": release},
+        )
+        return models.SitePackagesetPackageHashByNameVersionRelease(**data)
+
+    async def pkgset_categories_count(
+        self,
+        branch: str,
+        package_type: Literal["all", "source", "binary"] = "source",
+    ) -> models.SitePackagesetCategoriesModel:
+        data = await self.client.get(
+            "/site/pkgset_categories_count",
+            {"branch": branch, "package_type": package_type},
+        )
+        return models.SitePackagesetCategoriesModel(**data)
+
+    async def pkgsets_summary_status(self) -> models.SitePackagesetsSummaryStatusModel:
+        data = await self.client.get("/site/pkgsets_summary_status")
+        return models.SitePackagesetsSummaryStatusModel(**data)
+
+    async def repocop_by_maintainer(
+        self,
+        branch: str,
+        maintainer_nickname: str,
+        by_acl: str = "none",
+    ) -> models.RepocopByMaintainerModel:
+        data = await self.client.get(
+            "/site/repocop_by_maintainer",
+            {
+                "branch": branch,
+                "maintainer_nickname": maintainer_nickname,
+                "by_acl": by_acl,
+            },
+        )
+        return models.RepocopByMaintainerModel(**data)
+
+    async def repository_packages(
+        self,
+        branch: str,
+        package_type: Literal["all", "source", "binary"] = "source",
+        group: str | None = None,
+        buildtime: int = 0,
+    ) -> models.SitePackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "package_type": package_type,
+                "group": group,
+                "buildtime": buildtime,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/repository_packages", params)
+        return models.SitePackagesModel(**data)
+
+    async def source_package_versions(
+        self, name: str
+    ) -> models.SiteSourcePackagesVersionsModel:
+        data = await self.client.get("/site/source_package_versions", {"name": name})
+        return models.SiteSourcePackagesVersionsModel(**data)
+
+    async def tasks_by_maintainer(
+        self, branch: str, maintainer_nickname: str
+    ) -> models.SiteTaskByNameModel:
+        data = await self.client.get(
+            "/site/tasks_by_maintainer",
+            {"branch": branch, "maintainer_nickname": maintainer_nickname},
+        )
+        return models.SiteTaskByNameModel(**data)
+
+    async def tasks_by_package(self, name: str) -> models.SiteTaskByNameModel:
+        data = await self.client.get("/site/tasks_by_package", {"name": name})
+        return models.SiteTaskByNameModel(**data)
+
+    async def tasks_history(
+        self, task_id: int | None = None
+    ) -> models.SiteTasksHistoryModel:
+        params = {
+            k: v
+            for k, v in {
+                "task_id": task_id,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/site/tasks_history", params or None)
+        return models.SiteTasksHistoryModel(**data)
+
+
+class AuthInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def login(
+        self,
+        nickname: str,
+        password: str,
+        auth_provider: Literal["ldap", "keycloak"] = "ldap",
+    ) -> models.AuthResponseModel:
+        data = await self.client.post(
+            "/auth/login",
+            data={
+                "nickname": nickname,
+                "password": password,
+                "auth_provider": auth_provider,
+            },
+        )
+        return models.AuthResponseModel(**data)
+
+    async def logout(self) -> models.AuthLogoutResponseModel:
+        data = await self.client.post("/auth/logout")
+        return models.AuthLogoutResponseModel(**data)
+
+    async def refresh_token(self, access_token: str) -> models.AuthResponseModel:
+        data = await self.client.post(
+            "/auth/refresh-token", data={"access_token": access_token}
+        )
+        return models.AuthResponseModel(**data)
+
+
+class DependenciesInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def backport_helper(
+        self,
+        from_branch: str,
+        into_branch: str,
+        packages_names: list[str],
+        dp_type: Literal["both", "source", "binary"] = "both",
+        archs: list[str] | None = None,
+    ) -> models.BackportHelperModel:
+        params = {
+            k: v
+            for k, v in {
+                "from_branch": from_branch,
+                "into_branch": into_branch,
+                "packages_names": packages_names,
+                "dp_type": dp_type,
+                "archs": archs,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/dependencies/backport_helper", params)
+        return models.BackportHelperModel(**data)
+
+    async def binary_package_dependencies(
+        self, pkghash: int
+    ) -> models.DependenciesPackageDependenciesModel:
+        data = await self.client.get(
+            f"/dependencies/binary_package_dependencies/{pkghash}"
+        )
+        return models.DependenciesPackageDependenciesModel(**data)
+
+    async def fast_lookup(
+        self, branch: str, dp_name: str, limit: int = 10
+    ) -> models.FastDependencySearchModel:
+        data = await self.client.get(
+            "/dependencies/fast_lookup",
+            {"branch": branch, "dp_name": dp_name, "limit": limit},
+        )
+        return models.FastDependencySearchModel(**data)
+
+    async def packages_by_dependency(
+        self,
+        branch: str,
+        dp_name: str,
+        dp_type: Literal["all", "provide", "require", "conflict", "obsolete"] = "all",
+        last_state: bool = False,
+    ) -> models.DependenciesPackagesModel:
+        data = await self.client.get(
+            "/dependencies/packages_by_dependency",
+            {
+                "branch": branch,
+                "dp_name": dp_name,
+                "dp_type": dp_type,
+                "last_state": last_state,
+            },
+        )
+        return models.DependenciesPackagesModel(**data)
+
+    async def source_package_dependencies(
+        self, pkghash: int, branch: str, depth: int = 1
+    ) -> models.DependenciesPackageBuildDependenciesModel:
+        data = await self.client.get(
+            f"/dependencies/source_package_dependencies/{pkghash}",
+            {"branch": branch, "depth": depth},
+        )
+        return models.DependenciesPackageBuildDependenciesModel(**data)
+
+    async def what_depends_src(
+        self,
+        name: str,
+        branch: str,
+        dp_type: Literal["both", "source", "binary"] = "both",
+    ) -> models.PackageBuildDependencyModel:
+        data = await self.client.get(
+            "/dependencies/what_depends_src",
+            {"name": name, "branch": branch, "dp_type": dp_type},
+        )
+        return models.PackageBuildDependencyModel(**data)
+
+
+class ErrataInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def advisory(
+        self,
+        branch: str | None = None,
+        input: str | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+        sort: list[str] | None = None,
+    ) -> models.AdvisoryErrataModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "input": input,
+                "page": page,
+                "limit": limit,
+                "sort": sort,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/errata/advisory", params or None)
+        return models.AdvisoryErrataModel(**data)
+
+    async def branches_updates(
+        self, errata_ids: list[str], exclude_json: bool = False
+    ) -> models.ErrataBranchesUpdatesModel:
+        data = await self.client.post(
+            "/errata/branches_updates", json={"errata_ids": errata_ids}
+        )
+        return models.ErrataBranchesUpdatesModel(**data)
+
+    async def errata_branches(self) -> models.ErrataBranchesModel:
+        data = await self.client.get("/errata/errata_branches")
+        return models.ErrataBranchesModel(**data)
+
+    async def export_oval_branches(self) -> models.OvalBranchesModel:
+        data = await self.client.get("/errata/export/oval/branches")
+        return models.OvalBranchesModel(**data)
+
+    async def export_oval(
+        self,
+        branch: str,
+        package_name: str | None = None,
+        one_file: bool = False,
+    ) -> bytes:
+        params = {
+            k: v
+            for k, v in {
+                "package_name": package_name,
+                "one_file": one_file,
+            }.items()
+            if v is not None
+        }
+        return await self.client.get_bytes(
+            f"/errata/export/oval/{branch}", params or None
+        )
+
+    async def find_erratas(
+        self,
+        input: list[str] | None = None,
+        branch: str | None = None,
+        type: Literal["packages", "repository", "bug", "vuln", "exclusion"]
+        | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+        state: Literal["all", "active", "discarded"] = "all",
+    ) -> models.ErrataLastChangedModel:
+        params = {
+            k: v
+            for k, v in {
+                "input": input,
+                "branch": branch,
+                "type": type,
+                "page": page,
+                "limit": limit,
+                "state": state,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/errata/find_erratas", params or None)
+        return models.ErrataLastChangedModel(**data)
+
+    async def find_image_erratas(
+        self,
+        uuid: str,
+        branch: str,
+        component: str | None = None,
+        input: list[str] | None = None,
+        type: Literal["packages", "repository", "bug", "vuln", "exclusion"]
+        | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+        is_discarded: bool = False,
+        sort: list[str] | None = None,
+    ) -> models.ImageErrataModel:
+        params = {
+            k: v
+            for k, v in {
+                "uuid": uuid,
+                "branch": branch,
+                "component": component,
+                "input": input,
+                "type": type,
+                "page": page,
+                "limit": limit,
+                "is_discarded": is_discarded,
+                "sort": sort,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/errata/find_image_erratas", params)
+        return models.ImageErrataModel(**data)
+
+    async def ids(self) -> models.ErrataIdsListModel:
+        data = await self.client.get("/errata/ids")
+        return models.ErrataIdsListModel(**data)
+
+    async def packages_updates(
+        self, errata_ids: list[str], exclude_json: bool = False
+    ) -> models.ErrataPackagesUpdatesModel:
+        data = await self.client.post(
+            "/errata/packages_updates", json={"errata_ids": errata_ids}
+        )
+        return models.ErrataPackagesUpdatesModel(**data)
+
+    async def search(
+        self,
+        branch: str | None = None,
+        name: str | None = None,
+        vuln_id: str | None = None,
+        errata_id: str | None = None,
+    ) -> models.ErratasModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "name": name,
+                "vuln_id": vuln_id,
+                "errata_id": errata_id,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/errata/search", params or None)
+        return models.ErratasModel(**data)
+
+
+class ExportInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def beehive_ftbfs(
+        self, branch: str, arch: str | None = None
+    ) -> models.ExportBeehiveFTBFSListModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "arch": arch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/export/beehive/ftbfs", params)
+        return models.ExportBeehiveFTBFSListModel(**data)
+
+    async def branch_binary_packages(
+        self, branch: str, arch: str | None = None
+    ) -> models.PackagesetPackagesExportModel:
+        params = {
+            k: v
+            for k, v in {
+                "arch": arch,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(
+            f"/export/branch_binary_packages/{branch}", params or None
+        )
+        return models.PackagesetPackagesExportModel(**data)
+
+    async def branch_tree(self) -> models.BranchTreeModel:
+        data = await self.client.get("/export/branch_tree")
+        return models.BranchTreeModel(**data)
+
+    async def repology(self, branch: str) -> models.RepologyExportModel:
+        data = await self.client.get(f"/export/repology/{branch}")
+        return models.RepologyExportModel(**data)
+
+    async def sitemap_packages(self, branch: str) -> models.SitemapPackagesExportModel:
+        data = await self.client.get(f"/export/sitemap_packages/{branch}")
+        return models.SitemapPackagesExportModel(**data)
+
+    async def translation_packages_po_files(
+        self, branches: list[str], from_date: str | None = None
+    ) -> bytes:
+        params = {
+            k: v
+            for k, v in {
+                "branches": branches,
+                "from_date": from_date,
+            }.items()
+            if v is not None
+        }
+        return await self.client.get_bytes(
+            "/export/translation/packages_po_files", params
+        )
+
+
+class ImageInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def active_images(
+        self,
+        branch: str | None = None,
+        edition: str | None = None,
+        version: str | None = None,
+        release: str | None = None,
+        variant: str | None = None,
+        type: str | None = None,
+    ) -> models.ActiveImagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "edition": edition,
+                "version": version,
+                "release": release,
+                "variant": variant,
+                "type": type,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/active_images", params or None)
+        return models.ActiveImagesModel(**data)
+
+    async def find_images_by_package_name(
+        self,
+        pkg_name: str,
+        branch: str | None = None,
+        edition: str | None = None,
+        pkg_type: Literal["source", "binary"] = "source",
+        img_show: Literal["active", "all"] = "all",
+    ) -> models.FindImagesByPackageModel:
+        params = {
+            k: v
+            for k, v in {
+                "pkg_name": pkg_name,
+                "branch": branch,
+                "edition": edition,
+                "pkg_type": pkg_type,
+                "img_show": img_show,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/find_images_by_package_name", params)
+        return models.FindImagesByPackageModel(**data)
+
+    async def image_categories_count(
+        self, uuid: str, component: str | None = None
+    ) -> models.SiteImageCategoriesModel:
+        params = {
+            k: v
+            for k, v in {
+                "uuid": uuid,
+                "component": component,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/image_categories_count", params)
+        return models.SiteImageCategoriesModel(**data)
+
+    async def image_info(
+        self,
+        branch: str | None = None,
+        edition: str | None = None,
+        version: str | None = None,
+        release: str | None = None,
+        variant: str | None = None,
+        flavor: str | None = None,
+        arch: str | None = None,
+        component: str | None = None,
+        platform: str | None = None,
+        type: str | None = None,
+    ) -> models.ImageInfoModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "edition": edition,
+                "version": version,
+                "release": release,
+                "variant": variant,
+                "flavor": flavor,
+                "arch": arch,
+                "component": component,
+                "platform": platform,
+                "type": type,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/image_info", params or None)
+        return models.ImageInfoModel(**data)
+
+    async def image_packages(
+        self, uuid: str, group: str | None = None, component: str | None = None
+    ) -> models.ImagePackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "uuid": uuid,
+                "group": group,
+                "component": component,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/image_packages", params)
+        return models.ImagePackagesModel(**data)
+
+    async def image_packageset(self) -> models.ImagePackageSetModel:
+        data = await self.client.get("/image/image_packageset")
+        return models.ImagePackageSetModel(**data)
+
+    async def image_status_get(self) -> models.ImageStatusGetModel:
+        data = await self.client.get("/image/image_status")
+        return models.ImageStatusGetModel(**data)
+
+    async def image_status_post(self, payload: dict) -> None:
+        await self.client.post("/image/image_status", json=payload)
+
+    async def image_tag_status_get(
+        self, branch: str | None = None, edition: str | None = None
+    ) -> models.ImageTagStatusGetModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "edition": edition,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/image_tag_status", params or None)
+        return models.ImageTagStatusGetModel(**data)
+
+    async def image_tag_status_post(self, payload: dict) -> None:
+        await self.client.post("/image/image_tag_status", json=payload)
+
+    async def image_uuid_by_tag(self, tag: str) -> models.ImageTagUUIDModel:
+        data = await self.client.get("/image/image_uuid_by_tag", {"tag": tag})
+        return models.ImageTagUUIDModel(**data)
+
+    async def inspect_regular(
+        self, payload: dict
+    ) -> models.ImagePackagesInspectRegularModel:
+        data = await self.client.post("/image/inspect/regular", json=payload)
+        return models.ImagePackagesInspectRegularModel(**data)
+
+    async def inspect_sp(self, payload: dict) -> models.ImagePackagesInspectSPModel:
+        data = await self.client.post("/image/inspect/sp", json=payload)
+        return models.ImagePackagesInspectSPModel(**data)
+
+    async def iso_all_images(self) -> models.ImageAllISOModel:
+        data = await self.client.get("/image/iso/all_images")
+        return models.ImageAllISOModel(**data)
+
+    async def last_packages_by_image(
+        self,
+        branch: str,
+        uuid: str,
+        packages_limit: int | None = None,
+        component: str | None = None,
+    ) -> models.LastImagePackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "uuid": uuid,
+                "packages_limit": packages_limit,
+                "component": component,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get("/image/last_packages_by_image", params)
+        return models.LastImagePackagesModel(**data)
+
+    async def last_packages_image_with_cve_fixed(
+        self,
+        branch: str,
+        uuid: str,
+        packages_limit: int | None = None,
+        component: str | None = None,
+    ) -> models.LastImagePackagesModel:
+        params = {
+            k: v
+            for k, v in {
+                "branch": branch,
+                "uuid": uuid,
+                "packages_limit": packages_limit,
+                "component": component,
+            }.items()
+            if v is not None
+        }
+        data = await self.client.get(
+            "/image/last_packages_image_with_cve_fixed", params
+        )
+        return models.LastImagePackagesModel(**data)
+
+
+class LicenseInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def license_text(self) -> str:
+        return await self.client.get_text("/license")
+
+    async def info(self, license: str) -> models.LicenseInfoModel:
+        data = await self.client.get("/license/info", {"license": license})
+        return models.LicenseInfoModel(**data)
+
+    async def tokens(self, license: str) -> models.LicenseTokensModel:
+        data = await self.client.get("/license/tokens", {"license": license})
+        return models.LicenseTokensModel(**data)
+
+
+class VulnInfo:
+    def __init__(self, client: BaseAPI):
+        self.client = client
+
+    async def bdu(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnerabilityInfoModel:
+        data = await self.client.get(
+            "/vuln/bdu", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnerabilityInfoModel(**data)
+
+    async def bdu_fixes(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnFixesPackagesModel:
+        data = await self.client.get(
+            "/vuln/bdu/fixes", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnFixesPackagesModel(**data)
+
+    async def cve(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnerabilityInfoModel:
+        data = await self.client.get(
+            "/vuln/cve", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnerabilityInfoModel(**data)
+
+    async def cve_excluded(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnFixesPackagesModel:
+        data = await self.client.get(
+            "/vuln/cve/excluded", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnFixesPackagesModel(**data)
+
+    async def cve_fixes(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnFixesPackagesModel:
+        data = await self.client.get(
+            "/vuln/cve/fixes", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnFixesPackagesModel(**data)
+
+    async def ghsa(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnerabilityInfoModel:
+        data = await self.client.get(
+            "/vuln/ghsa", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnerabilityInfoModel(**data)
+
+    async def ghsa_fixes(
+        self, vuln_id: str, exclude_json: bool = False
+    ) -> models.VulnFixesPackagesModel:
+        data = await self.client.get(
+            "/vuln/ghsa/fixes", {"vuln_id": vuln_id, "exclude_json": exclude_json}
+        )
+        return models.VulnFixesPackagesModel(**data)
+
+    async def task(self, task_id: int) -> models.CveVulnerableTaskModel:
+        data = await self.client.get(f"/vuln/task/{task_id}")
+        return models.CveVulnerableTaskModel(**data)
+
 
 class ALTRepoAPI:
     def __init__(self, session: aiohttp.ClientSession):
@@ -292,6 +1824,13 @@ class ALTRepoAPI:
         self.bug = BugInfo(self._client)
         self.file = FileInfo(self._client)
         self.site = SiteInfo(self._client)
+        self.auth = AuthInfo(self._client)
+        self.dependencies = DependenciesInfo(self._client)
+        self.errata = ErrataInfo(self._client)
+        self.export = ExportInfo(self._client)
+        self.image = ImageInfo(self._client)
+        self.license = LicenseInfo(self._client)
+        self.vuln = VulnInfo(self._client)
 
     async def version(self) -> models.APIVersion:
         return await self.api.version()

src/altrepo/api/models.py

-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import List, Dict, Any
 
 
@@ -279,6 +279,12 @@ class PackageByFileNameElementModel(BaseModel):
     files: List[str]
 
 
+class PackagesByFileNamesJsonModel(BaseModel):
+    files: List[str]
+    branch: str
+    arch: str | None = None
+
+
 class PackageByFileNameModel(BaseModel):
     request_args: Dict[str, Any]
     length: int
@@ -402,3 +408,2028 @@ class SitePackagesetPackageHashModel(BaseModel):
 class FindSourcePackageInBranch(BaseModel):
     request_args: Dict[str, Any]
     source_package: str
+
+
+class AclByPackagesElementModel(BaseModel):
+    name: str
+    updated: str
+    members: List[str]
+
+
+class AclByPackagesModel(BaseModel):
+    branch: str
+    packages: List[AclByPackagesElementModel]
+
+
+class AclMaintainerGroupsElementModel(BaseModel):
+    name: str
+    groups: List[str]
+
+
+class AclMaintainerGroupsModel(BaseModel):
+    nickname: str
+    branches: List[AclMaintainerGroupsElementModel]
+
+
+class AuthResponseModel(BaseModel):
+    access_token: str
+    refresh_token: str
+
+
+class AuthLogoutResponseModel(BaseModel):
+    message: str
+
+
+class BackportHelperBinaryElementModel(BaseModel):
+    srpm: str
+    name: str
+    epoch: int
+    version: str
+    release: str
+    arch: str
+
+
+class BackportHelperBinaryDepthElementModel(BaseModel):
+    depth: int
+    packages: List[BackportHelperBinaryElementModel]
+
+
+class BackportHelperModel(BaseModel):
+    request_args: Dict[str, Any]
+    count: int
+    maxdepth: int
+    dependencies: List[BackportHelperBinaryDepthElementModel]
+
+
+class DependenciesPackageDependenciesElementModel(BaseModel):
+    name: str
+    version: str
+    type: str
+    flag: int
+    flag_decoded: List[str]
+
+
+class DependenciesPackageDependenciesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    dependencies: List[DependenciesPackageDependenciesElementModel]
+
+
+class DependenciesPackageInfoModel(BaseModel):
+    name: str
+    epoch: int
+    version: str
+    release: str
+    buildtime: int
+
+
+class DependenciesPackageInfoElementModel(BaseModel):
+    name: str
+    version: str
+    release: str
+    summary: str
+    pkghash: str
+
+
+class DependenciesPackageBuildDependenciesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    package_info: DependenciesPackageInfoModel | None
+    dependencies: List[DependenciesPackageDependenciesElementModel]
+    provided_by_src: List[DependenciesPackageInfoElementModel]
+
+
+class FastDependencySearchElementModel(BaseModel):
+    dp_name: str
+
+
+class FastDependencySearchModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    dependencies: List[FastDependencySearchElementModel]
+
+
+class DependenciesAllPackagasetsElementModel(BaseModel):
+    branch: str
+    count: int
+
+
+class DependenciesPackagesElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    arch: str
+    sourcepackage: int
+    summary: str
+    buildtime: int
+    category: str
+    maintainer: str
+    dp_types: List[str]
+
+
+class DependenciesPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[DependenciesPackagesElementModel]
+    branches: List[DependenciesAllPackagasetsElementModel]
+
+
+class PackageDependsElementModel(BaseModel):
+    pkghash: str
+    name: str
+    arch: str
+    dp_name: str
+    dp_version: str
+    dp_flag: int
+    dp_flag_decoded: List[str]
+
+
+class PackageDependsModel(BaseModel):
+    requires: PackageDependsElementModel | None
+    provides: PackageDependsElementModel | None
+
+
+class PackageBuildDependencyElementModel(BaseModel):
+    pkghash: str
+    name: str
+    branch: str
+    buildtime: str
+    acl: List[str]
+    depends: List[PackageDependsModel]
+
+
+class PackageBuildDependencyModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    dependencies: List[PackageBuildDependencyElementModel]
+
+
+class AdvisoryErrataReferenceModel(BaseModel):
+    type: str
+    link: str
+
+
+class AdvisoryErrataPackageVersionRangeModel(BaseModel):
+    begin: str
+    begin_exclude: bool
+    end: str
+    end_exclude: bool
+
+
+class AdvisoryErrataJsonModel(BaseModel):
+    type: str
+    action: str
+    is_public: bool
+    reason: str
+    description: str
+    vuln_id: str
+    vuln_cpe: str
+    branches: List[str]
+    pkg_name: str
+    pkg_evr: str
+    pkg_versions: List[AdvisoryErrataPackageVersionRangeModel]
+    references: List[AdvisoryErrataReferenceModel]
+    extra: Dict[str, Any]
+
+
+class AdvisoryErrataElementModel(BaseModel):
+    model_config = {"populate_by_name": True}
+    id: str
+    type: str
+    created: str
+    updated: str
+    pkgset_name: str
+    task_id: int
+    subtask_id: int
+    task_state: str
+    pkg_hash: str
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    references: List[AdvisoryErrataReferenceModel]
+    json_: AdvisoryErrataJsonModel | None = Field(None, alias="json")
+
+
+class AdvisoryErrataModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    erratas: List[AdvisoryErrataElementModel]
+
+
+class ErrataBranchesModel(BaseModel):
+    length: int
+    branches: List[str]
+
+
+class ErrataJsonPostListModel(BaseModel):
+    errata_ids: List[str]
+
+
+class ErrataBugModel(BaseModel):
+    id: int
+    summary: str
+    is_valid: bool
+
+
+class ErrataVulnerabilityModel(BaseModel):
+    id: str
+    hash: str
+    type: str
+    summary: str
+    score: float
+    severity: str
+    url: str
+    modified_date: str
+    published_date: str
+    body: str
+    is_valid: bool
+    parsed: Dict[str, Any] | None
+
+
+class ErrataPackageUpdateModel(BaseModel):
+    id: str
+    type: str
+    created: str
+    updated: str
+    pkgset_name: str
+    task_id: int
+    subtask_id: int
+    task_state: str
+    pkg_hash: str
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    bugs: List[ErrataBugModel]
+    vulns: List[ErrataVulnerabilityModel]
+
+
+class ErrataBranchUpdateModel(BaseModel):
+    id: str
+    type: str
+    pkgset_name: str
+    pkgset_date: str
+    packages_updates: List[ErrataPackageUpdateModel]
+
+
+class ErrataBranchesUpdatesModel(BaseModel):
+    branches_updates: List[ErrataBranchUpdateModel]
+
+
+class ErrataPackagesUpdatesModel(BaseModel):
+    packages_updates: List[ErrataPackageUpdateModel]
+
+
+class OvalBranchesModel(BaseModel):
+    length: int
+    branches: List[str]
+
+
+class VulnerabilitiesElementModel(BaseModel):
+    id: str
+    type: str
+
+
+class PackagesElementModel(BaseModel):
+    pkghash: str
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+
+
+class ErrataLastChangedElementModel(BaseModel):
+    model_config = {"populate_by_name": True}
+    is_discarded: bool
+    errata_id: str
+    eh_type: str
+    task_id: int
+    changed: str
+    branch: str
+    json_: Dict[str, Any] = Field(default_factory=dict, alias="json")
+    packages: List[PackagesElementModel]
+    vulnerabilities: List[VulnerabilitiesElementModel]
+
+
+class ErrataLastChangedModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    erratas: List[ErrataLastChangedElementModel]
+
+
+class ImageErrataElementModel(BaseModel):
+    img_hash: str
+    img_version: str
+    img_release: str
+    pkg_name: str
+    pkg_arch: str
+    pkg_hash: str
+    pkg_version: str
+    pkg_release: str
+    summary: str
+    errata_id: str
+    eh_type: str
+    task_id: int
+    changed: str
+    branch: str
+    is_discarded: bool
+    vulnerabilities: List[VulnerabilitiesElementModel]
+
+
+class ImageErrataModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    erratas: List[ImageErrataElementModel]
+
+
+class ErrataIdsListModel(BaseModel):
+    errata_ids: List[str]
+
+
+class ErrataReferenceModel(BaseModel):
+    id: str
+    type: str
+
+
+class ErrataModel(BaseModel):
+    id: str
+    type: str
+    created: str
+    updated: str
+    pkgset_name: str
+    task_id: int
+    subtask_id: int
+    task_state: str
+    pkg_hash: str
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    references: List[ErrataReferenceModel]
+
+
+class ErratasModel(BaseModel):
+    erratas: List[ErrataModel]
+
+
+class ExportBeehiveFTBFSElementModel(BaseModel):
+    branch: str
+    hash: str
+    name: str
+    epoch: int
+    version: str
+    release: str
+    arch: str
+    updated: str
+    ftbfs_since: str
+    url: str
+
+
+class ExportBeehiveFTBFSListModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    ftbfs: List[ExportBeehiveFTBFSElementModel]
+
+
+class PackagesetPackagesExportElementModel(BaseModel):
+    name: str
+    epoch: int
+    version: str
+    release: str
+    arch: str
+    disttag: str
+    buildtime: int
+    source: str
+
+
+class PackagesetPackagesExportModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[PackagesetPackagesExportElementModel]
+
+
+class BranchTreeTaskModel(BaseModel):
+    id: int
+    prev: int
+    branch: str
+    date: str
+
+
+class BranchTreeBranchCommitModel(BaseModel):
+    name: str
+    date: str
+    task: int
+
+
+class BranchTreeBranchPointModel(BaseModel):
+    branch: str
+    task: BranchTreeTaskModel | None
+    from_task: BranchTreeTaskModel | None
+
+
+class BranchTreeModel(BaseModel):
+    branches: List[str]
+    tasks: List[BranchTreeTaskModel]
+    branch_commits: List[BranchTreeBranchCommitModel]
+    branch_points: List[BranchTreeBranchPointModel]
+
+
+class RepologyExportBranchBinaryPackageElementModel(BaseModel):
+    name: str
+    epoch: int
+    version: str
+    release: str
+    summary: str
+    archs: List[str]
+
+
+class RepologyExportBranchSourcePackageElementModel(BaseModel):
+    name: str
+    epoch: int
+    version: str
+    release: str
+    url: str
+    license: str
+    category: str
+    summary: str
+    packager: str
+    homepage: str
+    recipe: str
+    recipe_raw: str
+    bugzilla: str
+    CPE: List[str]
+    binaries: List[RepologyExportBranchBinaryPackageElementModel]
+
+
+class RepologyExportBranchStatElementModel(BaseModel):
+    arch: str
+    count: int
+
+
+class RepologyExportModel(BaseModel):
+    branch: str
+    date: str
+    stats: List[RepologyExportBranchStatElementModel]
+    packages: List[RepologyExportBranchSourcePackageElementModel]
+
+
+class SitemapPackagesElementModel(BaseModel):
+    pkghash: str
+    name: str
+    buildtime: int
+
+
+class SitemapPackagesExportModel(BaseModel):
+    branch: str
+    packages: List[SitemapPackagesElementModel]
+
+
+class FastFileSearchElementModel(BaseModel):
+    file_name: str
+
+
+class FastFileSearchModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    files: List[FastFileSearchElementModel]
+
+
+class ActiveImagesElementModel(BaseModel):
+    edition: str
+    tags: List[str]
+
+
+class ActiveImagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    images: List[ActiveImagesElementModel]
+
+
+class FindImagesByPackageElementModel(BaseModel):
+    pkghash: str
+    name: str
+    branch: str
+    version: str
+    release: str
+    arch: str
+    edition: str
+    tag: str
+    file: str
+    date: str
+
+
+class FindImagesByPackageModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    images: List[FindImagesByPackageElementModel]
+
+
+class SiteImageCategoryElementModel(BaseModel):
+    category: str
+    count: int
+
+
+class SiteImageCategoriesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    categories: List[SiteImageCategoryElementModel]
+
+
+class ImageInfoComponentModel(BaseModel):
+    name: str
+    size: str
+    packages: int
+    uuid: str
+    ruuid: str
+    kv: Dict[str, Any]
+
+
+class ImageInfoElementModel(BaseModel):
+    date: str
+    uuid: str
+    tag: str
+    branch: str
+    edition: str
+    flavor: str
+    platform: str
+    release: str
+    version_major: int
+    version_minor: int
+    version_sub: int
+    arch: str
+    variant: str
+    type: str
+    file: str
+    url: List[str]
+    md5sum: str
+    gost12sum: str
+    sha256sum: str
+    components: List[ImageInfoComponentModel]
+
+
+class ImageInfoModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    images: List[ImageInfoElementModel]
+
+
+class ImagePackagesElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    arch: str
+    summary: str
+    buildtime: int
+    changelog_text: str
+
+
+class ImagePackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    subcategories: List[str]
+    packages: List[ImagePackagesElementModel]
+
+
+class ImagePackageSetModel(BaseModel):
+    length: int
+    branches: List[str]
+
+
+class ImageStatusGetElementModel(BaseModel):
+    model_config = {"populate_by_name": True}
+    branch: str
+    edition: str
+    name: str
+    show: str
+    start_date: str
+    end_date: str
+    summary_ru: str
+    summary_en: str
+    description_ru: str
+    description_en: str
+    mailing_list: str
+    name_bugzilla: str
+    json_: Dict[str, Any] = Field(default_factory=dict, alias="json")
+
+
+class ImageStatusGetModel(BaseModel):
+    images: List[ImageStatusGetElementModel]
+
+
+class ImageJSONElementModel(BaseModel):
+    img_edition: str
+    img_name: str
+    img_show: str
+    img_summary_ru: str
+    img_summary_en: str
+    img_start_date: str
+    img_end_date: str
+    img_mailing_list: str
+    img_name_bugzilla: str
+    img_json: Dict[str, Any]
+
+
+class ImageJSONModel(BaseModel):
+    img_branch: str
+    img_description_ru: str
+    img_description_en: str
+    images: List[ImageJSONElementModel]
+
+
+class ImageTagStatusGetElementModel(BaseModel):
+    tag: str
+    show: str
+
+
+class ImageTagStatusGetModel(BaseModel):
+    tags: List[ImageTagStatusGetElementModel]
+
+
+class ImageTagJSONElementModel(BaseModel):
+    img_tag: str
+    img_show: str
+
+
+class ImageTagJSONModel(BaseModel):
+    tags: List[ImageTagJSONElementModel]
+
+
+class ImageTagUUIDModel(BaseModel):
+    request_args: Dict[str, Any]
+    uuid: str
+    file: str
+    type: str
+    components: Dict[str, Any]
+
+
+class ImagePackagesElement1Model(BaseModel):
+    hash: str
+    arch: str
+    name: str
+    epoch: int
+    version: str
+    release: str
+    disttag: str
+    buildtime: int
+
+
+class ImagePackagesElement2Model(ImagePackagesElement1Model):
+    task_id: int
+    subtask_id: int
+
+
+class ImagePackagesJSONElementModel(BaseModel):
+    pkg_hash: str
+    pkg_name: str
+    pkg_epoch: int
+    pkg_version: str
+    pkg_release: str
+    pkg_arch: str
+    pkg_disttag: str
+    pkg_buildtime: int
+
+
+class ImagePackagesJSONModel(BaseModel):
+    branch: str
+    packages: List[ImagePackagesJSONElementModel]
+
+
+class ImagePackagesInspectSPPackageModel(BaseModel):
+    found_in: str
+    version_check: str
+    image: ImagePackagesElement1Model | None
+    database: ImagePackagesElement1Model | None
+    last_branch: ImagePackagesElement1Model | None
+
+
+class ImagePackagesInspectRegularModel(BaseModel):
+    request_args: Dict[str, Any]
+    input_pakages: int
+    not_in_branch: int
+    found_in_tasks: int
+    not_found_in_db: int
+    packages_in_tasks: List[ImagePackagesElement2Model]
+    packages_not_in_db: List[ImagePackagesElement1Model]
+
+
+class ImagePackagesInspectSPModel(BaseModel):
+    request_args: Dict[str, Any]
+    input_pakages: int
+    in_branch: int
+    not_in_branch: int
+    found_in_tasks: int
+    not_found_in_db: int
+    packages: List[ImagePackagesInspectSPPackageModel]
+
+
+class ImageAllISOElementModel(BaseModel):
+    branch: str
+    name: str
+    tag: str
+    file: str
+    date: str
+    uuid: str
+
+
+class ImageAllISOModel(BaseModel):
+    length: int
+    images: List[ImageAllISOElementModel]
+
+
+class LastImagePackagesElementModel(BaseModel):
+    task_id: str
+    task_changed: str
+    tplan_action: str
+    branch: str
+    hash: str
+    name: str
+    version: str
+    release: str
+    arch: str
+    img_hash: str
+    img_version: str
+    img_release: str
+    summary: str
+    chlog_name: str
+    chlog_nick: str
+    chlog_date: str
+    chlog_text: str
+
+
+class LastImagePackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[LastImagePackagesElementModel]
+
+
+class FindImagesByTaskImageElementModel(BaseModel):
+    filename: str
+    edition: str
+    tag: str
+    buildtime: str
+    binpkg_name: str
+    binpkg_version: str
+    binpkg_release: str
+    binpkg_arch: str
+    binpkg_hash: str
+
+
+class FindImagesByTaskIterationElementModel(BaseModel):
+    task_try: int
+    task_iter: int
+
+
+class FindImagesByTaskSubtaskElementModel(BaseModel):
+    id: int
+    type: str
+    srpm_name: str
+    srpm_hash: str
+    pkg_version: str
+    pkg_release: str
+    images: List[FindImagesByTaskImageElementModel]
+
+
+class FindImagesByTaskModel(BaseModel):
+    task_id: int
+    task_state: str
+    task_testonly: int
+    task_repo: str
+    task_owner: str
+    task_try: int
+    task_iter: int
+    task_message: str
+    task_changed: str
+    dependencies: List[int]
+    subtasks: List[FindImagesByTaskSubtaskElementModel]
+    iterations: List[FindImagesByTaskIterationElementModel]
+
+
+class CheckImagesInputFilterModel(BaseModel):
+    editions: List[str]
+    releases: List[str]
+    versions: List[str]
+    archs: List[str]
+    variants: List[str]
+    types: List[str]
+
+
+class CheckImagesInputModel(BaseModel):
+    task_id: int
+    packages_names: List[str]
+    filters: List[CheckImagesInputFilterModel]
+
+
+class CheckImagesOutputPackageModel(BaseModel):
+    status: str
+    from_subtask: int
+    srcpkg_name: str
+    binpkg_name: str
+    binpkg_arch: str
+
+
+class CheckImagesOutputImageModel(BaseModel):
+    file: str
+    branch: str
+    edition: str
+    flavor: str
+    platform: str
+    release: str
+    major_version: int
+    minor_version: int
+    sub_version: int
+    arch: str
+    variant: str
+    type: str
+    buildtime: str
+    packages: List[CheckImagesOutputPackageModel]
+
+
+class CheckImagesOutputModel(BaseModel):
+    request_args: Dict[str, Any]
+    in_images: List[CheckImagesOutputImageModel]
+    not_in_images: List[CheckImagesOutputPackageModel]
+
+
+class LicenseInfoModel(BaseModel):
+    request_args: Dict[str, Any]
+    id: str
+    name: str
+    text: str
+    type: str
+    header: str
+    comment: str
+    urls: List[str]
+
+
+class LicenseTokensElementModel(BaseModel):
+    token: str
+    license: str
+
+
+class LicenseTokensModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    tokens: List[LicenseTokensElementModel]
+
+
+class BuildDependencySetAmbiguousProvidesPackageModel(BaseModel):
+    name: str
+    used: bool
+
+
+class BuildDependencySetAmbiguousProvidesElementModel(BaseModel):
+    requires: str
+    provides_count: int
+    provides: List[BuildDependencySetAmbiguousProvidesPackageModel]
+
+
+class BuildDependencySetAmbiguousProvidesModel(BaseModel):
+    package: str
+    ambiguous_provides: List[BuildDependencySetAmbiguousProvidesElementModel]
+
+
+class BuildDependencySetPackageModel(BaseModel):
+    name: str
+    version: str
+    release: str
+    epoch: int
+    archs: List[str]
+    requires: List[str]
+
+
+class BuildDependencySetPackagesModel(BaseModel):
+    package: str
+    length: int
+    depends: List[BuildDependencySetPackageModel]
+
+
+class BuildDependencySetModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[BuildDependencySetPackagesModel]
+    ambiguous_dependencies: List[BuildDependencySetAmbiguousProvidesModel]
+
+
+class PackageFindPackagesetElementModel(BaseModel):
+    branch: str
+    pkgset_datetime: str
+    sourcepkgname: str
+    packages: List[str]
+    version: str
+    release: str
+    disttag: str
+    packager_email: str
+    buildtime: str
+    archs: List[str]
+
+
+class PackageFindPackagesetModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[PackageFindPackagesetElementModel]
+
+
+class MaintainerScoreElementModel(BaseModel):
+    nick: str
+    score: float
+    base_score: float
+    updates: int
+    patches: int
+    nmu: int
+    bugfixes: int
+    bugfixes_with_update: int
+    in_acl: bool
+    last_activity: str
+    recent_commits: int
+    bonus_applied: bool
+
+
+class MaintainerScoreModel(BaseModel):
+    request_args: Dict[str, Any]
+    package: str
+    branch: str
+    primary_maintainer: str
+    status: str
+    maintainers: List[MaintainerScoreElementModel]
+
+
+class PackageMisconflictPackageModel(BaseModel):
+    input_package: str
+    conflict_package: str
+    version: str
+    release: str
+    epoch: int
+    archs: List[str]
+    files_with_conflict: List[str]
+
+
+class PackageMisconflictPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    conflicts: List[PackageMisconflictPackageModel]
+
+
+class PackageFilesElementModel(BaseModel):
+    file_name: str
+    file_size: str
+    file_class: str
+    symlink: str
+    file_mtime: str
+    file_mode: str
+
+
+class PackageFilesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    files: List[PackageFilesElementModel]
+
+
+class RepocopJsonGetModel(BaseModel):
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    pkg_arch: str
+    branch: str
+    test_name: str
+    test_status: str
+    test_message: str
+    test_date: str
+
+
+class RepocopJsonGetListModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[RepocopJsonGetModel]
+
+
+class RepocopJsonPostModel(BaseModel):
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    pkg_arch: str
+    pkgset_name: str
+    rc_srcpkg_name: str
+    rc_srcpkg_version: str
+    rc_srcpkg_release: str
+    rc_test_name: str
+    rc_test_status: str
+    rc_test_message: str
+    rc_test_date: str
+
+
+class RepocopJsonPostListModel(BaseModel):
+    packages: List[RepocopJsonPostModel]
+
+
+class PackageSpecfileModel(BaseModel):
+    request_args: Dict[str, Any]
+    pkg_hash: str
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    specfile_name: str
+    specfile_date: str
+    specfile_content: str
+
+
+class UnpackagedDirsElementModel(BaseModel):
+    package: str
+    directory: str
+    version: str
+    release: str
+    epoch: int
+    packager: str
+    email: str
+    archs: List[str]
+
+
+class UnpackagedDirsModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[UnpackagedDirsElementModel]
+
+
+class PackagesetComparePackageModel(BaseModel):
+    name: str
+    version: str
+    release: str
+
+
+class PackagesetCompareElementModel(BaseModel):
+    pkgset1: str
+    pkgset2: str
+    package1: PackagesetComparePackageModel | None
+    package2: PackagesetComparePackageModel | None
+
+
+class PackagesetCompareModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[PackagesetCompareElementModel]
+
+
+class MaintainerScoresBatchMaintainerModel(BaseModel):
+    nick: str
+    score: float
+    base_score: float
+    updates: int
+    patches: int
+    nmu: int
+    bugfixes: int
+    in_acl: bool
+    last_activity: str
+    recent_commits: int
+    bonus_applied: bool
+
+
+class MaintainerScoresBatchElementModel(BaseModel):
+    package: str
+    primary_maintainer: str
+    status: str
+    maintainers: List[MaintainerScoresBatchMaintainerModel]
+
+
+class MaintainerScoresBatchModel(BaseModel):
+    request_args: Dict[str, Any]
+    branch: str
+    length: int
+    packages: List[MaintainerScoresBatchElementModel]
+
+
+class PackagesByUuidElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    arch: str
+    sourcerpm: str
+    summary: str
+    buildtime: int
+    changelog_text: str
+
+
+class PackagesByUuidModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[PackagesByUuidElementModel]
+
+
+class PackageSetStatusGetElementModel(BaseModel):
+    branch: str
+    pkgset_name_bugzilla: str
+    start_date: str
+    end_date: str
+    show: int
+    description_ru: str
+    description_en: str
+    url_mailing_list: str
+    mirrors_json: Dict[str, Any]
+    has_images: int
+
+
+class PackageSetStatusGetModel(BaseModel):
+    branches: List[PackageSetStatusGetElementModel]
+
+
+class PackageSetStatusPostElementModel(BaseModel):
+    pkgset_name: str
+    rs_pkgset_name_bugzilla: str
+    rs_start_date: str
+    rs_end_date: str
+    rs_show: int
+    rs_description_ru: str
+    rs_description_en: str
+    rs_mailing_list: str
+    rs_mirrors_json: List[Dict[str, Any]]
+
+
+class PackageSetStatusPostModel(BaseModel):
+    branches: List[PackageSetStatusPostElementModel]
+
+
+class PackagesetPackagesElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    summary: str
+    url: str
+    license: str
+    category: str
+    maintainers: List[str]
+    acl_list: List[str]
+    archs: List[str]
+
+
+class PackagesetPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[PackagesetPackagesElementModel]
+    done_tasks: List[int]
+
+
+class SiteAllArchsElementModel(BaseModel):
+    arch: str
+    count: int
+
+
+class SiteAllArchsModel(BaseModel):
+    length: int
+    archs: List[SiteAllArchsElementModel]
+
+
+class SiteAllPackagasetsElementModel(BaseModel):
+    branch: str
+    count: int
+
+
+class SiteAllPackagasetsModel(BaseModel):
+    length: int
+    branches: List[SiteAllPackagasetsElementModel]
+
+
+class SiteAllPackagesetsSummaryCountsModel(BaseModel):
+    arch: str
+    count: int
+
+
+class SiteAllPackagesetsSummaryBranchesModel(BaseModel):
+    branch: str
+    packages_count: List[SiteAllPackagesetsSummaryCountsModel]
+
+
+class SiteAllPackagesetsSummaryModel(BaseModel):
+    length: int
+    branches: List[SiteAllPackagesetsSummaryBranchesModel]
+
+
+class SiteBeehiveByMaintainerElementModel(BaseModel):
+    branch: str
+    name: str
+    version: str
+    release: str
+    arch: str
+    updated: str
+    ftbfs_since: str
+    build_time: float
+    url: str
+
+
+class SiteBeehiveByMaintainerModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    beehive: List[SiteBeehiveByMaintainerElementModel]
+
+
+class SitePackageVersionsElementModel(BaseModel):
+    branch: str
+    version: str
+    release: str
+    pkghash: str
+    deleted: bool
+
+
+class SitePackagesBinaryListElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    arch: str
+
+
+class SitePackagesBinaryListModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[SitePackagesBinaryListElementModel]
+    versions: List[SitePackageVersionsElementModel]
+
+
+class SiteBinPackageScriptsElementModel(BaseModel):
+    prein: str
+    postin: str
+    preun: str
+    postun: str
+    pretrans: str
+    posttrans: str
+
+
+class SiteBinPackageScriptsModel(BaseModel):
+    request_args: Dict[str, Any]
+    pkg_name: str
+    pkg_arch: str
+    length: int
+    scripts: List[SiteBinPackageScriptsElementModel]
+
+
+class SiteDeletedPackageModel(BaseModel):
+    branch: str
+    package: str
+    version: str
+    release: str
+    hash: str
+    task_id: int
+    subtask_id: int
+    task_owner: str
+    subtask_owner: str
+    task_changed: str
+    task_message: str
+
+
+class SiteFastPackagesSearchElementModel(BaseModel):
+    name: str
+    sourcepackage: str
+    branches: List[str]
+
+
+class SiteFastPackagesSearchModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[SiteFastPackagesSearchElementModel]
+
+
+class SiteFingPackagesPackageModel(BaseModel):
+    name: str
+    buildtime: int
+    url: str
+    summary: str
+    category: str
+    versions: List[SitePackageVersionsElementModel]
+    by_binary: bool
+
+
+class SiteFingPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[SiteFingPackagesPackageModel]
+
+
+class SiteLastPackagesElementModel(BaseModel):
+    subtask_id: int
+    subtask_userid: str
+    subtask_type: str
+    hash: str
+    name: str
+    version: str
+    release: str
+    summary: str
+    buildtime: int
+    changelog_name: str
+    changelog_nickname: str
+    changelog_date: str
+    changelog_text: str
+
+
+class SiteLastPackagesPackageModel(BaseModel):
+    task_id: int
+    task_owner: str
+    task_changed: str
+    task_message: str
+    packages: List[SiteLastPackagesElementModel]
+
+
+class SiteLastPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    tasks: List[SiteLastPackagesPackageModel]
+    last_branch_task: int
+    last_branch_date: str
+
+
+class SiteLastBranchPackagesPackageModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    summary: str
+    buildtime: int
+    changelog_name: str
+    changelog_nickname: str
+    changelog_date: str
+    changelog_text: str
+
+
+class SiteLastBranchPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[SiteLastBranchPackagesPackageModel]
+    last_branch_date: str
+
+
+class SiteLastPackagesWithCVEFixesElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    summary: str
+    buildtime: int
+    changelog_date: str
+    changelog_text: str
+
+
+class SiteLastPackagesWithCVEFixesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[SiteLastPackagesWithCVEFixesElementModel]
+
+
+class MaintainerBranchesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    branches: List[SiteAllPackagasetsElementModel]
+
+
+class MaintainerPackagesElementModel(BaseModel):
+    name: str
+    buildtime: int
+    url: str
+    summary: str
+    version: str
+    release: str
+
+
+class MaintainerPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[MaintainerPackagesElementModel]
+
+
+class SiteChangelogElementModel(BaseModel):
+    date: str
+    name: str
+    nick: str
+    evr: str
+    message: str
+
+
+class SiteChangelogModel(BaseModel):
+    pkghash: str
+    request_args: Dict[str, Any]
+    length: int
+    changelog: List[SiteChangelogElementModel]
+
+
+class SitePackagesDownloadsPackageModel(BaseModel):
+    name: str
+    url: str
+    md5: str
+    size: str
+
+
+class SitePackagesDownloadsElementModel(BaseModel):
+    arch: str
+    packages: List[SitePackagesDownloadsPackageModel]
+
+
+class SitePackagesDownloadsModel(BaseModel):
+    pkghash: str
+    request_args: Dict[str, Any]
+    downloads: List[SitePackagesDownloadsElementModel]
+
+
+class SiteBriefPackageInfoModel(BaseModel):
+    name: str
+    version: str
+    release: str
+    arch: str
+    summary: str
+    type: str
+
+
+class BinPackageLogElementModel(BaseModel):
+    pkg_hash: str
+    task_id: int
+    subtask_id: int
+    subtask_arch: str
+    buildlog_hash: str
+    link: str
+
+
+class PackageMisconflictBySrcElementModel(BaseModel):
+    input_package: str
+    input_archs: List[str]
+    conflict_package: str
+    version: str
+    release: str
+    epoch: int
+    archs: List[str]
+    files_with_conflict: List[str]
+    explicit: bool
+
+
+class PackageMisconflictBySrcModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    conflicts: List[PackageMisconflictBySrcElementModel]
+
+
+class PackageNameFromRepologyModel(BaseModel):
+    request_args: Dict[str, Any]
+    name: str
+    repo: str
+
+
+class PackageNVRByHashModel(BaseModel):
+    request_args: Dict[str, Any]
+    hash: str
+    name: str
+    version: str
+    release: str
+    is_source: bool
+
+
+class SiteSourcePackagesVersionsModel(BaseModel):
+    request_args: Dict[str, Any]
+    versions: List[SitePackageVersionsElementModel]
+
+
+class SiteImagePackageVersionsElementModel(BaseModel):
+    tag: str
+    uuid: str
+    version_major: int
+    version_minor: int
+    version_sub: int
+    img_arch: str
+    platform: str
+    variant: str
+    flavor: str
+    type: str
+    hash: str
+    name: str
+    version: str
+    release: str
+    arch: str
+
+
+class SiteImagePackageVersionsModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    versions: List[SiteImagePackageVersionsElementModel]
+
+
+class SItePackagesVersionsFromTasksElementModel(BaseModel):
+    branch: str
+    task: int
+    hash: str
+    owner: str
+    changed: str
+    name: str
+    version: str
+    release: str
+
+
+class SItePackagesVersionsFromTasksModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    versions: List[SItePackagesVersionsFromTasksElementModel]
+
+
+class SitePackagesetsByHashModel(BaseModel):
+    pkghash: str
+    length: int
+    branches: List[str]
+
+
+class SitePackagesetPackageHashByNameVersionRelease(BaseModel):
+    request_args: Dict[str, Any]
+    pkghash: str
+
+
+class SitePackagesetCategoryElementModel(BaseModel):
+    category: str
+    count: int
+
+
+class SitePackagesetCategoriesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    categories: List[SitePackagesetCategoryElementModel]
+
+
+class SitePackagesetStatusElementModel(BaseModel):
+    branch: str
+    start_date: str
+    end_date: str
+    show: int
+    description_ru: str
+    description_en: str
+    has_images: int
+
+
+class SitePackagesetsSummaryStatusModel(BaseModel):
+    length: int
+    branches: List[SiteAllPackagesetsSummaryBranchesModel]
+    status: List[SitePackagesetStatusElementModel]
+
+
+class RepocopByMaintainerElementModel(BaseModel):
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    pkg_arch: str
+    srcpkg_name: str
+    branch: str
+    test_name: str
+    test_status: str
+    test_message: str
+    test_date: str
+
+
+class RepocopByMaintainerModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[RepocopByMaintainerElementModel]
+
+
+class SitePackagesElementModel(BaseModel):
+    hash: str
+    name: str
+    version: str
+    release: str
+    summary: str
+    buildtime: int
+    category: str
+    maintainer: str
+    changelog: str
+    task_id: int
+    subtask_id: int
+    task_owner: str
+
+
+class SitePackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    subcategories: List[str]
+    packages: List[SitePackagesElementModel]
+
+
+class SiteTaskByNamePackageModel(BaseModel):
+    type: str
+    name: str
+    version: str
+    release: str
+    link: str
+
+
+class SiteTaskByNameTaskModel(BaseModel):
+    id: int
+    state: str
+    branch: str
+    owner: str
+    changed: str
+    packages: List[SiteTaskByNamePackageModel]
+
+
+class SiteTaskByNameModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    tasks: List[SiteTaskByNameTaskModel]
+
+
+class TasksHistoryBranchCommitModel(BaseModel):
+    name: str
+    date: str
+    task: int
+
+
+class TasksHistoryTaskModel(BaseModel):
+    id: int
+    prev: int
+    branch: str
+    date: str
+
+
+class SiteTasksHistoryModel(BaseModel):
+    branches: List[str]
+    tasks: List[TasksHistoryTaskModel]
+    branch_commits: List[TasksHistoryBranchCommitModel]
+
+
+class AllTasksBranchesModel(BaseModel):
+    length: int
+    branches: List[str]
+
+
+class FindTasksElementModel(BaseModel):
+    task_id: int
+    task_owner: str
+    task_state: str
+    task_repo: str
+    components: List[str]
+
+
+class FindTasksModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    tasks: List[FindTasksElementModel]
+
+
+class TaskInfoPackageModel(BaseModel):
+    name: str
+    version: str
+    release: str
+    filename: str
+
+
+class TaskInfoApprovalsModel(BaseModel):
+    date: str
+    type: str
+    name: str
+    message: str
+
+
+class TaskInfoArchsModel(BaseModel):
+    last_changed: str
+    arch: str
+    status: str
+
+
+class TaskInfoSubtaskModel(BaseModel):
+    subtask_id: int
+    last_changed: str
+    userid: str
+    type: str
+    sid: str
+    dir: str
+    package: str
+    tag_author: str
+    tag_name: str
+    tag_id: str
+    srpm: str
+    srpm_name: str
+    srpm_evr: str
+    pkg_from: str
+    source_package: TaskInfoPackageModel | None
+    approvals: List[TaskInfoApprovalsModel]
+    archs: List[TaskInfoArchsModel]
+
+
+class TaskInfoPlanModel(BaseModel):
+    src: List[TaskInfoPackageModel]
+    bin: List[TaskInfoPackageModel]
+
+
+class TaskInfoPlan2Model(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    add: TaskInfoPlanModel | None
+    del_: TaskInfoPlanModel | None = Field(None, alias="del")
+
+
+class TaskInfoModel(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    id: int
+    prev: int
+    try_: int | None = Field(None, alias="try")
+    iter: int
+    rebuilds: List[str]
+    state: str
+    branch: str
+    user: str
+    runby: str
+    testonly: int
+    failearly: int
+    shared: int
+    depends: List[int]
+    message: str
+    version: str
+    last_changed: str
+    subtasks: List[TaskInfoSubtaskModel]
+    plan: TaskInfoPlan2Model | None
+
+
+class TaskPackagesPackageElementModel(BaseModel):
+    name: str
+    epoch: int
+    version: str
+    release: str
+    disttag: str
+    buildtime: str
+    arch: str
+
+
+class TaskPackagesSubtaskElementModel(BaseModel):
+    subtask: int
+    source: TaskPackagesPackageElementModel | None
+    binaries: List[TaskPackagesPackageElementModel]
+
+
+class TaskPackagesModel(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    id: int
+    repo: str
+    owner: str
+    state: str
+    testonly: int
+    try_: int | None = Field(None, alias="try")
+    iter: int
+    message: str
+    dependencies: List[int]
+    length: int
+    subtasks: List[TaskPackagesSubtaskElementModel]
+    arepo: List[TaskPackagesPackageElementModel]
+
+
+class TaskDiffDependenciesModel(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    type: str
+    del_: List[str] = Field(default_factory=list, alias="del")
+    add: List[str]
+
+
+class TaskDiffPackagesModel(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    package: str
+    del_: List[str] = Field(default_factory=list, alias="del")
+    add: List[str]
+    dependencies: List[TaskDiffDependenciesModel]
+
+
+class TaskDiffArchsModel(BaseModel):
+    arch: str
+    packages: List[TaskDiffPackagesModel]
+
+
+class TaskDiffModel(BaseModel):
+    task_id: int
+    task_have_plan: bool
+    task_diff: List[TaskDiffArchsModel]
+
+
+class TaskFindPackagesetElementModel(BaseModel):
+    branch: str
+    pkgset_datetime: str
+    sourcepkgname: str
+    packages: List[str]
+    version: str
+    release: str
+    disttag: str
+    packager_email: str
+    buildtime: str
+    archs: List[str]
+
+
+class TaskFindPackagesetModel(BaseModel):
+    id: int
+    request_args: Dict[str, Any]
+    task_packages: List[str]
+    length: int
+    packages: List[TaskFindPackagesetElementModel]
+
+
+class TaskMisconflictPackageModel(BaseModel):
+    input_package: str
+    conflict_package: str
+    version: str
+    release: str
+    epoch: int
+    archs: List[str]
+    files_with_conflict: List[str]
+
+
+class TaskMisconflictPackagesModel(BaseModel):
+    id: int
+    request_args: Dict[str, Any]
+    length: int
+    conflicts: List[TaskMisconflictPackageModel]
+
+
+class NeedsApprovalSubtaskElementModel(BaseModel):
+    id: int
+    type: str
+    package: str
+    userid: str
+    dir: str
+    sid: str
+    pkg_from: str
+    tag_author: str
+    tag_id: str
+    tag_name: str
+    srpm: str
+    srpm_name: str
+    srpm_evr: str
+    last_changed: str
+    source_package: TaskInfoPackageModel | None
+
+
+class NeedsApprovalTaskElementModel(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    id: int
+    state: str
+    runby: str
+    try_: int | None = Field(None, alias="try")
+    iter: int
+    failearly: bool
+    shared: bool
+    depends: List[int]
+    testonly: bool
+    message: str
+    version: str
+    prev: int
+    last_changed: str
+    branch: str
+    user: str
+    subtasks: List[NeedsApprovalSubtaskElementModel]
+
+
+class NeedsApprovalModel(BaseModel):
+    length: int
+    tasks: List[NeedsApprovalTaskElementModel]
+
+
+class TaskHistoryElementModel(BaseModel):
+    task_id: int
+    task_commited: str
+    branch_commited: str
+
+
+class TaskHistoryModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    tasks: List[TaskHistoryElementModel]
+
+
+class TaskRepoPackageModel(BaseModel):
+    name: str
+    version: str
+    release: str
+    filename: str
+
+
+class TaskRepoInfoModel(BaseModel):
+    name: str
+    date: str
+    tag: str
+
+
+class TaskRepoArchsModel(BaseModel):
+    arch: str
+    packages: List[TaskRepoPackageModel]
+
+
+class TaskRepoModel(BaseModel):
+    task_id: int
+    base_repository: TaskRepoInfoModel | None
+    task_diff_list: List[int]
+    archs: List[TaskRepoArchsModel]
+
+
+class TaskBuildDependencyElementModel(BaseModel):
+    depth: int
+    name: str
+    version: str
+    release: str
+    epoch: int
+    serial: int
+    sourcerpm: str
+    branch: str
+    buildtime: str
+    archs: List[str]
+    cycle: List[str]
+    requires: List[str]
+    acl: List[str]
+
+
+class TaskBuildDependencyModel(BaseModel):
+    id: int
+    request_args: Dict[str, Any]
+    length: int
+    dependencies: List[TaskBuildDependencyElementModel]
+
+
+class VulnerabilityReferenceElementModel(BaseModel):
+    name: str
+    url: str
+    tags: List[str]
+
+
+class VulnerabilityCVSSVectorElementModel(BaseModel):
+    version: str
+    score: float
+    vector: str
+
+
+class VulnerabilityConfigurationElementModel(BaseModel):
+    cpe: str
+    version_start_excluding: str
+    version_start_including: str
+    version_end_excluding: str
+    version_end_including: str
+
+
+class VulnerabilityParsedDetailsModel(BaseModel):
+    references: List[VulnerabilityReferenceElementModel]
+    cvss_vectors: List[VulnerabilityCVSSVectorElementModel]
+    configurations: List[VulnerabilityConfigurationElementModel]
+    cwes: List[str]
+
+
+class VulnerabilityModel(BaseModel):
+    model_config = {"populate_by_name": True}
+    id: str
+    summary: str
+    url: str
+    severity: str
+    score: float
+    published: str
+    modified: str
+    refs: List[str]
+    json_: Dict[str, Any] = Field(default_factory=dict, alias="json")
+    rejected: bool
+
+
+class VulnerabilityInfoModel(BaseModel):
+    request_args: Dict[str, Any]
+    vuln_info: VulnerabilityModel | None
+    parsed: VulnerabilityParsedDetailsModel | None
+
+
+class VulnPackageLastVersionModel(BaseModel):
+    pkghash: str
+    name: str
+    branch: str
+    version: str
+    release: str
+
+
+class VulnFixesPackagesElementModel(BaseModel):
+    pkghash: str
+    name: str
+    branch: str
+    version: str
+    release: str
+    errata_id: str
+    task_id: int
+    task_state: str
+    last_version: VulnPackageLastVersionModel | None
+
+
+class VulnFixesPackagesModel(BaseModel):
+    request_args: Dict[str, Any]
+    length: int
+    packages: List[VulnFixesPackagesElementModel]
+
+
+class CveTaskPackageVulnerableElementModel(BaseModel):
+    id: str
+    type: str
+    link: str
+
+
+class CveTaskPackagesElementModel(BaseModel):
+    subtask: int
+    pkghash: str
+    pkg_name: str
+    pkg_version: str
+    pkg_release: str
+    branch: str
+    errata_id: str
+    errata_link: str
+    vulnerabilities: List[CveTaskPackageVulnerableElementModel]
+
+
+class CveVulnerableTaskModel(BaseModel):
+    packages: List[CveTaskPackagesElementModel]