tapimo 0.11.0 → 0.13.0

package/dist/apps/management/routes/projects.d.ts

@@ -5,7 +5,7 @@ import * as Response from '../../../internal/Response.js';
 export declare namespace schema {
     /** One project: an app or integration within an organization. */
     const Project: z.ZodMiniObject<{
-        createdAt: z.ZodMiniString<string>;
+        createdAt: z.ZodMiniISODateTime;
         environments: z.ZodMiniArray<z.ZodMiniEnum<{
             production: "production";
             sandbox: "sandbox";
@@ -13,7 +13,7 @@ export declare namespace schema {
         id: z.ZodMiniString<string>;
         name: z.ZodMiniString<string>;
         orgId: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniString<string>;
+        updatedAt: z.ZodMiniISODateTime;
     }, z.core.$strip>;
     /** Path parameters addressing an organization's project collection. */
     const Params: z.ZodMiniObject<{
@@ -24,8 +24,12 @@ export declare namespace schema {
         orgId: z.ZodMiniString<string>;
         projectId: z.ZodMiniString<string>;
     }, z.core.$strip>;
-    /** Request body creating or renaming a project. */
-    const ProjectBody: z.ZodMiniObject<{
+    /** Request body creating a project. */
+    const CreateProjectRequest: z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+    /** Request body updating a project. */
+    const UpdateProjectRequest: z.ZodMiniObject<{
         name: z.ZodMiniString<string>;
     }, z.core.$strip>;
     /** Schemas for the deleteProject operation. */
@@ -40,7 +44,7 @@ export declare namespace schema {
         /** Non-paginated list of an organization's projects. */
         const Response: z.ZodMiniObject<{
             data: z.ZodMiniArray<z.ZodMiniObject<{
-                createdAt: z.ZodMiniString<string>;
+                createdAt: z.ZodMiniISODateTime;
                 environments: z.ZodMiniArray<z.ZodMiniEnum<{
                     production: "production";
                     sandbox: "sandbox";
@@ -48,7 +52,7 @@ export declare namespace schema {
                 id: z.ZodMiniString<string>;
                 name: z.ZodMiniString<string>;
                 orgId: z.ZodMiniString<string>;
-                updatedAt: z.ZodMiniString<string>;
+                updatedAt: z.ZodMiniISODateTime;
             }, z.core.$strip>>;
         }, z.core.$strip>;
     }
@@ -61,14 +65,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         $get: {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     orgId: string;
@@ -77,14 +81,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -93,14 +97,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -109,14 +113,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -125,14 +129,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
@@ -141,14 +145,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "organization_not_found";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -157,14 +161,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "organization_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 404;
             input: {
                 param: {
                     orgId: string;
@@ -193,6 +197,26 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
 } & {
     "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects": {
         $post: {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                json: {
+                    name: string;
+                };
+            };
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -275,14 +299,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -295,14 +319,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "organization_not_found";
+                    code: "body_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -315,14 +339,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -335,14 +359,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "body_invalid";
+                    code: "organization_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 404;
             input: {
                 param: {
                     orgId: string;
@@ -447,14 +471,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "organization_not_found" | "project_not_found";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -464,14 +488,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "organization_not_found" | "project_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 404;
             input: {
                 param: {
                     orgId: string;
@@ -500,6 +524,27 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
 } & {
     "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects/:projectId{prj_[A-Za-z0-9_-]+}": {
         $patch: {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    orgId: string;
+                    projectId: string;
+                };
+            } & {
+                json: {
+                    name: string;
+                };
+            };
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -586,14 +631,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -607,14 +652,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "organization_not_found" | "project_not_found";
+                    code: "body_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -628,14 +673,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -649,14 +694,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "body_invalid";
+                    code: "organization_not_found" | "project_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 404;
             input: {
                 param: {
                     orgId: string;
@@ -693,6 +738,23 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
 } & {
     "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects/:projectId{prj_[A-Za-z0-9_-]+}": {
         $delete: {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    orgId: string;
+                    projectId: string;
+                };
+            };
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -763,14 +825,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -780,14 +842,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "organization_not_found" | "project_not_found";
+                    code: "forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -797,14 +859,14 @@ export declare function projects(): import("hono/hono-base").HonoBase<App.Enviro
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "organization_not_found" | "project_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 404;
             input: {
                 param: {
                     orgId: string;

package/dist/apps/management/routes/projects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../../../src/apps/management/routes/projects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAMzD,kDAAkD;AAClD,yBAAiB,MAAM,CAAC;IAUtB,iEAAiE;IAC1D,MAAM,OAAO;;;;;;;;;;qBAmCnB,CAAA;IAED,uEAAuE;IAChE,MAAM,MAAM;;qBASoD,CAAA;IAEvE,8CAA8C;IACvC,MAAM,aAAa;;;qBAe8B,CAAA;IAExD,mDAAmD;IAC5C,MAAM,WAAW;;qBAE0C,CAAA;IAElE,+CAA+C;IAC/C,UAAiB,aAAa,CAAC;QAC7B,iDAAiD;QAC1C,MAAM,QAAQ;;yBAS6C,CAAA;KACnE;IAED,8CAA8C;IAC9C,UAAiB,YAAY,CAAC;QAC5B,wDAAwD;QACjD,MAAM,QAAQ;;;;;;;;;;;;yBAKpB,CAAA;KACF;CACF;AAED;;GAEG;AACH,wBAAgB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFAyNvB"}
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../../../src/apps/management/routes/projects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAMzD,kDAAkD;AAClD,yBAAiB,MAAM,CAAC;IAUtB,iEAAiE;IAC1D,MAAM,OAAO;;;;;;;;;;qBAsCnB,CAAA;IAED,uEAAuE;IAChE,MAAM,MAAM;;qBASoD,CAAA;IAEvE,8CAA8C;IACvC,MAAM,aAAa;;;qBAe8B,CAAA;IAExD,uCAAuC;IAChC,MAAM,oBAAoB;;qBAGhC,CAAA;IAED,uCAAuC;IAChC,MAAM,oBAAoB;;qBAGhC,CAAA;IAED,+CAA+C;IAC/C,UAAiB,aAAa,CAAC;QAC7B,iDAAiD;QAC1C,MAAM,QAAQ;;yBAYpB,CAAA;KACF;IAED,8CAA8C;IAC9C,UAAiB,YAAY,CAAC;QAC5B,wDAAwD;QACjD,MAAM,QAAQ;;;;;;;;;;;;yBAQpB,CAAA;KACF;CACF;AAED;;GAEG;AACH,wBAAgB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFAyQvB"}

package/dist/apps/management/routes/projects.js

@@ -16,9 +16,9 @@ export var schema;
         .string()
         .check(z.minLength(1), z.maxLength(100), z.describe('Human-readable name.'), z.meta({ examples: ['Checkout'] }));
     /** One project: an app or integration within an organization. */
-    schema.Project = Schema.describe(z.object({
-        createdAt: z
-            .string()
+    schema.Project = OpenApi.component(Schema.describe(z.object({
+        createdAt: z.iso
+            .datetime()
             .check(z.describe('When the project was created (ISO 8601).'), z.meta({ examples: ['2026-01-01T00:00:00.000Z'] })),
         environments: z.array(z.enum(environments)).check(z.describe('Environments available to this project: sandbox (testnet) and production (mainnet).'), // prettier-ignore
         z.meta({ examples: [[...environments]] })),
@@ -31,10 +31,10 @@ export var schema;
         orgId: z
             .string()
             .check(z.describe('Owning organization id (`org_…`).'), z.meta({ examples: ['org_1a2b3c4d5e6f7g8h9j0k1m2n'] })),
-        updatedAt: z
-            .string()
+        updatedAt: z.iso
+            .datetime()
             .check(z.describe('When the project was last updated (ISO 8601).'), z.meta({ examples: ['2026-01-01T00:00:00.000Z'] })),
-    }), 'A project: an app or integration within an organization.');
+    }), 'A project: an app or integration within an organization.'), 'Project');
     /** Path parameters addressing an organization's project collection. */
     schema.Params = z
         .object({
@@ -54,29 +54,29 @@ export var schema;
             .check(z.describe('The project id (`prj_…`).'), z.meta({ examples: ['prj_1a2b3c4d5e6f7g8h9j0k1m2n'] })),
     })
         .check(z.describe('Path parameters for one project.'));
-    /** Request body creating or renaming a project. */
-    schema.ProjectBody = z
-        .object({ name })
-        .check(z.describe('Fields for creating or renaming a project.'));
+    /** Request body creating a project. */
+    schema.CreateProjectRequest = OpenApi.component(z.object({ name }).check(z.describe('Fields for creating a project.')), 'CreateProjectRequest');
+    /** Request body updating a project. */
+    schema.UpdateProjectRequest = OpenApi.component(z.object({ name }).check(z.describe('Fields for updating a project.')), 'UpdateProjectRequest');
     /** Schemas for the deleteProject operation. */
     let deleteProject;
     (function (deleteProject) {
         /** Confirmation that the project was deleted. */
-        deleteProject.Response = z
+        deleteProject.Response = OpenApi.component(z
             .object({
             id: z
                 .string()
                 .check(z.describe('ID of the project that was deleted.'), z.meta({ examples: ['prj_1a2b3c4d5e6f7g8h9j0k1m2n'] })),
         })
-            .check(z.describe('Confirmation that the project was deleted.'));
+            .check(z.describe('Confirmation that the project was deleted.')), 'DeleteProjectResponse');
     })(deleteProject = schema.deleteProject || (schema.deleteProject = {}));
     /** Schemas for the listProjects operation. */
     let listProjects;
     (function (listProjects) {
         /** Non-paginated list of an organization's projects. */
-        listProjects.Response = Schema.describe(z.object({
+        listProjects.Response = OpenApi.component(Schema.describe(z.object({
             data: z.array(schema.Project).check(z.describe('The projects, newest first.')),
-        }), "A non-paginated list of an organization's projects.");
+        }), "A non-paginated list of an organization's projects."), 'ProjectList');
     })(listProjects = schema.listProjects || (schema.listProjects = {}));
 })(schema || (schema = {}));
 /**
@@ -90,7 +90,16 @@ export function projects() {
     }), OpenApi.describeRoute({
         operationId: 'listProjects',
         responses: OpenApi.responses({
-            errors: { 404: 'No accessible organization was found for this id.' },
+            errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'Malformed API key or invalid path parameters.',
+                },
+                404: {
+                    codes: ['organization_not_found'],
+                    description: 'No accessible organization was found for this id.',
+                },
+            },
             success: {
                 description: "The organization's projects, newest first.",
                 schema: schema.listProjects.Response,
@@ -122,13 +131,22 @@ export function projects() {
         .post('/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects', Auth.policy({ apiKey: { scopes: ['management:write'] }, session: true }), Auth.ensureOrg({ role: 'admin' }), OpenApi.validate('param', schema.Params, {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
-    }), OpenApi.validate('json', schema.ProjectBody, {
+    }), OpenApi.validate('json', schema.CreateProjectRequest, {
         code: 'body_invalid',
         message: 'Check the request body and try again.',
     }), OpenApi.describeRoute({
         operationId: 'createProject',
         responses: OpenApi.responses({
-            errors: { 404: 'No accessible organization was found for this id.' },
+            errors: {
+                400: {
+                    codes: ['body_invalid', 'param_invalid'],
+                    description: 'Malformed API key, invalid path parameters, or invalid request body.',
+                },
+                404: {
+                    codes: ['organization_not_found'],
+                    description: 'No accessible organization was found for this id.',
+                },
+            },
             success: { description: 'The created project.', schema: schema.Project },
         }),
         summary: 'Create project',
@@ -138,6 +156,8 @@ export function projects() {
             return Auth.accessError(c);
         if (Auth.narrowScope)
             return Auth.ensureOrgError(c);
+        if (Auth.narrowOrgRole)
+            return Auth.ensureOrgRoleError(c);
         if (OpenApi.narrowValidation)
             return OpenApi.validationError(c, {
                 code: 'param_invalid',
@@ -164,7 +184,16 @@ export function projects() {
     }), OpenApi.describeRoute({
         operationId: 'getProject',
         responses: OpenApi.responses({
-            errors: { 404: 'No accessible project was found for this id.' },
+            errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'Malformed API key or invalid path parameters.',
+                },
+                404: {
+                    codes: ['organization_not_found', 'project_not_found'],
+                    description: 'No accessible project was found for this id.',
+                },
+            },
             success: { description: 'One project.', schema: schema.Project },
         }),
         summary: 'Get project',
@@ -184,13 +213,22 @@ export function projects() {
         .patch('/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects/:projectId{prj_[A-Za-z0-9_-]+}', Auth.policy({ apiKey: { scopes: ['management:write'] }, session: true }), Auth.ensureOrg({ role: 'admin' }), Auth.ensureProject(), OpenApi.validate('param', schema.ProjectParams, {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
-    }), OpenApi.validate('json', schema.ProjectBody, {
+    }), OpenApi.validate('json', schema.UpdateProjectRequest, {
         code: 'body_invalid',
         message: 'Check the request body and try again.',
     }), OpenApi.describeRoute({
         operationId: 'updateProject',
         responses: OpenApi.responses({
-            errors: { 404: 'No accessible project was found for this id.' },
+            errors: {
+                400: {
+                    codes: ['body_invalid', 'param_invalid'],
+                    description: 'Malformed API key, invalid path parameters, or invalid request body.',
+                },
+                404: {
+                    codes: ['organization_not_found', 'project_not_found'],
+                    description: 'No accessible project was found for this id.',
+                },
+            },
             success: { description: 'The updated project.', schema: schema.Project },
         }),
         summary: 'Update project',
@@ -210,6 +248,8 @@ export function projects() {
             });
         if (Auth.narrowScope)
             return Auth.ensureProjectError(c);
+        if (Auth.narrowOrgRole)
+            return Auth.ensureOrgRoleError(c);
         const body = c.req.valid('json');
         const db = Db.get(c.get('db'));
         try {
@@ -228,7 +268,16 @@ export function projects() {
     }), OpenApi.describeRoute({
         operationId: 'deleteProject',
         responses: OpenApi.responses({
-            errors: { 404: 'No accessible project was found for this id.' },
+            errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'Malformed API key or invalid path parameters.',
+                },
+                404: {
+                    codes: ['organization_not_found', 'project_not_found'],
+                    description: 'No accessible project was found for this id.',
+                },
+            },
             success: {
                 description: 'Confirmation that the project was deleted.',
                 schema: schema.deleteProject.Response,
@@ -241,6 +290,8 @@ export function projects() {
             return Auth.accessError(c);
         if (Auth.narrowScope)
             return Auth.ensureProjectError(c);
+        if (Auth.narrowOrgRole)
+            return Auth.ensureOrgRoleError(c);
         if (OpenApi.narrowValidation)
             return OpenApi.validationError(c, {
                 code: 'param_invalid',