@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/gettaskop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -10,22 +11,14 @@ import { Task, Task$zodSchema } from "./task.js";
 
 export type GetTaskRequest = { id: string; xClientId: string };
 
-export const GetTaskRequest$zodSchema: z.ZodType<
-  GetTaskRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetTaskRequest$zodSchema: z.ZodType<GetTaskRequest> = z.object({
   id: z.string(),
   xClientId: z.string(),
 });
 
 export type GetTaskPath = string | number;
 
-export const GetTaskPath$zodSchema: z.ZodType<
-  GetTaskPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetTaskPath$zodSchema: z.ZodType<GetTaskPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -36,11 +29,7 @@ export type GetTaskIssue = {
   message?: string | undefined;
 };
 
-export const GetTaskIssue$zodSchema: z.ZodType<
-  GetTaskIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetTaskIssue$zodSchema: z.ZodType<GetTaskIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -51,11 +40,7 @@ export const GetTaskIssue$zodSchema: z.ZodType<
 
 export type GetTaskError = { issues: Array<GetTaskIssue>; name: string };
 
-export const GetTaskError$zodSchema: z.ZodType<
-  GetTaskError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetTaskError$zodSchema: z.ZodType<GetTaskError> = z.object({
   issues: z.array(z.lazy(() => GetTaskIssue$zodSchema)),
   name: z.string(),
 });
@@ -69,36 +54,39 @@ export type GetTaskUnprocessableEntityResponseBody = {
 };
 
 export const GetTaskUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  GetTaskUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetTaskUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => GetTaskError$zodSchema),
   success: z.boolean(),
 }).describe("Invalid id error");
 
+export const GetTaskForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetTaskForbiddenStatusCode = ClosedEnum<
+  typeof GetTaskForbiddenStatusCode
+>;
+
 export const GetTaskForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type GetTaskForbiddenStatusCode = z.infer<
-  typeof GetTaskForbiddenStatusCode$zodSchema
->;
+export const GetTaskForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type GetTaskForbiddenType = ClosedEnum<typeof GetTaskForbiddenType>;
 
 export const GetTaskForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetTaskForbiddenType = z.infer<
-  typeof GetTaskForbiddenType$zodSchema
->;
+export const GetTaskForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetTaskForbiddenCode = ClosedEnum<typeof GetTaskForbiddenCode>;
 
 export const GetTaskForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetTaskForbiddenCode = z.infer<
-  typeof GetTaskForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -110,9 +98,7 @@ export type GetTaskForbiddenResponseBody = {
 };
 
 export const GetTaskForbiddenResponseBody$zodSchema: z.ZodType<
-  GetTaskForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetTaskForbiddenResponseBody
 > = z.object({
   code: GetTaskForbiddenCode$zodSchema,
   message: z.string(),
@@ -120,28 +106,33 @@ export const GetTaskForbiddenResponseBody$zodSchema: z.ZodType<
   type: GetTaskForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const GetTaskStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type GetTaskStatusCode400 = ClosedEnum<typeof GetTaskStatusCode400>;
+
 export const GetTaskStatusCode400$zodSchema = z.literal(400);
 
-export type GetTaskStatusCode400 = z.infer<
-  typeof GetTaskStatusCode400$zodSchema
->;
+export const GetTaskBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type GetTaskBadRequestType = ClosedEnum<typeof GetTaskBadRequestType>;
 
 export const GetTaskBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type GetTaskBadRequestType = z.infer<
-  typeof GetTaskBadRequestType$zodSchema
+export const GetTaskCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type GetTaskCodeMissingClientID = ClosedEnum<
+  typeof GetTaskCodeMissingClientID
 >;
 
 export const GetTaskCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type GetTaskCodeMissingClientID = z.infer<
-  typeof GetTaskCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -153,9 +144,7 @@ export type GetTaskBadRequestResponseBody = {
 };
 
 export const GetTaskBadRequestResponseBody$zodSchema: z.ZodType<
-  GetTaskBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetTaskBadRequestResponseBody
 > = z.object({
   code: GetTaskCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -172,11 +161,7 @@ export type GetTaskResponse =
   | RateLimit
   | GetTaskUnprocessableEntityResponseBody;
 
-export const GetTaskResponse$zodSchema: z.ZodType<
-  GetTaskResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetTaskResponse$zodSchema: z.ZodType<GetTaskResponse> = z.union([
   Task$zodSchema,
   z.lazy(() => GetTaskBadRequestResponseBody$zodSchema),
   AuthError$zodSchema,

package/src/models/getuserop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { ClientUser, ClientUser$zodSchema } from "./clientuser.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
@@ -10,22 +11,14 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type GetUserRequest = { id: string; xClientId: string };
 
-export const GetUserRequest$zodSchema: z.ZodType<
-  GetUserRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserRequest$zodSchema: z.ZodType<GetUserRequest> = z.object({
   id: z.string(),
   xClientId: z.string(),
 });
 
 export type GetUserPath2 = string | number;
 
-export const GetUserPath2$zodSchema: z.ZodType<
-  GetUserPath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetUserPath2$zodSchema: z.ZodType<GetUserPath2> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -36,11 +29,7 @@ export type GetUserIssue2 = {
   message?: string | undefined;
 };
 
-export const GetUserIssue2$zodSchema: z.ZodType<
-  GetUserIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserIssue2$zodSchema: z.ZodType<GetUserIssue2> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -51,33 +40,22 @@ export const GetUserIssue2$zodSchema: z.ZodType<
 
 export type GetUserError2 = { issues: Array<GetUserIssue2>; name: string };
 
-export const GetUserError2$zodSchema: z.ZodType<
-  GetUserError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserError2$zodSchema: z.ZodType<GetUserError2> = z.object({
   issues: z.array(z.lazy(() => GetUserIssue2$zodSchema)),
   name: z.string(),
 });
 
 export type GetUserResponseBody2 = { success: boolean; error: GetUserError2 };
 
-export const GetUserResponseBody2$zodSchema: z.ZodType<
-  GetUserResponseBody2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => GetUserError2$zodSchema),
-  success: z.boolean(),
-});
+export const GetUserResponseBody2$zodSchema: z.ZodType<GetUserResponseBody2> = z
+  .object({
+    error: z.lazy(() => GetUserError2$zodSchema),
+    success: z.boolean(),
+  });
 
 export type GetUserPath1 = string | number;
 
-export const GetUserPath1$zodSchema: z.ZodType<
-  GetUserPath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetUserPath1$zodSchema: z.ZodType<GetUserPath1> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -88,11 +66,7 @@ export type GetUserIssue1 = {
   message?: string | undefined;
 };
 
-export const GetUserIssue1$zodSchema: z.ZodType<
-  GetUserIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserIssue1$zodSchema: z.ZodType<GetUserIssue1> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -103,62 +77,57 @@ export const GetUserIssue1$zodSchema: z.ZodType<
 
 export type GetUserError1 = { issues: Array<GetUserIssue1>; name: string };
 
-export const GetUserError1$zodSchema: z.ZodType<
-  GetUserError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserError1$zodSchema: z.ZodType<GetUserError1> = z.object({
   issues: z.array(z.lazy(() => GetUserIssue1$zodSchema)),
   name: z.string(),
 });
 
 export type GetUserResponseBody1 = { success: boolean; error: GetUserError1 };
 
-export const GetUserResponseBody1$zodSchema: z.ZodType<
-  GetUserResponseBody1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => GetUserError1$zodSchema),
-  success: z.boolean(),
-});
+export const GetUserResponseBody1$zodSchema: z.ZodType<GetUserResponseBody1> = z
+  .object({
+    error: z.lazy(() => GetUserError1$zodSchema),
+    success: z.boolean(),
+  });
 
 /**
  * The validation error(s)
  */
 export type GetUserResponseBody = GetUserResponseBody1 | GetUserResponseBody2;
 
-export const GetUserResponseBody$zodSchema: z.ZodType<
-  GetUserResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => GetUserResponseBody1$zodSchema),
-  z.lazy(() => GetUserResponseBody2$zodSchema),
-]).describe("The validation error(s)");
+export const GetUserResponseBody$zodSchema: z.ZodType<GetUserResponseBody> = z
+  .union([
+    z.lazy(() => GetUserResponseBody1$zodSchema),
+    z.lazy(() => GetUserResponseBody2$zodSchema),
+  ]).describe("The validation error(s)");
+
+export const GetUserForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetUserForbiddenStatusCode = ClosedEnum<
+  typeof GetUserForbiddenStatusCode
+>;
 
 export const GetUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type GetUserForbiddenStatusCode = z.infer<
-  typeof GetUserForbiddenStatusCode$zodSchema
->;
+export const GetUserForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type GetUserForbiddenType = ClosedEnum<typeof GetUserForbiddenType>;
 
 export const GetUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetUserForbiddenType = z.infer<
-  typeof GetUserForbiddenType$zodSchema
->;
+export const GetUserForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetUserForbiddenCode = ClosedEnum<typeof GetUserForbiddenCode>;
 
 export const GetUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetUserForbiddenCode = z.infer<
-  typeof GetUserForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -170,9 +139,7 @@ export type GetUserForbiddenResponseBody = {
 };
 
 export const GetUserForbiddenResponseBody$zodSchema: z.ZodType<
-  GetUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetUserForbiddenResponseBody
 > = z.object({
   code: GetUserForbiddenCode$zodSchema,
   message: z.string(),
@@ -180,28 +147,33 @@ export const GetUserForbiddenResponseBody$zodSchema: z.ZodType<
   type: GetUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const GetUserStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type GetUserStatusCode400 = ClosedEnum<typeof GetUserStatusCode400>;
+
 export const GetUserStatusCode400$zodSchema = z.literal(400);
 
-export type GetUserStatusCode400 = z.infer<
-  typeof GetUserStatusCode400$zodSchema
->;
+export const GetUserBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type GetUserBadRequestType = ClosedEnum<typeof GetUserBadRequestType>;
 
 export const GetUserBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type GetUserBadRequestType = z.infer<
-  typeof GetUserBadRequestType$zodSchema
+export const GetUserCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type GetUserCodeMissingClientID = ClosedEnum<
+  typeof GetUserCodeMissingClientID
 >;
 
 export const GetUserCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type GetUserCodeMissingClientID = z.infer<
-  typeof GetUserCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -213,9 +185,7 @@ export type GetUserBadRequestResponseBody = {
 };
 
 export const GetUserBadRequestResponseBody$zodSchema: z.ZodType<
-  GetUserBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetUserBadRequestResponseBody
 > = z.object({
   code: GetUserCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -233,11 +203,7 @@ export type GetUserResponse =
   | GetUserResponseBody1
   | GetUserResponseBody2;
 
-export const GetUserResponse$zodSchema: z.ZodType<
-  GetUserResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetUserResponse$zodSchema: z.ZodType<GetUserResponse> = z.union([
   ClientUser$zodSchema,
   z.lazy(() => GetUserBadRequestResponseBody$zodSchema),
   AuthError$zodSchema,

package/src/models/getworkspaceop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -10,22 +11,15 @@ import { Workspace, Workspace$zodSchema } from "./workspace.js";
 
 export type GetWorkspaceRequest = { id: string; xClientId: string };
 
-export const GetWorkspaceRequest$zodSchema: z.ZodType<
-  GetWorkspaceRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  xClientId: z.string(),
-});
+export const GetWorkspaceRequest$zodSchema: z.ZodType<GetWorkspaceRequest> = z
+  .object({
+    id: z.string(),
+    xClientId: z.string(),
+  });
 
 export type GetWorkspacePath = string | number;
 
-export const GetWorkspacePath$zodSchema: z.ZodType<
-  GetWorkspacePath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetWorkspacePath$zodSchema: z.ZodType<GetWorkspacePath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -36,32 +30,26 @@ export type GetWorkspaceIssue = {
   message?: string | undefined;
 };
 
-export const GetWorkspaceIssue$zodSchema: z.ZodType<
-  GetWorkspaceIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const GetWorkspaceIssue$zodSchema: z.ZodType<GetWorkspaceIssue> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type GetWorkspaceError = {
   issues: Array<GetWorkspaceIssue>;
   name: string;
 };
 
-export const GetWorkspaceError$zodSchema: z.ZodType<
-  GetWorkspaceError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => GetWorkspaceIssue$zodSchema)),
-  name: z.string(),
-});
+export const GetWorkspaceError$zodSchema: z.ZodType<GetWorkspaceError> = z
+  .object({
+    issues: z.array(z.lazy(() => GetWorkspaceIssue$zodSchema)),
+    name: z.string(),
+  });
 
 /**
  * Invalid id error
@@ -72,36 +60,43 @@ export type GetWorkspaceUnprocessableEntityResponseBody = {
 };
 
 export const GetWorkspaceUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  GetWorkspaceUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetWorkspaceUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => GetWorkspaceError$zodSchema),
   success: z.boolean(),
 }).describe("Invalid id error");
 
+export const GetWorkspaceForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetWorkspaceForbiddenStatusCode = ClosedEnum<
+  typeof GetWorkspaceForbiddenStatusCode
+>;
+
 export const GetWorkspaceForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type GetWorkspaceForbiddenStatusCode = z.infer<
-  typeof GetWorkspaceForbiddenStatusCode$zodSchema
+export const GetWorkspaceForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type GetWorkspaceForbiddenType = ClosedEnum<
+  typeof GetWorkspaceForbiddenType
 >;
 
 export const GetWorkspaceForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetWorkspaceForbiddenType = z.infer<
-  typeof GetWorkspaceForbiddenType$zodSchema
+export const GetWorkspaceForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetWorkspaceForbiddenCode = ClosedEnum<
+  typeof GetWorkspaceForbiddenCode
 >;
 
 export const GetWorkspaceForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetWorkspaceForbiddenCode = z.infer<
-  typeof GetWorkspaceForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -113,9 +108,7 @@ export type GetWorkspaceForbiddenResponseBody = {
 };
 
 export const GetWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
-  GetWorkspaceForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetWorkspaceForbiddenResponseBody
 > = z.object({
   code: GetWorkspaceForbiddenCode$zodSchema,
   message: z.string(),
@@ -123,28 +116,37 @@ export const GetWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
   type: GetWorkspaceForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const GetWorkspaceStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type GetWorkspaceStatusCode400 = ClosedEnum<
+  typeof GetWorkspaceStatusCode400
+>;
+
 export const GetWorkspaceStatusCode400$zodSchema = z.literal(400);
 
-export type GetWorkspaceStatusCode400 = z.infer<
-  typeof GetWorkspaceStatusCode400$zodSchema
+export const GetWorkspaceBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type GetWorkspaceBadRequestType = ClosedEnum<
+  typeof GetWorkspaceBadRequestType
 >;
 
 export const GetWorkspaceBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type GetWorkspaceBadRequestType = z.infer<
-  typeof GetWorkspaceBadRequestType$zodSchema
+export const GetWorkspaceCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type GetWorkspaceCodeMissingClientID = ClosedEnum<
+  typeof GetWorkspaceCodeMissingClientID
 >;
 
 export const GetWorkspaceCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type GetWorkspaceCodeMissingClientID = z.infer<
-  typeof GetWorkspaceCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -156,9 +158,7 @@ export type GetWorkspaceBadRequestResponseBody = {
 };
 
 export const GetWorkspaceBadRequestResponseBody$zodSchema: z.ZodType<
-  GetWorkspaceBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetWorkspaceBadRequestResponseBody
 > = z.object({
   code: GetWorkspaceCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -175,16 +175,13 @@ export type GetWorkspaceResponse =
   | RateLimit
   | GetWorkspaceUnprocessableEntityResponseBody;
 
-export const GetWorkspaceResponse$zodSchema: z.ZodType<
-  GetWorkspaceResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  Workspace$zodSchema,
-  z.lazy(() => GetWorkspaceBadRequestResponseBody$zodSchema),
-  AuthError$zodSchema,
-  z.lazy(() => GetWorkspaceForbiddenResponseBody$zodSchema),
-  NotFound$zodSchema,
-  RateLimit$zodSchema,
-  z.lazy(() => GetWorkspaceUnprocessableEntityResponseBody$zodSchema),
-]);
+export const GetWorkspaceResponse$zodSchema: z.ZodType<GetWorkspaceResponse> = z
+  .union([
+    Workspace$zodSchema,
+    z.lazy(() => GetWorkspaceBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => GetWorkspaceForbiddenResponseBody$zodSchema),
+    NotFound$zodSchema,
+    RateLimit$zodSchema,
+    z.lazy(() => GetWorkspaceUnprocessableEntityResponseBody$zodSchema),
+  ]);