@steuerboard/mcp 0.3.0 → 0.3.4

package/src/models/updatefileop.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
-import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import { FileT, FileT$zodSchema } from "./file.js";
 import { FileUpdate, FileUpdate$zodSchema } from "./fileupdate.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -170,31 +169,35 @@ export const UpdateFileNotFoundResponseBody$zodSchema: z.ZodType<
   message: z.string(),
 }).describe("File not found");
 
-export const UpdateFileStatusCode$zodSchema = z.literal(403);
+export const UpdateFileForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateFileStatusCode = z.infer<
-  typeof UpdateFileStatusCode$zodSchema
+export type UpdateFileForbiddenStatusCode = z.infer<
+  typeof UpdateFileForbiddenStatusCode$zodSchema
 >;
 
-export const UpdateFileType$zodSchema = z.enum([
+export const UpdateFileForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateFileType = z.infer<typeof UpdateFileType$zodSchema>;
+export type UpdateFileForbiddenType = z.infer<
+  typeof UpdateFileForbiddenType$zodSchema
+>;
 
-export const UpdateFileCode$zodSchema = z.enum([
+export const UpdateFileForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateFileCode = z.infer<typeof UpdateFileCode$zodSchema>;
+export type UpdateFileForbiddenCode = z.infer<
+  typeof UpdateFileForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type UpdateFileForbiddenResponseBody = {
-  status_code: UpdateFileStatusCode;
-  type: UpdateFileType;
-  code: UpdateFileCode;
+  status_code: UpdateFileForbiddenStatusCode;
+  type: UpdateFileForbiddenType;
+  code: UpdateFileForbiddenCode;
   message: string;
 };
 
@@ -203,52 +206,78 @@ export const UpdateFileForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: UpdateFileCode$zodSchema,
+  code: UpdateFileForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: UpdateFileStatusCode$zodSchema,
-  type: UpdateFileType$zodSchema,
+  status_code: UpdateFileForbiddenStatusCode$zodSchema,
+  type: UpdateFileForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateFileResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  FileT?: FileT | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | UpdateFileForbiddenResponseBody
-    | undefined;
-  fourHundredAndFourApplicationJsonObject?:
-    | UpdateFileNotFoundResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonOneOf?:
-    | UpdateFileResponseBody1
-    | UpdateFileResponseBody2
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const UpdateFileStatusCode400$zodSchema = z.literal(400);
+
+export type UpdateFileStatusCode400 = z.infer<
+  typeof UpdateFileStatusCode400$zodSchema
+>;
+
+export const UpdateFileBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type UpdateFileBadRequestType = z.infer<
+  typeof UpdateFileBadRequestType$zodSchema
+>;
+
+export const UpdateFileCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type UpdateFileCodeMissingClientID = z.infer<
+  typeof UpdateFileCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type UpdateFileBadRequestResponseBody = {
+  status_code: UpdateFileStatusCode400;
+  type: UpdateFileBadRequestType;
+  code: UpdateFileCodeMissingClientID;
+  message: string;
 };
 
+export const UpdateFileBadRequestResponseBody$zodSchema: z.ZodType<
+  UpdateFileBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: UpdateFileCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: UpdateFileStatusCode400$zodSchema,
+  type: UpdateFileBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type UpdateFileResponse =
+  | FileT
+  | UpdateFileBadRequestResponseBody
+  | AuthError
+  | UpdateFileForbiddenResponseBody
+  | RateLimit
+  | UpdateFileNotFoundResponseBody
+  | UpdateFileResponseBody1
+  | UpdateFileResponseBody2;
+
 export const UpdateFileResponse$zodSchema: z.ZodType<
   UpdateFileResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  FileT: FileT$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndFourApplicationJsonObject: z.lazy(() =>
-    UpdateFileNotFoundResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    UpdateFileForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonOneOf: z.union([
+> = z.union([
+  FileT$zodSchema,
+  z.lazy(() => UpdateFileBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => UpdateFileForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  z.lazy(() => UpdateFileNotFoundResponseBody$zodSchema),
+  z.union([
     z.lazy(() => UpdateFileResponseBody1$zodSchema),
     z.lazy(() => UpdateFileResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  ]),
+]);

package/src/models/updatetaskop.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
-import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Task, Task$zodSchema } from "./task.js";
@@ -158,31 +157,35 @@ export const UpdateTaskResponseBody$zodSchema: z.ZodType<
   z.lazy(() => UpdateTaskResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
-export const UpdateTaskStatusCode$zodSchema = z.literal(403);
+export const UpdateTaskForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateTaskStatusCode = z.infer<
-  typeof UpdateTaskStatusCode$zodSchema
+export type UpdateTaskForbiddenStatusCode = z.infer<
+  typeof UpdateTaskForbiddenStatusCode$zodSchema
 >;
 
-export const UpdateTaskType$zodSchema = z.enum([
+export const UpdateTaskForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateTaskType = z.infer<typeof UpdateTaskType$zodSchema>;
+export type UpdateTaskForbiddenType = z.infer<
+  typeof UpdateTaskForbiddenType$zodSchema
+>;
 
-export const UpdateTaskCode$zodSchema = z.enum([
+export const UpdateTaskForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateTaskCode = z.infer<typeof UpdateTaskCode$zodSchema>;
+export type UpdateTaskForbiddenCode = z.infer<
+  typeof UpdateTaskForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type UpdateTaskForbiddenResponseBody = {
-  status_code: UpdateTaskStatusCode;
-  type: UpdateTaskType;
-  code: UpdateTaskCode;
+  status_code: UpdateTaskForbiddenStatusCode;
+  type: UpdateTaskForbiddenType;
+  code: UpdateTaskForbiddenCode;
   message: string;
 };
 
@@ -191,41 +194,78 @@ export const UpdateTaskForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: UpdateTaskCode$zodSchema,
+  code: UpdateTaskForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: UpdateTaskStatusCode$zodSchema,
-  type: UpdateTaskType$zodSchema,
+  status_code: UpdateTaskForbiddenStatusCode$zodSchema,
+  type: UpdateTaskForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateTaskResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Task?: Task | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: UpdateTaskForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: UpdateTaskResponseBody1 | UpdateTaskResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
+export const UpdateTaskStatusCode400$zodSchema = z.literal(400);
+
+export type UpdateTaskStatusCode400 = z.infer<
+  typeof UpdateTaskStatusCode400$zodSchema
+>;
+
+export const UpdateTaskBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type UpdateTaskBadRequestType = z.infer<
+  typeof UpdateTaskBadRequestType$zodSchema
+>;
+
+export const UpdateTaskCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type UpdateTaskCodeMissingClientID = z.infer<
+  typeof UpdateTaskCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type UpdateTaskBadRequestResponseBody = {
+  status_code: UpdateTaskStatusCode400;
+  type: UpdateTaskBadRequestType;
+  code: UpdateTaskCodeMissingClientID;
+  message: string;
 };
 
+export const UpdateTaskBadRequestResponseBody$zodSchema: z.ZodType<
+  UpdateTaskBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: UpdateTaskCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: UpdateTaskStatusCode400$zodSchema,
+  type: UpdateTaskBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type UpdateTaskResponse =
+  | Task
+  | UpdateTaskBadRequestResponseBody
+  | AuthError
+  | UpdateTaskForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | UpdateTaskResponseBody1
+  | UpdateTaskResponseBody2;
+
 export const UpdateTaskResponse$zodSchema: z.ZodType<
   UpdateTaskResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  Task: Task$zodSchema.optional(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  not_found: NotFound$zodSchema.optional(),
-  object: z.lazy(() => UpdateTaskForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
+> = z.union([
+  Task$zodSchema,
+  z.lazy(() => UpdateTaskBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => UpdateTaskForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.union([
     z.lazy(() => UpdateTaskResponseBody1$zodSchema),
     z.lazy(() => UpdateTaskResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  ]),
+]);

package/src/models/updateuserop.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
-import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import { ClientUser, ClientUser$zodSchema } from "./clientuser.js";
 import {
   ClientUserUpdate,
@@ -161,31 +160,35 @@ export const UpdateUserResponseBody$zodSchema: z.ZodType<
   z.lazy(() => UpdateUserResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
-export const UpdateUserStatusCode$zodSchema = z.literal(403);
+export const UpdateUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateUserStatusCode = z.infer<
-  typeof UpdateUserStatusCode$zodSchema
+export type UpdateUserForbiddenStatusCode = z.infer<
+  typeof UpdateUserForbiddenStatusCode$zodSchema
 >;
 
-export const UpdateUserType$zodSchema = z.enum([
+export const UpdateUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateUserType = z.infer<typeof UpdateUserType$zodSchema>;
+export type UpdateUserForbiddenType = z.infer<
+  typeof UpdateUserForbiddenType$zodSchema
+>;
 
-export const UpdateUserCode$zodSchema = z.enum([
+export const UpdateUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateUserCode = z.infer<typeof UpdateUserCode$zodSchema>;
+export type UpdateUserForbiddenCode = z.infer<
+  typeof UpdateUserForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type UpdateUserForbiddenResponseBody = {
-  status_code: UpdateUserStatusCode;
-  type: UpdateUserType;
-  code: UpdateUserCode;
+  status_code: UpdateUserForbiddenStatusCode;
+  type: UpdateUserForbiddenType;
+  code: UpdateUserForbiddenCode;
   message: string;
 };
 
@@ -194,41 +197,78 @@ export const UpdateUserForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: UpdateUserCode$zodSchema,
+  code: UpdateUserForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: UpdateUserStatusCode$zodSchema,
-  type: UpdateUserType$zodSchema,
+  status_code: UpdateUserForbiddenStatusCode$zodSchema,
+  type: UpdateUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  ClientUser?: ClientUser | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: UpdateUserForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: UpdateUserResponseBody1 | UpdateUserResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
+export const UpdateUserStatusCode400$zodSchema = z.literal(400);
+
+export type UpdateUserStatusCode400 = z.infer<
+  typeof UpdateUserStatusCode400$zodSchema
+>;
+
+export const UpdateUserBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type UpdateUserBadRequestType = z.infer<
+  typeof UpdateUserBadRequestType$zodSchema
+>;
+
+export const UpdateUserCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type UpdateUserCodeMissingClientID = z.infer<
+  typeof UpdateUserCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type UpdateUserBadRequestResponseBody = {
+  status_code: UpdateUserStatusCode400;
+  type: UpdateUserBadRequestType;
+  code: UpdateUserCodeMissingClientID;
+  message: string;
 };
 
+export const UpdateUserBadRequestResponseBody$zodSchema: z.ZodType<
+  UpdateUserBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: UpdateUserCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: UpdateUserStatusCode400$zodSchema,
+  type: UpdateUserBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type UpdateUserResponse =
+  | ClientUser
+  | UpdateUserBadRequestResponseBody
+  | AuthError
+  | UpdateUserForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | UpdateUserResponseBody1
+  | UpdateUserResponseBody2;
+
 export const UpdateUserResponse$zodSchema: z.ZodType<
   UpdateUserResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ClientUser: ClientUser$zodSchema.optional(),
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  not_found: NotFound$zodSchema.optional(),
-  object: z.lazy(() => UpdateUserForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
+> = z.union([
+  ClientUser$zodSchema,
+  z.lazy(() => UpdateUserBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => UpdateUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.union([
     z.lazy(() => UpdateUserResponseBody1$zodSchema),
     z.lazy(() => UpdateUserResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  ]),
+]);

package/src/models/updateworkspaceop.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
-import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Workspace, Workspace$zodSchema } from "./workspace.js";
@@ -161,31 +160,35 @@ export const UpdateWorkspaceResponseBody$zodSchema: z.ZodType<
   z.lazy(() => UpdateWorkspaceResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
-export const UpdateWorkspaceStatusCode$zodSchema = z.literal(403);
+export const UpdateWorkspaceForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateWorkspaceStatusCode = z.infer<
-  typeof UpdateWorkspaceStatusCode$zodSchema
+export type UpdateWorkspaceForbiddenStatusCode = z.infer<
+  typeof UpdateWorkspaceForbiddenStatusCode$zodSchema
 >;
 
-export const UpdateWorkspaceType$zodSchema = z.enum([
+export const UpdateWorkspaceForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateWorkspaceType = z.infer<typeof UpdateWorkspaceType$zodSchema>;
+export type UpdateWorkspaceForbiddenType = z.infer<
+  typeof UpdateWorkspaceForbiddenType$zodSchema
+>;
 
-export const UpdateWorkspaceCode$zodSchema = z.enum([
+export const UpdateWorkspaceForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateWorkspaceCode = z.infer<typeof UpdateWorkspaceCode$zodSchema>;
+export type UpdateWorkspaceForbiddenCode = z.infer<
+  typeof UpdateWorkspaceForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type UpdateWorkspaceForbiddenResponseBody = {
-  status_code: UpdateWorkspaceStatusCode;
-  type: UpdateWorkspaceType;
-  code: UpdateWorkspaceCode;
+  status_code: UpdateWorkspaceForbiddenStatusCode;
+  type: UpdateWorkspaceForbiddenType;
+  code: UpdateWorkspaceForbiddenCode;
   message: string;
 };
 
@@ -194,45 +197,78 @@ export const UpdateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: UpdateWorkspaceCode$zodSchema,
+  code: UpdateWorkspaceForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: UpdateWorkspaceStatusCode$zodSchema,
-  type: UpdateWorkspaceType$zodSchema,
+  status_code: UpdateWorkspaceForbiddenStatusCode$zodSchema,
+  type: UpdateWorkspaceForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateWorkspaceResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Workspace?: Workspace | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: UpdateWorkspaceForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?:
-    | UpdateWorkspaceResponseBody1
-    | UpdateWorkspaceResponseBody2
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const UpdateWorkspaceStatusCode400$zodSchema = z.literal(400);
+
+export type UpdateWorkspaceStatusCode400 = z.infer<
+  typeof UpdateWorkspaceStatusCode400$zodSchema
+>;
+
+export const UpdateWorkspaceBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type UpdateWorkspaceBadRequestType = z.infer<
+  typeof UpdateWorkspaceBadRequestType$zodSchema
+>;
+
+export const UpdateWorkspaceCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type UpdateWorkspaceCodeMissingClientID = z.infer<
+  typeof UpdateWorkspaceCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type UpdateWorkspaceBadRequestResponseBody = {
+  status_code: UpdateWorkspaceStatusCode400;
+  type: UpdateWorkspaceBadRequestType;
+  code: UpdateWorkspaceCodeMissingClientID;
+  message: string;
 };
 
+export const UpdateWorkspaceBadRequestResponseBody$zodSchema: z.ZodType<
+  UpdateWorkspaceBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: UpdateWorkspaceCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: UpdateWorkspaceStatusCode400$zodSchema,
+  type: UpdateWorkspaceBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type UpdateWorkspaceResponse =
+  | Workspace
+  | UpdateWorkspaceBadRequestResponseBody
+  | AuthError
+  | UpdateWorkspaceForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | UpdateWorkspaceResponseBody1
+  | UpdateWorkspaceResponseBody2;
+
 export const UpdateWorkspaceResponse$zodSchema: z.ZodType<
   UpdateWorkspaceResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  Workspace: Workspace$zodSchema.optional(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  not_found: NotFound$zodSchema.optional(),
-  object: z.lazy(() => UpdateWorkspaceForbiddenResponseBody$zodSchema)
-    .optional(),
-  oneOf: z.union([
+> = z.union([
+  Workspace$zodSchema,
+  z.lazy(() => UpdateWorkspaceBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => UpdateWorkspaceForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.union([
     z.lazy(() => UpdateWorkspaceResponseBody1$zodSchema),
     z.lazy(() => UpdateWorkspaceResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  ]),
+]);

package/src/models/workspacemember.ts

@@ -12,12 +12,14 @@ export type User = {
   email: string;
   firstName: string | null;
   lastName: string | null;
+  image: string | null;
 };
 
 export const User$zodSchema: z.ZodType<User, z.ZodTypeDef, unknown> = z.object({
   email: z.string(),
   firstName: z.string().nullable(),
   id: z.string(),
+  image: z.string().nullable(),
   lastName: z.string().nullable(),
 }).describe(
   "Optional user object with denormalised information for convenience.",