@fa-software/semi2-dsh 0.0.18 → 0.0.19-preview.20261001161030

package/lib/types/api/generated/http.d.ts

@@ -0,0 +1,3924 @@
+export interface paths {
+    "/api/v1/logs/{book}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                book: "operations" | "security" | "client-events";
+            };
+            cookie?: never;
+        };
+        /** @description Administrator-only event book; client-events selects events without a session */
+        get: operations["listLogEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/logs/{book}/action-options": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                book: "operations" | "security" | "client-events";
+            };
+            cookie?: never;
+        };
+        get: operations["listLogActionOptions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/logs/client-sessions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listClientSessions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/logs/client-sessions/timeline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readClientSessionTimeline"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/me/cnb-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readMyCnbAccount"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/me/cnb-account/token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put: operations["replaceMyCnbToken"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/me/cnb-account/refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["refreshMyCnbAccount"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/users/{id}/cnb-account/token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /** @description Administrator only; replacement token must match the bound external identity */
+        put: operations["replaceUserCnbToken"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/users/{id}/cnb-account/refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["refreshUserCnbAccount"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/members": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listUpstreamCnbMembers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/repositories": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listUpstreamCnbRepositories"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/users/import": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["importCnbUsers"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/projects/sync": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["syncCnbProjects"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/access-keys": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listCnbAccessKeys"];
+        put?: never;
+        post: operations["createCnbAccessKey"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/access-keys/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete: operations["revokeCnbAccessKey"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/integrations/cnb/access-keys/{id}/rotate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["rotateCnbAccessKey"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readViewer"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/roles": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listRoles"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Administrator only */
+        get: operations["listUsers"];
+        put?: never;
+        /** @description Create pending account from verified CNB identity; does not create password or login session */
+        post: operations["createUser"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/users/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readUser"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/users/{id}/roles": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /** @description USER role is mandatory; cannot remove the last active administrator */
+        patch: operations["setUserRoles"];
+        trace?: never;
+    };
+    "/api/v1/users/{id}/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /** @description Pending accounts must activate before becoming active; disabling revokes sessions and activation links */
+        patch: operations["setUserStatus"];
+        trace?: never;
+    };
+    "/api/v1/users/{id}/activation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["issueActivation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/models": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listModels"];
+        put?: never;
+        /** @description Custom connections only; provider preset models must be imported from a catalog */
+        post: operations["createModel"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/models/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readModel"];
+        put?: never;
+        post?: never;
+        delete: operations["deleteModel"];
+        options?: never;
+        head?: never;
+        /** @description Omitted fields remain unchanged; null removes metadata overrides or the default reasoning level */
+        patch: operations["updateModel"];
+        trace?: never;
+    };
+    "/api/v1/model-connections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listModelConnections"];
+        put?: never;
+        post: operations["createModelConnection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/model-connections/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readModelConnection"];
+        put?: never;
+        post?: never;
+        delete: operations["deleteModelConnection"];
+        options?: never;
+        head?: never;
+        /** @description Destination changes with an existing key require explicit reuse, replacement or clearing */
+        patch: operations["updateModelConnection"];
+        trace?: never;
+    };
+    "/api/v1/model-provider-presets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listModelProviderPresets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/model-references/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["queryModelReferences"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/model-connections/{id}/catalog/upstream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readUpstreamModelCatalog"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/model-connections/{id}/catalog/builtin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readBuiltinModelCatalog"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/model-connections/{id}/catalog/sync": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["syncModelCatalog"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/model-connections/{id}/catalog/import-builtin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["importBuiltinModels"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/configuration/global": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readGlobalConfiguration"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /** @description Administrator only; omitted fields remain unchanged and explicit null clears nullable fields */
+        patch: operations["saveGlobalConfiguration"];
+        trace?: never;
+    };
+    "/api/v1/me/configuration": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readMyConfiguration"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch: operations["saveMyConfiguration"];
+        trace?: never;
+    };
+    "/api/v1/users/{id}/configuration": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        /** @description Self or administrator */
+        get: operations["readUserConfiguration"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /** @description Self or administrator; validation failure leaves settings and audit unchanged */
+        patch: operations["saveUserConfiguration"];
+        trace?: never;
+    };
+    "/api/v1/users/{id}/model-credentials": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readUserCredentialReferences"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/available-models": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listAvailableModels"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/effective-model-defaults": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readEffectiveModelDefaults"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/projects": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listProjects"];
+        put?: never;
+        post: operations["createProject"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/projects/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readProject"];
+        put?: never;
+        post?: never;
+        delete: operations["deleteProject"];
+        options?: never;
+        head?: never;
+        patch: operations["updateProject"];
+        trace?: never;
+    };
+    "/api/v1/projects/{id}/headless-models": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch: operations["updateProjectHeadlessModels"];
+        trace?: never;
+    };
+    "/api/v1/projects/{id}/access/{userId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+                userId: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put: operations["setProjectAccess"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/project-organizations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listProjectOrganizations"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listSkills"];
+        put?: never;
+        post: operations["createSkill"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readSkill"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}/content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put: operations["saveSkillContent"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}/archived": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["setSkillArchived"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}/versions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["listSkillVersions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}/files": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get: operations["readSkillFiles"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}/files/write": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["writeSkillFiles"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/skills/{id}/files/remove": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["removeSkillFiles"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/self-portrait": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readSelfPortrait"];
+        put: operations["saveSelfPortrait"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/self-portrait/versions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listSelfPortraitVersions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/runtime/bootstrap": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["runtimeBootstrap"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/runtime/projects/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["runtimeProjects"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/runtime/model-credentials/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["runtimeCredentials"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/runtime/skills/{id}/files": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["runtimeSkillFiles"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/runtime/projects/{id}/profile": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["runtimeProjectProfile"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/runtime/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["runtimeReportEvent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/healthz": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Check application and database readiness */
+        get: operations["health"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/login": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["login"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["issueUserToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/session": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readSession"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/logout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["logout"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/change-password": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["changePassword"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/setup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["readSetupState"];
+        put?: never;
+        post: operations["initializeHub"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/register": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["registerMember"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/cnb-token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["exchangeCnbToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/activate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["activateAccount"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        PasswordLogin: {
+            username: string;
+            password: string;
+        };
+        Session: {
+            user: components["schemas"]["User"];
+            csrfToken: string;
+        };
+        User: {
+            /** Format: uuid */
+            id: string;
+            username: string;
+            displayName: string;
+            roles: ("USER" | "ADMIN")[];
+            /** @enum {string} */
+            status: "PENDING" | "ACTIVE" | "DISABLED";
+            revision: number;
+            /** Format: date-time */
+            createdAt: string;
+            cnbAccount: components["schemas"]["CnbAccount"];
+        };
+        CnbAccount: {
+            externalUserId: string;
+            username: string;
+            nickname: string | null;
+            avatar: string | null;
+            /** @enum {string} */
+            state: "CONNECTED" | "AWAITING_BINDING" | "RECONNECT_REQUIRED";
+            organizationPath: string;
+            /** Format: date-time */
+            verifiedAt: string | null;
+            /** Format: date-time */
+            membershipVerifiedAt: string | null;
+        };
+        ApiError: {
+            code: string;
+            message: string;
+            /** Format: uuid */
+            requestId: string;
+        };
+        PageWindow: {
+            /** @default 20 */
+            first: number;
+            /** @default 0 */
+            offset: number;
+        };
+        /** @enum {string} */
+        Outcome: "SUCCESS" | "DENIED" | "ERROR";
+        /** @enum {string} */
+        Channel: "CONSOLE" | "NPC" | "WORKSTATION" | "CONTAINER_WEB" | "HOST" | "UNKNOWN";
+        /** @enum {string} */
+        ActorKind: "SESSION" | "USER_KEY" | "ACCESS_KEY" | "ANONYMOUS";
+        Event: {
+            /** Format: uuid */
+            id: string;
+            /** Format: date-time */
+            occurredAt: string;
+            action: string;
+            actionLabel: string;
+            actorId: string | null;
+            actorUsername: string | null;
+            actorDisplayName: string | null;
+            actorKind: components["schemas"]["ActorKind"];
+            outcome: components["schemas"]["Outcome"];
+            code: string | null;
+            detail: {
+                [key: string]: unknown;
+            };
+            targetType?: string | null;
+            targetId?: string | null;
+            targetLabel?: string | null;
+            durationMs?: number | null;
+            clientIp?: string | null;
+            userAgent?: string | null;
+            channel?: components["schemas"]["Channel"];
+            sessionKey?: string | null;
+        };
+        "schemas-Session": {
+            key: string;
+            sessionId: string | null;
+            clientId: string | null;
+            runRef: string | null;
+            channel: components["schemas"]["Channel"];
+            actorId: string | null;
+            actorKind: components["schemas"]["ActorKind"];
+            actorUsername: string | null;
+            actorDisplayName: string | null;
+            clientIp?: string | null;
+            workspaceSlug?: string | null;
+            workspacePath?: string | null;
+            projectId?: string | null;
+            projectLabel?: string | null;
+            modelId?: string | null;
+            reasoningLevel?: string | null;
+            outcome: components["schemas"]["Outcome"];
+            code?: string | null;
+            /** Format: date-time */
+            startedAt: string;
+            /** Format: date-time */
+            endedAt: string | null;
+            endReason?: string | null;
+            eventCount: number;
+        };
+        Member: {
+            externalUserId: string;
+            username: string;
+            nickname: string | null;
+            avatar: string | null;
+            organizationPath: string;
+            registered: boolean;
+        };
+        Repository: {
+            externalRepoId: string;
+            path: string;
+            name: string;
+            /** Format: uri */
+            webUrl: string;
+            /** @enum {string} */
+            status: "active" | "archived" | "forking";
+            /** @enum {string} */
+            visibility: "Private" | "Public";
+            frozen: boolean;
+            imported: boolean;
+        };
+        AccessKey: {
+            /** Format: uuid */
+            id: string;
+            name: string;
+            hint: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            rotatedAt: string | null;
+            /** Format: date-time */
+            lastUsedAt: string | null;
+        };
+        AdminUser: components["schemas"]["User"] & {
+            revokedProjectCount: number;
+            /** Format: date-time */
+            lastActivityAt: string | null;
+        };
+        /** @enum {string} */
+        Protocol: "DEEPSEEK" | "OPENAI_CHAT" | "OPENAI_RESPONSES" | "ANTHROPIC";
+        /** @enum {string} */
+        DiscoveryStatus: "NEVER" | "STALE" | "SUCCESS" | "FAILED";
+        Connection: {
+            /** Format: uuid */
+            id: string;
+            displayName: string;
+            provider: string | null;
+            /** @enum {string} */
+            protocol: "DEEPSEEK" | "OPENAI_CHAT" | "OPENAI_RESPONSES" | "ANTHROPIC";
+            /** Format: uri */
+            baseUrl: string;
+            enabled: boolean;
+            keyConfigured: boolean;
+            revision: number;
+            credentialRevision: number;
+            /** Format: date-time */
+            lastDiscoveryAt: string | null;
+            /** @enum {string|null} */
+            lastDiscoveryError: "CREDENTIALS_NOT_CONFIGURED" | "UPSTREAM_CREDENTIALS_REJECTED" | "DISCOVERY_UNSUPPORTED" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_TIMEOUT" | "UPSTREAM_RESPONSE_TOO_LARGE" | "UPSTREAM_REDIRECT_FORBIDDEN" | "MODEL_URL_FORBIDDEN" | "INVALID_MODEL_URL" | "INVALID_MODEL_CATALOG" | "UPSTREAM_PAGINATION_ERROR" | "MODEL_CATALOG_TOO_LARGE" | null;
+            /** @enum {string} */
+            discoveryStatus: "NEVER" | "STALE" | "SUCCESS" | "FAILED";
+        };
+        /** @enum {string|null} */
+        ReasoningLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | null;
+        Metadata: {
+            contextWindow?: number;
+            maxTokens?: number;
+            input?: ("text" | "image")[];
+            reasoningLevels?: components["schemas"]["ReasoningLevel"][];
+        };
+        Model: {
+            /** Format: uuid */
+            id: string;
+            upstreamId: string;
+            displayName: string | null;
+            connection: components["schemas"]["Connection"];
+            discoveredMetadata: components["schemas"]["Metadata"];
+            overrides: components["schemas"]["Metadata"];
+            metadata: components["schemas"]["Metadata"];
+            metadataSources: {
+                /** @enum {string} */
+                field: "contextWindow" | "maxTokens" | "input" | "reasoningLevels";
+                /** @enum {string} */
+                source: "MANUAL" | "DISCOVERED" | "BUILTIN" | "DSH_DEFAULT";
+            }[];
+            present: boolean;
+            manual: boolean;
+            builtin: boolean;
+            enabled: boolean;
+            revision: number;
+            defaultReasoningLevel: components["schemas"]["ReasoningLevel"];
+        };
+        /** @enum {string|null} */
+        ReasoningInput: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | "OFF" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH" | "XHIGH" | "MAX" | null;
+        ModelWrite: {
+            expectedRevision: number;
+            /** Format: uuid */
+            connectionId?: string;
+            upstreamId?: string;
+            displayName?: string | null;
+            enabled?: boolean;
+            retainMissing?: boolean;
+            defaultReasoningLevel?: components["schemas"]["ReasoningInput"];
+            overrides?: {
+                contextWindow?: number | null;
+                maxTokens?: number | null;
+                input?: ("text" | "image" | "TEXT" | "IMAGE")[] | null;
+                reasoningLevels?: components["schemas"]["ReasoningInput"][] | null;
+            };
+        };
+        SecretChange: {
+            value: string;
+        } | {
+            /** @constant */
+            clear: true;
+        };
+        Reference: {
+            model: {
+                /** Format: uuid */
+                id: string;
+                upstreamId: string;
+                displayName: string | null;
+            };
+            /** @enum {string} */
+            scope: "GLOBAL_WEB" | "GLOBAL_PLAN" | "GLOBAL_EXECUTE" | "PROJECT_PLAN" | "PROJECT_EXECUTE";
+            project: null | {
+                /** Format: uuid */
+                id: string;
+                slug: string;
+                name: string;
+            };
+        };
+        Preferences: {
+            /** Format: uuid */
+            defaultModelId?: string | null;
+            /** Format: uuid */
+            planModelId?: string | null;
+            /** Format: uuid */
+            executeModelId?: string | null;
+        };
+        GlobalConfiguration: {
+            revision: number;
+            preferences: components["schemas"]["Preferences"];
+            redmineBaseUrl: string | null;
+        };
+        UserConfiguration: {
+            /** Format: uuid */
+            userId: string;
+            revision: number;
+            redmineApiKeyConfigured: boolean;
+        };
+        ModelSecretChange: {
+            value: string;
+        } | {
+            /** @constant */
+            clear: true;
+        };
+        Selection: {
+            modelId: string | null;
+            reasoningLevel: components["schemas"]["ReasoningLevel"];
+        };
+        Project: {
+            /** Format: uuid */
+            id: string;
+            /** @enum {string} */
+            kind: "LOCAL" | "CNB";
+            slug: string;
+            name: string;
+            webUrl: string | null;
+            enabled: boolean;
+            /** @enum {string} */
+            upstreamStatus: "ACTIVE" | "ARCHIVED" | "FORKING" | "UNAVAILABLE";
+            redmineProjectId: number | null;
+            revision: number;
+            headlessModelsRevision: number;
+            /** Format: date-time */
+            createdAt: string;
+            planModelId: string | null;
+            executeModelId: string | null;
+            planReasoningLevel: components["schemas"]["ReasoningLevel"];
+            executeReasoningLevel: components["schemas"]["ReasoningLevel"];
+            revokedCount: number | null;
+            skillCount: number | null;
+            members?: {
+                /** Format: uuid */
+                userId: string;
+                present: boolean;
+            }[];
+        };
+        File: {
+            path: string;
+            sizeBytes: number;
+            mimeType: string;
+            isExecutable: boolean;
+        };
+        Skill: {
+            id: string;
+            projectId: string | null;
+            name: string;
+            description: string;
+            whenToUse: string | null;
+            invocation: {
+                modelInvocable: boolean;
+                userInvocable: boolean;
+            };
+            metadata: {
+                [key: string]: unknown;
+            } | null;
+            content: string;
+            version: number;
+            files: components["schemas"]["File"][];
+            fileCount: number;
+            filesBytes: number;
+        };
+        "schemas-Skill": components["schemas"]["Skill"] & {
+            archived: boolean;
+            /** Format: date-time */
+            updatedAt: string;
+            disableModelInvocation: boolean | null;
+            userInvocable: boolean | null;
+        };
+        FileInput: {
+            path: string;
+            content: string;
+            /** @enum {string|null} */
+            encoding?: "UTF8" | "BASE64" | "utf-8" | "base64" | null;
+            isExecutable?: boolean | null;
+        };
+        Version: {
+            version: number;
+            content: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: uuid */
+            createdBy: string;
+            createdByUsername: string | null;
+            createdByDisplayName: string | null;
+        };
+        SkillVersion: components["schemas"]["Version"] & {
+            archived: boolean;
+        };
+        FileContent: components["schemas"]["File"] & {
+            content: string;
+            /** @enum {string} */
+            encoding: "UTF8" | "BASE64";
+        };
+        Portrait: {
+            version: number;
+            content: string;
+            /** Format: date-time */
+            updatedAt: string | null;
+            /** Format: uuid */
+            updatedBy: string | null;
+            updatedByUsername: string | null;
+            updatedByDisplayName: string | null;
+        };
+        Viewer: {
+            id: string;
+            username: string;
+            displayName: string;
+        };
+        Failure: {
+            /** @constant */
+            status: "error";
+            code: string;
+        };
+        "schemas-Connection": {
+            id: string;
+            provider: string | null;
+            /** @enum {string} */
+            protocol: "DEEPSEEK" | "OPENAI_CHAT" | "OPENAI_RESPONSES" | "ANTHROPIC";
+            /** Format: uri */
+            baseUrl: string;
+        };
+        "schemas-Model": {
+            id: string;
+            upstreamId: string;
+            displayName: string | null;
+            metadata: components["schemas"]["Metadata"];
+            defaultReasoningLevel: components["schemas"]["ReasoningLevel"];
+            connection: components["schemas"]["schemas-Connection"];
+        };
+        Credential: {
+            connectionId: string;
+            value: string;
+        };
+        ModelConfiguration: {
+            models: components["schemas"]["schemas-Model"][];
+            credentials: components["schemas"]["Credential"][];
+            defaults: {
+                web: components["schemas"]["Selection"];
+                plan: components["schemas"]["Selection"];
+                execute: components["schemas"]["Selection"];
+            };
+        };
+        Redmine: {
+            baseUrl: string | null;
+            apiKey: string | null;
+        };
+        Bootstrap: {
+            viewer: components["schemas"]["Viewer"];
+            models: components["schemas"]["Failure"] | {
+                /** @constant */
+                status: "ok";
+                data: components["schemas"]["ModelConfiguration"];
+            };
+            skills: components["schemas"]["Failure"] | {
+                /** @constant */
+                status: "ok";
+                data: components["schemas"]["Skill"][];
+            };
+            selfPortrait: components["schemas"]["Failure"] | {
+                /** @constant */
+                status: "ok";
+                data: string;
+            };
+            redmine: components["schemas"]["Failure"] | {
+                /** @constant */
+                status: "ok";
+                data: components["schemas"]["Redmine"];
+            };
+        };
+        "schemas-Project": {
+            id: string;
+            slug: string;
+            name: string;
+            enabled: boolean;
+            planModelId: string | null;
+            executeModelId: string | null;
+            planReasoningLevel: components["schemas"]["ReasoningLevel"];
+            executeReasoningLevel: components["schemas"]["ReasoningLevel"];
+        };
+        RedmineProject: {
+            id: number;
+            identifier: string;
+            name: string;
+            status: number;
+            homepage: string | null;
+            description: string | null;
+            customFields: {
+                name: string;
+                value: string;
+            }[];
+            truncated: boolean;
+        };
+        ProjectProfile: {
+            projectName: string;
+            projectSlug: string;
+            redmineProjectId: number | null;
+            redmine: components["schemas"]["RedmineProject"] | null;
+        };
+        EventInput: {
+            /** @enum {string} */
+            action: "SESSION_START" | "SESSION_CREATED" | "SESSION_DISPOSED" | "SESSION_FAILED" | "SESSION_REFUSED" | "DELIVERY_READY" | "DELIVERY_VERIFIED";
+            /** @enum {string} */
+            outcome: "SUCCESS" | "DENIED" | "ERROR";
+            code?: string | null;
+            projectSlug?: string | null;
+            targetLabel?: string | null;
+            detail?: {
+                [key: string]: unknown;
+            } | null;
+            sessionId?: string | null;
+            clientId?: string | null;
+            runRef?: string | null;
+            workspacePath?: string | null;
+            workspaceSlug?: string | null;
+            modelId?: string | null;
+            reasoningLevel?: string | null;
+        };
+        "schemas-Event": {
+            /** Format: uuid */
+            id: string;
+            action: string;
+            /** @enum {string} */
+            outcome: "SUCCESS" | "DENIED" | "ERROR";
+            code: string | null;
+            /** Format: date-time */
+            occurredAt: string;
+        };
+    };
+    responses: {
+        /** @description Authenticated user and CSRF token; console_session cookie is set */
+        Session: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Session"];
+            };
+        };
+        /** @description Request rejected or operation failed; secrets are never included */
+        Error: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description Operation completed */
+        Ok: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    /** @constant */
+                    ok: true;
+                };
+            };
+        };
+        /** @description Bound identity and connection state, never token plaintext */
+        Account: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["CnbAccount"];
+            };
+        };
+        /** @description Key returned once; server stores only its digest */
+        NewKey: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    key: string;
+                    record: components["schemas"]["AccessKey"];
+                };
+            };
+        };
+        /** @description Account without credentials */
+        User: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["User"];
+            };
+        };
+        /** @description Model configuration including stored and effective metadata */
+        Model: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Model"];
+            };
+        };
+        /** @description Connection configuration and discovery status */
+        Connection: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Connection"];
+            };
+        };
+        /** @description Read-only model catalog */
+        Catalog: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    upstreamId: string;
+                    displayName: string | null;
+                    metadata: components["schemas"]["Metadata"];
+                }[];
+            };
+        };
+        /** @description Stored global settings */
+        Global: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["GlobalConfiguration"];
+            };
+        };
+        /** @description Personal configuration status with no plaintext credentials */
+        "responses-User": {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["UserConfiguration"];
+            };
+        };
+        /** @description Stored project configuration; availability is resolved separately for runtime reads */
+        Project: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Project"];
+            };
+        };
+        /** @description Selected skill snapshot */
+        Skill: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["schemas-Skill"];
+            };
+        };
+        /** @description Current self portrait; version zero and empty content when never configured */
+        Portrait: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Portrait"];
+            };
+        };
+    };
+    parameters: {
+        Origin: string;
+        Csrf: string;
+        First: number;
+        Offset: number;
+        Actor: string;
+        Outcome: components["schemas"]["Outcome"];
+        /** @description Inclusive lower time bound */
+        From: string;
+        /** @description Inclusive upper time bound */
+        To: string;
+        Id: string;
+        Revision: number;
+        /** @description Omitted selects head */
+        Version: number;
+    };
+    requestBodies: {
+        Enrollment: {
+            content: {
+                "application/json": {
+                    cnbToken: string;
+                    password: string;
+                };
+            };
+        };
+        Token: {
+            content: {
+                "application/json": {
+                    token: string;
+                };
+            };
+        };
+        Connection: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    displayName: string;
+                    provider?: string | null;
+                    protocol: components["schemas"]["Protocol"];
+                    /** Format: uri */
+                    baseUrl?: string;
+                    enabled?: boolean;
+                    apiKey?: components["schemas"]["SecretChange"] | {
+                        /** @constant */
+                        reuse: true;
+                    };
+                };
+            };
+        };
+        Selection: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    upstreamIds: string[];
+                };
+            };
+        };
+        User: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    modelCredentials?: {
+                        /** Format: uuid */
+                        connectionId: string;
+                        apiKey?: components["schemas"]["ModelSecretChange"];
+                    }[];
+                    redmineApiKey?: components["schemas"]["SecretChange"];
+                };
+            };
+        };
+    };
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    listLogEvents: {
+        parameters: {
+            query?: {
+                first?: components["parameters"]["First"];
+                offset?: components["parameters"]["Offset"];
+                actorUserId?: components["parameters"]["Actor"];
+                outcome?: components["parameters"]["Outcome"];
+                /** @description Inclusive lower time bound */
+                from?: components["parameters"]["From"];
+                /** @description Inclusive upper time bound */
+                to?: components["parameters"]["To"];
+                action?: string;
+                /** @description Client events only */
+                channel?: components["schemas"]["Channel"];
+                /** @description Operations and client events only */
+                targetType?: string;
+                /** @description Operations and client events only */
+                targetId?: string;
+            };
+            header?: never;
+            path: {
+                book: "operations" | "security" | "client-events";
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Filtered page with authoritative total */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        total: number;
+                        items: components["schemas"]["Event"][];
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listLogActionOptions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                book: "operations" | "security" | "client-events";
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Registered action codes and labels for this book */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        action: string;
+                        label: string;
+                    }[];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listClientSessions: {
+        parameters: {
+            query?: {
+                first?: components["parameters"]["First"];
+                offset?: components["parameters"]["Offset"];
+                actorUserId?: components["parameters"]["Actor"];
+                outcome?: components["parameters"]["Outcome"];
+                /** @description Inclusive lower time bound */
+                from?: components["parameters"]["From"];
+                /** @description Inclusive upper time bound */
+                to?: components["parameters"]["To"];
+                channel?: components["schemas"]["Channel"];
+                workspaceSlug?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description One row per logical client session */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        total: number;
+                        items: components["schemas"]["schemas-Session"][];
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    readClientSessionTimeline: {
+        parameters: {
+            query: {
+                sessionKey: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Events ordered by occurrence time; session key is opaque and may contain slashes */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Event"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    readMyCnbAccount: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Account"];
+            default: components["responses"]["Error"];
+        };
+    };
+    replaceMyCnbToken: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Token"];
+        responses: {
+            200: components["responses"]["Account"];
+            default: components["responses"]["Error"];
+        };
+    };
+    refreshMyCnbAccount: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Account"];
+            default: components["responses"]["Error"];
+        };
+    };
+    replaceUserCnbToken: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Token"];
+        responses: {
+            200: components["responses"]["Account"];
+            default: components["responses"]["Error"];
+        };
+    };
+    refreshUserCnbAccount: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Account"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listUpstreamCnbMembers: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Verified organization subtree member directory; no credentials */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Member"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listUpstreamCnbRepositories: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Visible non-secret repositories */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Repository"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    importCnbUsers: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    externalUserIds: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Selected visible identities become pending unbound accounts; duplicates and absent identities skipped */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        added: number;
+                        skipped: number;
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    syncCnbProjects: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    repositoryIds: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Import selection and refresh visible existing projects; invisible projects and local settings preserved */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        added: number;
+                        updated: number;
+                        /** @constant */
+                        removed: 0;
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listCnbAccessKeys: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Key metadata only; plaintext cannot be retrieved */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AccessKey"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    createCnbAccessKey: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    name?: string | null;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["NewKey"];
+            default: components["responses"]["Error"];
+        };
+    };
+    revokeCnbAccessKey: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Key revoked immediately */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    rotateCnbAccessKey: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["NewKey"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readViewer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listRoles: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Administrator-only role definitions */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        code: "USER" | "ADMIN";
+                        name: string;
+                    }[];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listUsers: {
+        parameters: {
+            query?: {
+                first?: components["parameters"]["First"];
+                offset?: components["parameters"]["Offset"];
+                search?: string;
+                role?: "USER" | "ADMIN";
+                status?: "PENDING" | "ACTIVE" | "DISABLED";
+                cnbState?: "CONNECTED" | "AWAITING_BINDING" | "RECONNECT_REQUIRED";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Matching users with aggregate activity and access counts */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["AdminUser"][];
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    createUser: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    cnbToken: string;
+                    /** @description Must contain USER; omitted defaults to USER */
+                    roles?: ("USER" | "ADMIN")[];
+                    expectedExternalUserId?: string | null;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Administrator view of an account */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminUser"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    setUserRoles: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    roles: ("USER" | "ADMIN")[];
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    setUserStatus: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    /** @enum {string} */
+                    status: "PENDING" | "ACTIVE" | "DISABLED";
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    issueActivation: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description One-time activation URL; expires after 24 hours */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uri */
+                        url: string;
+                        /** Format: date-time */
+                        expiresAt: string;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listModels: {
+        parameters: {
+            query?: {
+                first?: components["parameters"]["First"];
+                offset?: components["parameters"]["Offset"];
+                connectionId?: string;
+                enabled?: boolean;
+                search?: string;
+                availableOnly?: boolean;
+                missingOnly?: boolean;
+                protocol?: components["schemas"]["Protocol"];
+                discoveryStatus?: components["schemas"]["DiscoveryStatus"];
+                ids?: string[];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Filtered model page */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["Model"][];
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    createModel: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ModelWrite"] & Record<string, never>;
+            };
+        };
+        responses: {
+            201: components["responses"]["Model"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readModel: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Model"];
+            default: components["responses"]["Error"];
+        };
+    };
+    deleteModel: {
+        parameters: {
+            query: {
+                expectedRevision: components["parameters"]["Revision"];
+            };
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Model removed and connection revision advanced; referenced models are rejected */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    updateModel: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ModelWrite"];
+            };
+        };
+        responses: {
+            200: components["responses"]["Model"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listModelConnections: {
+        parameters: {
+            query?: {
+                first?: components["parameters"]["First"];
+                offset?: components["parameters"]["Offset"];
+                enabled?: boolean;
+                keyConfigured?: boolean;
+                hasProvider?: boolean;
+                discoveryStatus?: components["schemas"]["DiscoveryStatus"];
+                excludeDiscoveryError?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Filtered connections without plaintext credentials */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["Connection"][];
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    createModelConnection: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Connection"];
+        responses: {
+            201: components["responses"]["Connection"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readModelConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Connection"];
+            default: components["responses"]["Error"];
+        };
+    };
+    deleteModelConnection: {
+        parameters: {
+            query: {
+                expectedRevision: components["parameters"]["Revision"];
+            };
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Custom connection, models and personal credential overrides removed atomically; preset and referenced connections rejected */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    updateModelConnection: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Connection"];
+        responses: {
+            200: components["responses"]["Connection"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listModelProviderPresets: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Built-in provider definitions aligned with runtime adapters */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: string;
+                        displayName: string;
+                        protocol: components["schemas"]["Protocol"];
+                        /** Format: uri */
+                        baseUrl: string;
+                        modelCount: number;
+                    }[];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    queryModelReferences: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    modelIds: string[];
+                } | {
+                    /** Format: uuid */
+                    connectionId: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Global and project references preventing deletion */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Reference"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    readUpstreamModelCatalog: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Catalog"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readBuiltinModelCatalog: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Catalog"];
+            default: components["responses"]["Error"];
+        };
+    };
+    syncModelCatalog: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Selection"];
+        responses: {
+            200: components["responses"]["Connection"];
+            default: components["responses"]["Error"];
+        };
+    };
+    importBuiltinModels: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Selection"];
+        responses: {
+            200: components["responses"]["Connection"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readGlobalConfiguration: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Global"];
+            default: components["responses"]["Error"];
+        };
+    };
+    saveGlobalConfiguration: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    preferences?: components["schemas"]["Preferences"];
+                    /** Format: uri */
+                    redmineBaseUrl?: string | null;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Global"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readMyConfiguration: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["responses-User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    saveMyConfiguration: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["User"];
+        responses: {
+            200: components["responses"]["responses-User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readUserConfiguration: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["responses-User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    saveUserConfiguration: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["User"];
+        responses: {
+            200: components["responses"]["responses-User"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readUserCredentialReferences: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Self or administrator; connection references only, never plaintext keys */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        connectionId: string;
+                        revision: number;
+                    }[];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listAvailableModels: {
+        parameters: {
+            query?: {
+                /** @description Omitted selects self; selecting another user requires administrator */
+                userId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Models passing connection, model, existence and credential gates */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Model"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    readEffectiveModelDefaults: {
+        parameters: {
+            query?: {
+                userId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Independently resolved global defaults; unavailable selections are null */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        web: components["schemas"]["Selection"];
+                        plan: components["schemas"]["Selection"];
+                        execute: components["schemas"]["Selection"];
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listProjects: {
+        parameters: {
+            query?: {
+                first?: number;
+                offset?: number;
+                /** @description Select own accessible projects; false requires administrator */
+                mine?: boolean;
+                search?: string;
+                /** @description Organization subtree; empty selects ungrouped projects */
+                organization?: string;
+                kind?: "LOCAL" | "CNB";
+                enabled?: boolean;
+                upstreamStatuses?: ("ACTIVE" | "ARCHIVED" | "FORKING" | "UNAVAILABLE")[];
+                accessibleBy?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Matching projects and total count independent of page offset */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["Project"][];
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    createProject: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    name: string;
+                    slug: string;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["Project"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Project"];
+            default: components["responses"]["Error"];
+        };
+    };
+    deleteProject: {
+        parameters: {
+            query: {
+                expectedRevision: number;
+            };
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Project and its configuration, access exceptions, skill history and attachments removed atomically */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    updateProject: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Project row revision, not headlessModelsRevision */
+                    expectedRevision: number;
+                    name?: string;
+                    enabled?: boolean;
+                    /** @description Omitted preserves; null clears without contacting Redmine; value verified using operator's credentials */
+                    redmineProjectId?: number | null;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Project"];
+            default: components["responses"]["Error"];
+        };
+    };
+    updateProjectHeadlessModels: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description headlessModelsRevision from project view */
+                    expectedRevision: number;
+                    /** Format: uuid */
+                    planModelId?: string | null;
+                    /** Format: uuid */
+                    executeModelId?: string | null;
+                    planReasoningLevel?: components["schemas"]["ReasoningInput"];
+                    executeReasoningLevel?: components["schemas"]["ReasoningInput"];
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Project"];
+            default: components["responses"]["Error"];
+        };
+    };
+    setProjectAccess: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+                userId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedRevision: number;
+                    /** @description False revokes this user's default access; true restores it */
+                    present: boolean;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Project"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listProjectOrganizations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Derived organization tree with subtree project counts */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        path: string;
+                        parentPath: string | null;
+                        name: string;
+                        projectCount: number;
+                    }[];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    listSkills: {
+        parameters: {
+            query?: {
+                first?: number;
+                offset?: number;
+                scope?: "all" | "global" | "project";
+                /** @description Required when scope is project */
+                projectId?: string;
+                search?: string;
+                archived?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Matching head versions and total count */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["schemas-Skill"][];
+                        total: number;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    createSkill: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** Format: uuid */
+                    projectId?: string | null;
+                    content: string;
+                    files?: components["schemas"]["FileInput"][];
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["Skill"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readSkill: {
+        parameters: {
+            query?: {
+                /** @description Omitted selects head */
+                version?: components["parameters"]["Version"];
+            };
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Skill"];
+            default: components["responses"]["Error"];
+        };
+    };
+    saveSkillContent: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedVersion: number;
+                    content: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Skill"];
+            default: components["responses"]["Error"];
+        };
+    };
+    setSkillArchived: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedVersion: number;
+                    archived: boolean;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Skill"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listSkillVersions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Immutable versions newest first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SkillVersion"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    readSkillFiles: {
+        parameters: {
+            query?: {
+                /** @description Omitted selects head */
+                version?: components["parameters"]["Version"];
+            };
+            header?: never;
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description File bytes of the selected immutable version; audited sensitive read */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileContent"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    writeSkillFiles: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedVersion: number;
+                    files: components["schemas"]["FileInput"][];
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Skill"];
+            default: components["responses"]["Error"];
+        };
+    };
+    removeSkillFiles: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path: {
+                id: components["parameters"]["Id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedVersion: number;
+                    paths: string[];
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Skill"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readSelfPortrait: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Portrait"];
+            default: components["responses"]["Error"];
+        };
+    };
+    saveSelfPortrait: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    expectedVersion: number;
+                    content: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Portrait"];
+            default: components["responses"]["Error"];
+        };
+    };
+    listSelfPortraitVersions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Latest 50 immutable snapshots, newest first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Version"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    runtimeBootstrap: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Independent authoritative domain results for this reader */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Bootstrap"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    runtimeProjects: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Omitted or null selects all visible projects; empty array selects none */
+                    slugs?: string[] | null;
+                };
+            };
+        };
+        responses: {
+            /** @description Current visible enabled projects matching the selection */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["schemas-Project"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    runtimeCredentials: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Omitted selects all available connections; empty array selects none */
+                    connectionIds?: string[] | null;
+                };
+            };
+        };
+        responses: {
+            /** @description Credentials for available connections, personal override first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Credential"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    runtimeSkillFiles: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current version files; inaccessible or archived skill returns an empty array */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileContent"][];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    runtimeProjectProfile: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Visible project and optional Redmine profile read using this user's key */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ProjectProfile"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    runtimeReportEvent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EventInput"];
+            };
+        };
+        responses: {
+            /** @description Accepted event; actor identity comes exclusively from authentication */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["schemas-Event"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    health: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Database is reachable and startup migration completed */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        status: "ok";
+                    };
+                };
+            };
+        };
+    };
+    login: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PasswordLogin"];
+            };
+        };
+        responses: {
+            /** @description Signed in; console_session cookie is HttpOnly and SameSite=Lax */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Session"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    issueUserToken: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PasswordLogin"];
+            };
+        };
+        responses: {
+            /** @description Runtime token; no browser session is created */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        user: components["schemas"]["User"];
+                        token: string;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    readSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current user and CSRF token */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Session"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    logout: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["Ok"];
+            default: components["responses"]["Error"];
+        };
+    };
+    changePassword: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+                "X-CSRF-Token": components["parameters"]["Csrf"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    currentPassword: string;
+                    newPassword: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["Ok"];
+            default: components["responses"]["Error"];
+        };
+    };
+    readSetupState: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Whether the first administrator must be created */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        required: boolean;
+                        organization: string;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    initializeHub: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Enrollment"];
+        responses: {
+            200: components["responses"]["Session"];
+            default: components["responses"]["Error"];
+        };
+    };
+    registerMember: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Enrollment"];
+        responses: {
+            200: components["responses"]["Session"];
+            default: components["responses"]["Error"];
+        };
+    };
+    exchangeCnbToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    token: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Short-lived user token bound to the verified CNB identity; no browser session */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        user: components["schemas"]["User"];
+                        token: string;
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+    activateAccount: {
+        parameters: {
+            query?: never;
+            header: {
+                Origin: components["parameters"]["Origin"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    username: string;
+                    code: string;
+                    password: string;
+                    cnbToken?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Activated account; all existing sessions are revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        user: components["schemas"]["User"];
+                    };
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
+}