tapimo 0.11.0 → 0.13.0

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

@@ -11,9 +11,9 @@ export declare namespace schema {
     }>;
     /** One organization member: the membership plus the member's identity. */
     const Member: z.ZodMiniObject<{
-        address: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        createdAt: z.ZodMiniString<string>;
-        email: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        address: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+        createdAt: z.ZodMiniISODateTime;
+        email: z.ZodMiniOptional<z.ZodMiniEmail>;
         role: z.ZodMiniEnum<{
             admin: "admin";
             member: "member";
@@ -31,7 +31,7 @@ export declare namespace schema {
         userId: z.ZodMiniString<string>;
     }, z.core.$strip>;
     /** Request body changing a member's role. */
-    const MemberBody: z.ZodMiniObject<{
+    const UpdateMemberRequest: z.ZodMiniObject<{
         role: z.ZodMiniEnum<{
             admin: "admin";
             member: "member";
@@ -43,9 +43,9 @@ export declare namespace schema {
         /** Non-paginated list of an organization's members. */
         const Response: z.ZodMiniObject<{
             data: z.ZodMiniArray<z.ZodMiniObject<{
-                address: z.ZodMiniOptional<z.ZodMiniString<string>>;
-                createdAt: z.ZodMiniString<string>;
-                email: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                address: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                createdAt: z.ZodMiniISODateTime;
+                email: z.ZodMiniOptional<z.ZodMiniEmail>;
                 role: z.ZodMiniEnum<{
                     admin: "admin";
                     member: "member";
@@ -72,16 +72,15 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
     "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/members": {
         $get: {
             output: {
-                data: {
-                    address?: string | undefined;
-                    createdAt: string;
-                    email?: string | undefined;
-                    role: "admin" | "member" | "owner";
-                    userId: string;
-                }[];
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -90,14 +89,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -106,14 +105,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -122,14 +121,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
@@ -138,14 +137,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 502;
             input: {
                 param: {
                     orgId: string;
@@ -170,14 +169,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -185,15 +184,16 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
             };
         } | {
             output: {
-                error: {
-                    code: "upstream_error";
-                    details?: readonly Response.error.Detail[] | undefined;
-                    message: string;
-                };
-                requestId: string;
+                data: {
+                    address?: `0x${string}` | undefined;
+                    createdAt: string;
+                    email?: string | undefined;
+                    role: "admin" | "member" | "owner";
+                    userId: string;
+                }[];
             };
             outputFormat: "json";
-            status: 502;
+            status: 200;
             input: {
                 param: {
                     orgId: string;
@@ -205,14 +205,15 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
     "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/members/:userId{usr_[A-Za-z0-9_-]+}": {
         $patch: {
             output: {
-                address?: string | undefined;
-                createdAt: string;
-                email?: string | undefined;
-                role: "admin" | "member" | "owner";
-                userId: string;
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -226,14 +227,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -247,14 +248,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -268,14 +269,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "body_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
@@ -289,14 +290,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 502;
             input: {
                 param: {
                     orgId: string;
@@ -310,14 +311,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "body_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -331,14 +332,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "organization_not_found";
+                    code: "forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -352,7 +353,7 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "member_not_found";
+                    code: "organization_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
@@ -373,14 +374,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "last_owner";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 409;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -394,14 +395,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "last_owner";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 409;
             input: {
                 param: {
                     orgId: string;
@@ -415,14 +416,34 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "member_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 404;
+            input: {
+                param: {
+                    orgId: string;
+                    userId: string;
+                };
+            } & {
+                json: {
+                    role: "admin" | "member" | "owner";
+                };
+            };
+        } | {
+            output: {
+                address?: `0x${string}` | undefined;
+                createdAt: string;
+                email?: string | undefined;
+                role: "admin" | "member" | "owner";
+                userId: string;
+            };
+            outputFormat: "json";
+            status: 200;
             input: {
                 param: {
                     orgId: string;
@@ -439,10 +460,15 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
     "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/members/:userId{usr_[A-Za-z0-9_-]+}": {
         $delete: {
             output: {
-                userId: string;
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -452,14 +478,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -469,14 +495,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -486,14 +512,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
@@ -503,14 +529,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 502;
             input: {
                 param: {
                     orgId: string;
@@ -554,14 +580,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "member_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;
@@ -588,14 +614,14 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "member_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 404;
             input: {
                 param: {
                     orgId: string;
@@ -604,15 +630,10 @@ export declare function members(): import("hono/hono-base").HonoBase<App.Environ
             };
         } | {
             output: {
-                error: {
-                    code: "upstream_error";
-                    details?: readonly Response.error.Detail[] | undefined;
-                    message: string;
-                };
-                requestId: string;
+                userId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 200;
             input: {
                 param: {
                     orgId: string;

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

@@ -1 +1 @@
-{"version":3,"file":"members.d.ts","sourceRoot":"","sources":["../../../../src/apps/management/routes/members.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAIzD,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB,yBAAyB;IAClB,MAAM,IAAI;;;;MAEwD,CAAA;IAEzE,0EAA0E;IACnE,MAAM,MAAM;;;;;;;;;;qBA6BlB,CAAA;IAED,sEAAsE;IAC/D,MAAM,MAAM;;qBASmD,CAAA;IAEtE,6CAA6C;IACtC,MAAM,YAAY;;;qBAe8B,CAAA;IAEvD,6CAA6C;IACtC,MAAM,UAAU;;;;;;qBAEqC,CAAA;IAE5D,6CAA6C;IAC7C,UAAiB,WAAW,CAAC;QAC3B,uDAAuD;QAChD,MAAM,QAAQ;;;;;;;;;;;;yBAKpB,CAAA;KACF;IAED,8CAA8C;IAC9C,UAAiB,YAAY,CAAC;QAC5B,gDAAgD;QACzC,MAAM,QAAQ;;yBAS4C,CAAA;KAClE;CACF;AAED;;;;GAIG;AACH,wBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAqKtB"}
+{"version":3,"file":"members.d.ts","sourceRoot":"","sources":["../../../../src/apps/management/routes/members.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAIzD,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB,yBAAyB;IAClB,MAAM,IAAI;;;;MAEwD,CAAA;IAEzE,0EAA0E;IACnE,MAAM,MAAM;;;;;;;;;;qBAgClB,CAAA;IAED,sEAAsE;IAC/D,MAAM,MAAM;;qBASmD,CAAA;IAEtE,6CAA6C;IACtC,MAAM,YAAY;;;qBAe8B,CAAA;IAEvD,6CAA6C;IACtC,MAAM,mBAAmB;;;;;;qBAG/B,CAAA;IAED,6CAA6C;IAC7C,UAAiB,WAAW,CAAC;QAC3B,uDAAuD;QAChD,MAAM,QAAQ;;;;;;;;;;;;yBAUpB,CAAA;KACF;IAED,8CAA8C;IAC9C,UAAiB,YAAY,CAAC;QAC5B,gDAAgD;QACzC,MAAM,QAAQ;;yBAYpB,CAAA;KACF;CACF;AAED;;;;GAIG;AACH,wBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAuLtB"}

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

@@ -15,21 +15,21 @@ export var schema;
         .enum(Memberships.roles)
         .check(z.describe('Membership role.'), z.meta({ examples: ['admin'] }));
     /** One organization member: the membership plus the member's identity. */
-    schema.Member = Schema.describe(z.object({
+    schema.Member = OpenApi.component(Schema.describe(z.object({
         address: z
-            .optional(z.string())
+            .optional(z.templateLiteral(['0x', z.string().check(z.regex(/^[0-9a-fA-F]{40}$/))]))
             .check(z.describe("The member's wallet address, when wallet sign-in established it."), z.meta({ examples: ['0x20f414b3cbcf1fd8e8f5e1c1c2e3d4a5b6c7d8e9'] })),
-        createdAt: z
-            .string()
+        createdAt: z.iso
+            .datetime()
             .check(z.describe('When the member joined (ISO 8601).'), z.meta({ examples: ['2026-01-01T00:00:00.000Z'] })),
         email: z
-            .optional(z.string())
+            .optional(z.email())
             .check(z.describe("The member's verified email, when known."), z.meta({ examples: ['dev@example.com'] })),
         role: schema.Role,
         userId: z
             .string()
             .check(z.describe('Member user id (`usr_…`).'), z.meta({ examples: ['usr_1a2b3c4d5e6f7g8h9j0k1m2n'] })),
-    }), "One organization member: the membership plus the member's identity.");
+    }), "One organization member: the membership plus the member's identity."), 'Member');
     /** Path parameters addressing an organization's member collection. */
     schema.Params = z
         .object({
@@ -50,28 +50,28 @@ export var schema;
     })
         .check(z.describe('Path parameters for one member.'));
     /** Request body changing a member's role. */
-    schema.MemberBody = z
-        .object({ role: schema.Role })
-        .check(z.describe("Fields for changing a member's role."));
+    schema.UpdateMemberRequest = OpenApi.component(z.object({ role: schema.Role }).check(z.describe("Fields for changing a member's role.")), 'UpdateMemberRequest');
     /** Schemas for the listMembers operation. */
     let listMembers;
     (function (listMembers) {
         /** Non-paginated list of an organization's members. */
-        listMembers.Response = Schema.describe(z.object({
-            data: z.array(schema.Member).check(z.describe('The members, oldest first.')),
-        }), "A non-paginated list of an organization's members.");
+        listMembers.Response = OpenApi.component(Schema.describe(z.object({
+            data: z
+                .array(schema.Member)
+                .check(z.describe('The members, oldest first.'), z.meta({ examples: [[]] })),
+        }), "A non-paginated list of an organization's members."), 'MemberList');
     })(listMembers = schema.listMembers || (schema.listMembers = {}));
     /** Schemas for the removeMember operation. */
     let removeMember;
     (function (removeMember) {
         /** Confirmation that the member was removed. */
-        removeMember.Response = z
+        removeMember.Response = OpenApi.component(z
             .object({
             userId: z
                 .string()
                 .check(z.describe('User id (`usr_…`) of the removed member.'), z.meta({ examples: ['usr_1a2b3c4d5e6f7g8h9j0k1m2n'] })),
         })
-            .check(z.describe('Confirmation that the member was removed.'));
+            .check(z.describe('Confirmation that the member was removed.')), 'RemoveMemberResponse');
     })(removeMember = schema.removeMember || (schema.removeMember = {}));
 })(schema || (schema = {}));
 /**
@@ -87,7 +87,13 @@ export function members() {
     }), OpenApi.describeRoute({
         operationId: 'listMembers',
         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.' },
+                404: {
+                    codes: ['organization_not_found'],
+                    description: 'No accessible organization was found for this id.',
+                },
+            },
             success: {
                 description: 'The members, oldest first.',
                 schema: schema.listMembers.Response,
@@ -119,7 +125,7 @@ export function members() {
         .patch('/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/members/:userId{usr_[A-Za-z0-9_-]+}', Auth.policy({ apiKey: { scopes: ['management:write'] }, session: true }), Auth.ensureOrg({ role: 'owner' }), OpenApi.validate('param', schema.MemberParams, {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
-    }), OpenApi.validate('json', schema.MemberBody, {
+    }), OpenApi.validate('json', schema.UpdateMemberRequest, {
         code: 'body_invalid',
         message: 'Check the request body and try again.',
     }), OpenApi.describeRoute({
@@ -127,7 +133,14 @@ export function members() {
         operationId: 'updateMember',
         responses: OpenApi.responses({
             errors: {
-                404: 'No accessible member was found for this id.',
+                400: {
+                    codes: ['body_invalid', 'param_invalid'],
+                    description: 'Malformed API key, invalid path, or invalid body.',
+                },
+                404: {
+                    codes: ['member_not_found', 'organization_not_found'],
+                    description: 'No accessible organization or member was found for this id.',
+                },
                 409: {
                     codes: ['last_owner'],
                     description: 'The organization would be left without an owner.',
@@ -142,6 +155,8 @@ export function members() {
             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',
@@ -178,7 +193,11 @@ export function members() {
         operationId: 'removeMember',
         responses: OpenApi.responses({
             errors: {
-                404: 'No accessible member was found for this id.',
+                400: { codes: ['param_invalid'], description: 'Malformed API key or invalid path.' },
+                404: {
+                    codes: ['member_not_found', 'organization_not_found'],
+                    description: 'No accessible organization or member was found for this id.',
+                },
                 409: {
                     codes: ['last_owner'],
                     description: 'The organization would be left without an owner.',