@pipeline-builder/api-core 0.0.1

package/lib/openapi/routes/image-registry-routes.js

@@ -0,0 +1,98 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Image Registry'];
+const auth = [{ bearerAuth: [] }];
+/**
+ * OpenAPI definitions for the image-registry service (api/image-registry): the
+ * Docker-registry token endpoint (`/token`), the org-scoped image API
+ * (`/api/images`), and the admin API (`/api/admin`). Image read/write is gated by
+ * the `registry:read` / `registry:write` permissions.
+ */
+export function registerImageRegistryRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/token',
+        summary: 'Mint a Docker registry token',
+        description: 'OAuth2-style token endpoint for `docker`/`crane`/`buildctl` clients. Verifies Basic-auth creds (a platform JWT or user login) and issues a scoped bearer token for pull/push.',
+        tags,
+        responses: { 200: { description: 'Registry access token' }, 401: { description: 'Invalid credentials' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images',
+        summary: 'List images',
+        description: "List the organization's container images in the registry.",
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Image list' }, 403: { description: 'registry:read required' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images/{name}/tags',
+        summary: 'List image tags',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Tag list' }, 404: { description: 'Image not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images/{name}/manifests/{reference}',
+        summary: 'Get an image manifest',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'OCI manifest / index' }, 404: { description: 'Manifest not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images/{name}/blobs/{digest}',
+        summary: 'Get an image blob',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Blob content' }, 404: { description: 'Blob not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/api/images/copy',
+        summary: 'Copy an image',
+        description: 'Server-side copy of an image between repositories. Requires both registry:read and registry:write.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Image copied' }, 403: { description: 'registry:read + registry:write required' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/api/images/{name}',
+        summary: 'Delete an image repository',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Repository deleted' }, 403: { description: 'registry:write required' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/api/images/{name}/manifests/{reference}',
+        summary: 'Delete an image manifest/tag',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Manifest deleted' }, 403: { description: 'registry:write required' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/admin/storage/{prefix}',
+        summary: 'Registry storage rollup',
+        description: 'Storage usage rollup under a prefix (registry:read).',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Storage usage' }, 403: { description: 'registry:read required' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/api/admin/gc',
+        summary: 'Run registry garbage collection',
+        description: 'Trigger blob/manifest garbage collection (registry:write).',
+        tags,
+        security: auth,
+        responses: { 202: { description: 'GC started' }, 403: { description: 'registry:write required' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-registry-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/image-registry-routes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Image Registry'];\nconst auth = [{ bearerAuth: [] }];\n\n/**\n * OpenAPI definitions for the image-registry service (api/image-registry): the\n * Docker-registry token endpoint (`/token`), the org-scoped image API\n * (`/api/images`), and the admin API (`/api/admin`). Image read/write is gated by\n * the `registry:read` / `registry:write` permissions.\n */\nexport function registerImageRegistryRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/token',\n    summary: 'Mint a Docker registry token',\n    description: 'OAuth2-style token endpoint for `docker`/`crane`/`buildctl` clients. Verifies Basic-auth creds (a platform JWT or user login) and issues a scoped bearer token for pull/push.',\n    tags,\n    responses: { 200: { description: 'Registry access token' }, 401: { description: 'Invalid credentials' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images',\n    summary: 'List images',\n    description: \"List the organization's container images in the registry.\",\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Image list' }, 403: { description: 'registry:read required' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images/{name}/tags',\n    summary: 'List image tags',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Tag list' }, 404: { description: 'Image not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images/{name}/manifests/{reference}',\n    summary: 'Get an image manifest',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'OCI manifest / index' }, 404: { description: 'Manifest not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images/{name}/blobs/{digest}',\n    summary: 'Get an image blob',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Blob content' }, 404: { description: 'Blob not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/api/images/copy',\n    summary: 'Copy an image',\n    description: 'Server-side copy of an image between repositories. Requires both registry:read and registry:write.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Image copied' }, 403: { description: 'registry:read + registry:write required' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/api/images/{name}',\n    summary: 'Delete an image repository',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Repository deleted' }, 403: { description: 'registry:write required' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/api/images/{name}/manifests/{reference}',\n    summary: 'Delete an image manifest/tag',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Manifest deleted' }, 403: { description: 'registry:write required' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/admin/storage/{prefix}',\n    summary: 'Registry storage rollup',\n    description: 'Storage usage rollup under a prefix (registry:read).',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Storage usage' }, 403: { description: 'registry:read required' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/api/admin/gc',\n    summary: 'Run registry garbage collection',\n    description: 'Trigger blob/manifest garbage collection (registry:write).',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'GC started' }, 403: { description: 'registry:write required' } },\n  });\n}\n"]}

package/lib/openapi/routes/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register all OpenAPI route definitions with the shared registry.
+ * Call this once during spec generation initialization.
+ */
+export declare function registerAllRoutes(): void;

package/lib/openapi/routes/index.js

@@ -0,0 +1,28 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registerAskRoutes } from './ask-routes.js';
+import { registerBillingRoutes } from './billing-routes.js';
+import { registerImageRegistryRoutes } from './image-registry-routes.js';
+import { registerMessageRoutes } from './message-routes.js';
+import { registerPipelineRoutes } from './pipeline-routes.js';
+import { registerPipelineTemplateRoutes } from './pipeline-template-routes.js';
+import { registerPluginRoutes } from './plugin-routes.js';
+import { registerQuotaRoutes } from './quota-routes.js';
+/**
+ * Register all OpenAPI route definitions with the shared registry.
+ * Call this once during spec generation initialization.
+ */
+export function registerAllRoutes() {
+    registerAskRoutes();
+    registerBillingRoutes();
+    registerImageRegistryRoutes();
+    registerMessageRoutes();
+    registerPipelineRoutes();
+    registerPipelineTemplateRoutes();
+    registerPluginRoutes();
+    registerQuotaRoutes();
+    // NOTE: compliance + reporting (large multi-router surfaces) and platform/auth
+    // are not yet registered — follow-on, and intentionally omitted rather than
+    // shipping inaccurate paths.
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/message-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerMessageRoutes(): void;

package/lib/openapi/routes/message-routes.js

@@ -0,0 +1,105 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Messages'];
+const auth = [{ bearerAuth: [] }];
+export function registerMessageRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/messages',
+        summary: 'List inbox messages',
+        description: 'List root messages (inbox) with optional filtering by type and pagination.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Paginated list of messages' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/messages/announcements',
+        summary: 'List announcements',
+        description: 'List announcement messages only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of announcements' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/messages/conversations',
+        summary: 'List conversations',
+        description: 'List conversation messages only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of conversations' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/messages/unread/count',
+        summary: 'Get unread count',
+        description: 'Get the number of unread messages for the current organization.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Unread message count' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/messages/{id}',
+        summary: 'Get message by ID',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Message details' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/messages/{id}/thread',
+        summary: 'Get message thread',
+        description: 'Get all messages in a thread including the root message and replies.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Thread messages sorted by date' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/messages',
+        summary: 'Create a message',
+        description: 'Create a new announcement or conversation message.',
+        tags,
+        security: auth,
+        responses: { 201: { description: 'Message created' }, 400: { description: 'Validation error' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/messages/{id}/reply',
+        summary: 'Reply to a message',
+        description: 'Create a reply in an existing message thread.',
+        tags,
+        security: auth,
+        responses: { 201: { description: 'Reply created' }, 404: { description: 'Parent message not found' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/messages/{id}/read',
+        summary: 'Mark message as read',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Message marked as read' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/messages/{id}/thread/read',
+        summary: 'Mark thread as read',
+        description: 'Mark all messages in a thread as read.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Thread marked as read' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/messages/{id}',
+        summary: 'Delete a message',
+        description: 'Soft-delete a message.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Message deleted' }, 404: { description: 'Not found' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/message-routes.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC;AAC1B,MAAM,IAAI,GAAG,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;AAElC,MAAM,UAAU,qBAAqB;IACnC,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,qBAAqB;QAC9B,WAAW,EAAE,4EAA4E;QACzF,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,4BAA4B,EAAE,EAAE;KAClE,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,yBAAyB;QAC/B,OAAO,EAAE,oBAAoB;QAC7B,WAAW,EAAE,kCAAkC;QAC/C,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,uBAAuB,EAAE,EAAE;KAC7D,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,yBAAyB;QAC/B,OAAO,EAAE,oBAAoB;QAC7B,WAAW,EAAE,kCAAkC;QAC/C,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,uBAAuB,EAAE,EAAE;KAC7D,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,wBAAwB;QAC9B,OAAO,EAAE,kBAAkB;QAC3B,WAAW,EAAE,iEAAiE;QAC9E,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,sBAAsB,EAAE,EAAE;KAC5D,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,mBAAmB;QAC5B,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,iBAAiB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KAC1F,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,uBAAuB;QAC7B,OAAO,EAAE,oBAAoB;QAC7B,WAAW,EAAE,sEAAsE;QACnF,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,gCAAgC,EAAE,EAAE;KACtE,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,kBAAkB;QAC3B,WAAW,EAAE,oDAAoD;QACjE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,iBAAiB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE;KACjG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,oBAAoB;QAC7B,WAAW,EAAE,+CAA+C;QAC5D,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,eAAe,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,0BAA0B,EAAE,EAAE;KACvG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,qBAAqB;QAC3B,OAAO,EAAE,sBAAsB;QAC/B,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,wBAAwB,EAAE,EAAE;KAC9D,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,4BAA4B;QAClC,OAAO,EAAE,qBAAqB;QAC9B,WAAW,EAAE,wCAAwC;QACrD,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,uBAAuB,EAAE,EAAE;KAC7D,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,QAAQ;QAChB,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,kBAAkB;QAC3B,WAAW,EAAE,wBAAwB;QACrC,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,iBAAiB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KAC1F,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Messages'];\nconst auth = [{ bearerAuth: [] }];\n\nexport function registerMessageRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/messages',\n    summary: 'List inbox messages',\n    description: 'List root messages (inbox) with optional filtering by type and pagination.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of messages' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/messages/announcements',\n    summary: 'List announcements',\n    description: 'List announcement messages only.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of announcements' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/messages/conversations',\n    summary: 'List conversations',\n    description: 'List conversation messages only.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of conversations' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/messages/unread/count',\n    summary: 'Get unread count',\n    description: 'Get the number of unread messages for the current organization.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Unread message count' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/messages/{id}',\n    summary: 'Get message by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Message details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/messages/{id}/thread',\n    summary: 'Get message thread',\n    description: 'Get all messages in a thread including the root message and replies.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Thread messages sorted by date' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/messages',\n    summary: 'Create a message',\n    description: 'Create a new announcement or conversation message.',\n    tags,\n    security: auth,\n    responses: { 201: { description: 'Message created' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/messages/{id}/reply',\n    summary: 'Reply to a message',\n    description: 'Create a reply in an existing message thread.',\n    tags,\n    security: auth,\n    responses: { 201: { description: 'Reply created' }, 404: { description: 'Parent message not found' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/messages/{id}/read',\n    summary: 'Mark message as read',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Message marked as read' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/messages/{id}/thread/read',\n    summary: 'Mark thread as read',\n    description: 'Mark all messages in a thread as read.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Thread marked as read' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/messages/{id}',\n    summary: 'Delete a message',\n    description: 'Soft-delete a message.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Message deleted' }, 404: { description: 'Not found' } },\n  });\n}\n"]}

package/lib/openapi/routes/pipeline-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerPipelineRoutes(): void;

package/lib/openapi/routes/pipeline-routes.js

@@ -0,0 +1,105 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Pipelines'];
+const auth = [{ bearerAuth: [] }];
+export function registerPipelineRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines',
+        summary: 'List pipelines',
+        description: 'List pipelines with pagination, filtering, and sorting.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Paginated list of pipelines' }, 401: { description: 'Unauthorized' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines/find',
+        summary: 'Find a single pipeline',
+        description: 'Find a single pipeline matching the query filters.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline found' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines/{id}',
+        summary: 'Get pipeline by ID',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline details' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines/{id}/scorecard',
+        summary: 'Get a pipeline maturity scorecard',
+        description: 'Per-pipeline maturity scorecard blending compliance posture with DORA performance bands into a 0–100 score and letter grade. Requires the `advanced_reporting` feature.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Scorecard' }, 403: { description: 'Feature not enabled' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines/scorecard',
+        summary: 'Org-wide scorecard roll-up (software-health leaderboard)',
+        description: 'Grades every pipeline in the organization and returns a ranked leaderboard plus aggregate stats (pipeline count, average score, grade distribution). Bounded per request. Requires the `advanced_reporting` feature.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Org-wide scorecard roll-up' }, 403: { description: 'Feature not enabled' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/pipelines',
+        summary: 'Create a pipeline',
+        description: 'Create a new pipeline configuration. Checks pipeline quota.',
+        tags,
+        security: auth,
+        responses: { 201: { description: 'Pipeline created' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/pipelines/{id}',
+        summary: 'Update a pipeline',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline updated' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/pipelines/{id}',
+        summary: 'Delete a pipeline',
+        description: 'Soft-delete a pipeline by setting isActive to false.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline deleted' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines/providers',
+        summary: 'List AI providers',
+        description: 'List AI providers configured for pipeline generation.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of available AI providers with models' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/pipelines/generate',
+        summary: 'Generate pipeline via AI',
+        description: 'Generate a BuilderProps configuration from a natural language prompt. Returns the complete result when done.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Generated pipeline configuration' }, 400: { description: 'Validation error' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/pipelines/generate/stream',
+        summary: 'Stream pipeline generation via AI',
+        description: 'Generate a BuilderProps configuration from a natural language prompt. Streams partial results as SSE events.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'SSE event stream of partial pipeline objects' }, 400: { description: 'Validation error' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/pipeline-routes.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC;AAC3B,MAAM,IAAI,GAAG,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;AAElC,MAAM,UAAU,sBAAsB;IACpC,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,gBAAgB;QACzB,WAAW,EAAE,yDAAyD;QACtE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,6BAA6B,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,cAAc,EAAE,EAAE;KACzG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,wBAAwB;QACjC,WAAW,EAAE,oDAAoD;QACjE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,gBAAgB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KACzF,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,oBAAoB;QAC7B,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KAC3F,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,2BAA2B;QACjC,OAAO,EAAE,mCAAmC;QAC5C,WAAW,EAAE,yKAAyK;QACtL,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,qBAAqB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KACjI,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,0DAA0D;QACnE,WAAW,EAAE,sNAAsN;QACnO,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,4BAA4B,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,qBAAqB,EAAE,EAAE;KAC/G,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,mBAAmB;QAC5B,WAAW,EAAE,6DAA6D;QAC1E,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,gBAAgB,EAAE,EAAE;KAC1I,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,mBAAmB;QAC5B,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KAC3F,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,QAAQ;QAChB,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,mBAAmB;QAC5B,WAAW,EAAE,sDAAsD;QACnE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE;KAC3F,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,mBAAmB;QAC5B,WAAW,EAAE,uDAAuD;QACpE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,4CAA4C,EAAE,EAAE;KAClF,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,qBAAqB;QAC3B,OAAO,EAAE,0BAA0B;QACnC,WAAW,EAAE,8GAA8G;QAC3H,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kCAAkC,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE;KAClH,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,4BAA4B;QAClC,OAAO,EAAE,mCAAmC;QAC5C,WAAW,EAAE,8GAA8G;QAC3H,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,8CAA8C,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE;KAC9H,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Pipelines'];\nconst auth = [{ bearerAuth: [] }];\n\nexport function registerPipelineRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines',\n    summary: 'List pipelines',\n    description: 'List pipelines with pagination, filtering, and sorting.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of pipelines' }, 401: { description: 'Unauthorized' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/find',\n    summary: 'Find a single pipeline',\n    description: 'Find a single pipeline matching the query filters.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline found' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/{id}',\n    summary: 'Get pipeline by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/{id}/scorecard',\n    summary: 'Get a pipeline maturity scorecard',\n    description: 'Per-pipeline maturity scorecard blending compliance posture with DORA performance bands into a 0–100 score and letter grade. Requires the `advanced_reporting` feature.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Scorecard' }, 403: { description: 'Feature not enabled' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/scorecard',\n    summary: 'Org-wide scorecard roll-up (software-health leaderboard)',\n    description: 'Grades every pipeline in the organization and returns a ranked leaderboard plus aggregate stats (pipeline count, average score, grade distribution). Bounded per request. Requires the `advanced_reporting` feature.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Org-wide scorecard roll-up' }, 403: { description: 'Feature not enabled' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines',\n    summary: 'Create a pipeline',\n    description: 'Create a new pipeline configuration. Checks pipeline quota.',\n    tags,\n    security: auth,\n    responses: { 201: { description: 'Pipeline created' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/pipelines/{id}',\n    summary: 'Update a pipeline',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline updated' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/pipelines/{id}',\n    summary: 'Delete a pipeline',\n    description: 'Soft-delete a pipeline by setting isActive to false.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline deleted' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/providers',\n    summary: 'List AI providers',\n    description: 'List AI providers configured for pipeline generation.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of available AI providers with models' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines/generate',\n    summary: 'Generate pipeline via AI',\n    description: 'Generate a BuilderProps configuration from a natural language prompt. Returns the complete result when done.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Generated pipeline configuration' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines/generate/stream',\n    summary: 'Stream pipeline generation via AI',\n    description: 'Generate a BuilderProps configuration from a natural language prompt. Streams partial results as SSE events.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'SSE event stream of partial pipeline objects' }, 400: { description: 'Validation error' } },\n  });\n}\n"]}

package/lib/openapi/routes/pipeline-template-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerPipelineTemplateRoutes(): void;

package/lib/openapi/routes/pipeline-template-routes.js

@@ -0,0 +1,61 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Pipeline Templates'];
+const auth = [{ bearerAuth: [] }];
+export function registerPipelineTemplateRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/pipeline-templates',
+        summary: 'List pipeline templates',
+        description: 'List golden-path pipeline templates with pagination and filtering. Visibility is a three-rung ladder: `private` (author only), `org` (everyone in the owning org), `public` (the org, its teams, and — for the system org — every org). Optional `visibility` query param narrows within what the caller can already see.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Paginated list of templates' }, 401: { description: 'Unauthorized' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipeline-templates/{id}',
+        summary: 'Get a pipeline template by ID',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Template details' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/pipeline-templates/{id}/instantiate',
+        summary: 'Instantiate a template',
+        description: 'Render a template into a concrete pipeline `props` by supplying its declared inputs. The returned props are submitted through the normal pipeline-create endpoint (compliance + quota apply there).',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Resolved pipeline props' }, 400: { description: 'Invalid inputs' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/pipeline-templates',
+        summary: 'Create a pipeline template',
+        description: 'Author a golden-path template. Requires `templates:write`; `visibility: public` additionally requires `templates:publish` (a caller without it is clamped to `org`). Defaults to `private` — a personal draft only the author can see.',
+        tags,
+        security: auth,
+        responses: { 201: { description: 'Template created' }, 400: { description: 'Validation error' }, 403: { description: 'Forbidden' }, 409: { description: 'A template with that name already exists in the organization' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/pipeline-templates/{id}',
+        summary: 'Update a pipeline template',
+        description: 'Requires `templates:write`, plus `templates:publish` for a `public` template and authorship for a `private` one.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Template updated' }, 403: { description: 'Forbidden' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/pipeline-templates/{id}',
+        summary: 'Delete a pipeline template',
+        description: 'Same authority as update: `templates:write`, plus `templates:publish` for a `public` template and authorship for a `private` one.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Template deleted' }, 403: { description: 'Forbidden' }, 404: { description: 'Not found' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/plugin-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerPluginRoutes(): void;

package/lib/openapi/routes/plugin-routes.js

@@ -0,0 +1,96 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Plugins'];
+const auth = [{ bearerAuth: [] }];
+export function registerPluginRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/plugins',
+        summary: 'List plugins',
+        description: 'List plugins with pagination, filtering, and sorting.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Paginated list of plugins' }, 401: { description: 'Unauthorized' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/plugins/find',
+        summary: 'Find a single plugin',
+        description: 'Find a single plugin matching the query filters.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin found' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/plugins/{id}',
+        summary: 'Get plugin by ID',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin details' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins',
+        summary: 'Upload a plugin',
+        description: 'Upload a plugin ZIP file with spec. Builds Docker image and saves to database.',
+        tags,
+        security: auth,
+        responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/plugins/{id}',
+        summary: 'Update a plugin',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin updated' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/plugins/{id}',
+        summary: 'Delete a plugin',
+        description: 'Soft-delete a plugin by setting isActive to false.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin deleted' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/plugins/providers',
+        summary: 'List AI providers',
+        description: 'List AI providers configured for plugin generation.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of available AI providers with models' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins/generate',
+        summary: 'Generate plugin via AI',
+        description: 'Generate a plugin configuration and Dockerfile from a natural language prompt.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Generated plugin configuration and Dockerfile' }, 400: { description: 'Validation error' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins/generate/stream',
+        summary: 'Stream plugin generation via AI',
+        description: 'Generate plugin configuration from a natural language prompt. Streams partial results as SSE events.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'SSE event stream of partial plugin objects' }, 400: { description: 'Validation error' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins/deploy-generated',
+        summary: 'Deploy AI-generated plugin',
+        description: 'Build Docker image from AI-generated Dockerfile and save plugin to database. Requires admin.',
+        tags,
+        security: auth,
+        responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 403: { description: 'Admin required' }, 429: { description: 'Quota exceeded' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/plugin-routes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Plugins'];\nconst auth = [{ bearerAuth: [] }];\n\nexport function registerPluginRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins',\n    summary: 'List plugins',\n    description: 'List plugins with pagination, filtering, and sorting.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of plugins' }, 401: { description: 'Unauthorized' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/find',\n    summary: 'Find a single plugin',\n    description: 'Find a single plugin matching the query filters.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin found' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/{id}',\n    summary: 'Get plugin by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins',\n    summary: 'Upload a plugin',\n    description: 'Upload a plugin ZIP file with spec. Builds Docker image and saves to database.',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/plugins/{id}',\n    summary: 'Update a plugin',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin updated' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/plugins/{id}',\n    summary: 'Delete a plugin',\n    description: 'Soft-delete a plugin by setting isActive to false.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin deleted' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/providers',\n    summary: 'List AI providers',\n    description: 'List AI providers configured for plugin generation.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of available AI providers with models' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/generate',\n    summary: 'Generate plugin via AI',\n    description: 'Generate a plugin configuration and Dockerfile from a natural language prompt.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Generated plugin configuration and Dockerfile' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/generate/stream',\n    summary: 'Stream plugin generation via AI',\n    description: 'Generate plugin configuration from a natural language prompt. Streams partial results as SSE events.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'SSE event stream of partial plugin objects' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/deploy-generated',\n    summary: 'Deploy AI-generated plugin',\n    description: 'Build Docker image from AI-generated Dockerfile and save plugin to database. Requires admin.',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 403: { description: 'Admin required' }, 429: { description: 'Quota exceeded' } },\n  });\n}\n"]}

package/lib/openapi/routes/quota-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerQuotaRoutes(): void;