@steuerboard/mcp 0.3.0 → 0.3.4

package/src/models/indexop.ts

@@ -18,22 +18,13 @@ export const IndexResponseBody$zodSchema: z.ZodType<
   message: z.string(),
 }).describe("Steuerboard API Index");
 
-export type IndexResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  object?: IndexResponseBody | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type IndexResponse = RateLimit | IndexResponseBody;
 
 export const IndexResponse$zodSchema: z.ZodType<
   IndexResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  object: z.lazy(() => IndexResponseBody$zodSchema).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  RateLimit$zodSchema,
+  z.lazy(() => IndexResponseBody$zodSchema),
+]);

package/src/models/inviteaccountantuserop.ts

@@ -114,40 +114,25 @@ export const InviteAccountantUserForbiddenResponseBody$zodSchema: z.ZodType<
   type: InviteAccountantUserType$zodSchema,
 }).describe("Missing scope");
 
-export type InviteAccountantUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  AccountantUser?: AccountantUser | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | InviteAccountantUserForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  conflict?: Conflict | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | InviteAccountantUserUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type InviteAccountantUserResponse =
+  | AccountantUser
+  | AuthError
+  | InviteAccountantUserForbiddenResponseBody
+  | NotFound
+  | Conflict
+  | RateLimit
+  | InviteAccountantUserUnprocessableEntityResponseBody;
 
 export const InviteAccountantUserResponse$zodSchema: z.ZodType<
   InviteAccountantUserResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  AccountantUser: AccountantUser$zodSchema.optional(),
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  conflict: Conflict$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    InviteAccountantUserForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    InviteAccountantUserUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  AccountantUser$zodSchema,
+  AuthError$zodSchema,
+  z.lazy(() => InviteAccountantUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  Conflict$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() => InviteAccountantUserUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/inviteuserop.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 {
   ClientUserInvite,
@@ -86,31 +85,35 @@ export const InviteUserUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("The validation error(s)");
 
-export const InviteUserStatusCode$zodSchema = z.literal(403);
+export const InviteUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type InviteUserStatusCode = z.infer<
-  typeof InviteUserStatusCode$zodSchema
+export type InviteUserForbiddenStatusCode = z.infer<
+  typeof InviteUserForbiddenStatusCode$zodSchema
 >;
 
-export const InviteUserType$zodSchema = z.enum([
+export const InviteUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type InviteUserType = z.infer<typeof InviteUserType$zodSchema>;
+export type InviteUserForbiddenType = z.infer<
+  typeof InviteUserForbiddenType$zodSchema
+>;
 
-export const InviteUserCode$zodSchema = z.enum([
+export const InviteUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type InviteUserCode = z.infer<typeof InviteUserCode$zodSchema>;
+export type InviteUserForbiddenCode = z.infer<
+  typeof InviteUserForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type InviteUserForbiddenResponseBody = {
-  status_code: InviteUserStatusCode;
-  type: InviteUserType;
-  code: InviteUserCode;
+  status_code: InviteUserForbiddenStatusCode;
+  type: InviteUserForbiddenType;
+  code: InviteUserForbiddenCode;
   message: string;
 };
 
@@ -119,48 +122,76 @@ export const InviteUserForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: InviteUserCode$zodSchema,
+  code: InviteUserForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: InviteUserStatusCode$zodSchema,
-  type: InviteUserType$zodSchema,
+  status_code: InviteUserForbiddenStatusCode$zodSchema,
+  type: InviteUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type InviteUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  ClientUser?: ClientUser | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | InviteUserForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  conflict?: Conflict | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | InviteUserUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const InviteUserStatusCode400$zodSchema = z.literal(400);
+
+export type InviteUserStatusCode400 = z.infer<
+  typeof InviteUserStatusCode400$zodSchema
+>;
+
+export const InviteUserBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type InviteUserBadRequestType = z.infer<
+  typeof InviteUserBadRequestType$zodSchema
+>;
+
+export const InviteUserCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type InviteUserCodeMissingClientID = z.infer<
+  typeof InviteUserCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type InviteUserBadRequestResponseBody = {
+  status_code: InviteUserStatusCode400;
+  type: InviteUserBadRequestType;
+  code: InviteUserCodeMissingClientID;
+  message: string;
 };
 
+export const InviteUserBadRequestResponseBody$zodSchema: z.ZodType<
+  InviteUserBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: InviteUserCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: InviteUserStatusCode400$zodSchema,
+  type: InviteUserBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type InviteUserResponse =
+  | ClientUser
+  | InviteUserBadRequestResponseBody
+  | AuthError
+  | InviteUserForbiddenResponseBody
+  | NotFound
+  | Conflict
+  | RateLimit
+  | InviteUserUnprocessableEntityResponseBody;
+
 export const InviteUserResponse$zodSchema: z.ZodType<
   InviteUserResponse,
   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(),
-  conflict: Conflict$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    InviteUserForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    InviteUserUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  ClientUser$zodSchema,
+  z.lazy(() => InviteUserBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => InviteUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  Conflict$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() => InviteUserUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/listaccountantusersop.ts

@@ -175,38 +175,21 @@ export const ListAccountantUsersResponseBody$zodSchema: z.ZodType<
   pagination: Pagination$zodSchema,
 }).describe("Accountant users");
 
-export type ListAccountantUsersResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  twoHundredApplicationJsonObject?: ListAccountantUsersResponseBody | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListAccountantUsersForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListAccountantUsersUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type ListAccountantUsersResponse =
+  | AuthError
+  | ListAccountantUsersForbiddenResponseBody
+  | RateLimit
+  | ListAccountantUsersResponseBody
+  | ListAccountantUsersUnprocessableEntityResponseBody;
 
 export const ListAccountantUsersResponse$zodSchema: z.ZodType<
   ListAccountantUsersResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListAccountantUsersForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListAccountantUsersUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-  twoHundredApplicationJsonObject: z.lazy(() =>
-    ListAccountantUsersResponseBody$zodSchema
-  ).optional(),
-});
+> = z.union([
+  AuthError$zodSchema,
+  z.lazy(() => ListAccountantUsersForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  z.lazy(() => ListAccountantUsersResponseBody$zodSchema),
+  z.lazy(() => ListAccountantUsersUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/listclientsop.ts

@@ -184,36 +184,21 @@ export const ListClientsForbiddenResponseBody$zodSchema: z.ZodType<
   type: ListClientsType$zodSchema,
 }).describe("Missing scope");
 
-export type ListClientsResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  PaginatedClients?: PaginatedClients | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListClientsForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListClientsUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type ListClientsResponse =
+  | AuthError
+  | ListClientsForbiddenResponseBody
+  | RateLimit
+  | PaginatedClients
+  | ListClientsUnprocessableEntityResponseBody;
 
 export const ListClientsResponse$zodSchema: z.ZodType<
   ListClientsResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  PaginatedClients: PaginatedClients$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListClientsForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListClientsUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  AuthError$zodSchema,
+  z.lazy(() => ListClientsForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  PaginatedClients$zodSchema,
+  z.lazy(() => ListClientsUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/listfilesop.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 { PaginatedFiles, PaginatedFiles$zodSchema } from "./paginatedfiles.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
@@ -84,29 +83,35 @@ export const ListFilesUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("The validation error(s)");
 
-export const ListFilesStatusCode$zodSchema = z.literal(403);
+export const ListFilesForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type ListFilesStatusCode = z.infer<typeof ListFilesStatusCode$zodSchema>;
+export type ListFilesForbiddenStatusCode = z.infer<
+  typeof ListFilesForbiddenStatusCode$zodSchema
+>;
 
-export const ListFilesType$zodSchema = z.enum([
+export const ListFilesForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type ListFilesType = z.infer<typeof ListFilesType$zodSchema>;
+export type ListFilesForbiddenType = z.infer<
+  typeof ListFilesForbiddenType$zodSchema
+>;
 
-export const ListFilesCode$zodSchema = z.enum([
+export const ListFilesForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type ListFilesCode = z.infer<typeof ListFilesCode$zodSchema>;
+export type ListFilesForbiddenCode = z.infer<
+  typeof ListFilesForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type ListFilesForbiddenResponseBody = {
-  status_code: ListFilesStatusCode;
-  type: ListFilesType;
-  code: ListFilesCode;
+  status_code: ListFilesForbiddenStatusCode;
+  type: ListFilesForbiddenType;
+  code: ListFilesForbiddenCode;
   message: string;
 };
 
@@ -115,44 +120,72 @@ export const ListFilesForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: ListFilesCode$zodSchema,
+  code: ListFilesForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: ListFilesStatusCode$zodSchema,
-  type: ListFilesType$zodSchema,
+  status_code: ListFilesForbiddenStatusCode$zodSchema,
+  type: ListFilesForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type ListFilesResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  PaginatedFiles?: PaginatedFiles | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListFilesForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListFilesUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const ListFilesStatusCode400$zodSchema = z.literal(400);
+
+export type ListFilesStatusCode400 = z.infer<
+  typeof ListFilesStatusCode400$zodSchema
+>;
+
+export const ListFilesBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type ListFilesBadRequestType = z.infer<
+  typeof ListFilesBadRequestType$zodSchema
+>;
+
+export const ListFilesCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type ListFilesCodeMissingClientID = z.infer<
+  typeof ListFilesCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type ListFilesBadRequestResponseBody = {
+  status_code: ListFilesStatusCode400;
+  type: ListFilesBadRequestType;
+  code: ListFilesCodeMissingClientID;
+  message: string;
 };
 
+export const ListFilesBadRequestResponseBody$zodSchema: z.ZodType<
+  ListFilesBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: ListFilesCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: ListFilesStatusCode400$zodSchema,
+  type: ListFilesBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type ListFilesResponse =
+  | ListFilesBadRequestResponseBody
+  | AuthError
+  | ListFilesForbiddenResponseBody
+  | RateLimit
+  | PaginatedFiles
+  | ListFilesUnprocessableEntityResponseBody;
+
 export const ListFilesResponse$zodSchema: z.ZodType<
   ListFilesResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  PaginatedFiles: PaginatedFiles$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListFilesForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListFilesUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  z.lazy(() => ListFilesBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => ListFilesForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  PaginatedFiles$zodSchema,
+  z.lazy(() => ListFilesUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/listtasksop.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 { PaginatedTasks, PaginatedTasks$zodSchema } from "./paginatedtasks.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
@@ -113,29 +112,35 @@ export const ListTasksUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("The validation error(s)");
 
-export const ListTasksStatusCode$zodSchema = z.literal(403);
+export const ListTasksForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type ListTasksStatusCode = z.infer<typeof ListTasksStatusCode$zodSchema>;
+export type ListTasksForbiddenStatusCode = z.infer<
+  typeof ListTasksForbiddenStatusCode$zodSchema
+>;
 
-export const ListTasksType$zodSchema = z.enum([
+export const ListTasksForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type ListTasksType = z.infer<typeof ListTasksType$zodSchema>;
+export type ListTasksForbiddenType = z.infer<
+  typeof ListTasksForbiddenType$zodSchema
+>;
 
-export const ListTasksCode$zodSchema = z.enum([
+export const ListTasksForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type ListTasksCode = z.infer<typeof ListTasksCode$zodSchema>;
+export type ListTasksForbiddenCode = z.infer<
+  typeof ListTasksForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type ListTasksForbiddenResponseBody = {
-  status_code: ListTasksStatusCode;
-  type: ListTasksType;
-  code: ListTasksCode;
+  status_code: ListTasksForbiddenStatusCode;
+  type: ListTasksForbiddenType;
+  code: ListTasksForbiddenCode;
   message: string;
 };
 
@@ -144,44 +149,72 @@ export const ListTasksForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: ListTasksCode$zodSchema,
+  code: ListTasksForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: ListTasksStatusCode$zodSchema,
-  type: ListTasksType$zodSchema,
+  status_code: ListTasksForbiddenStatusCode$zodSchema,
+  type: ListTasksForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type ListTasksResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  PaginatedTasks?: PaginatedTasks | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListTasksForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListTasksUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const ListTasksStatusCode400$zodSchema = z.literal(400);
+
+export type ListTasksStatusCode400 = z.infer<
+  typeof ListTasksStatusCode400$zodSchema
+>;
+
+export const ListTasksBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type ListTasksBadRequestType = z.infer<
+  typeof ListTasksBadRequestType$zodSchema
+>;
+
+export const ListTasksCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type ListTasksCodeMissingClientID = z.infer<
+  typeof ListTasksCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type ListTasksBadRequestResponseBody = {
+  status_code: ListTasksStatusCode400;
+  type: ListTasksBadRequestType;
+  code: ListTasksCodeMissingClientID;
+  message: string;
 };
 
+export const ListTasksBadRequestResponseBody$zodSchema: z.ZodType<
+  ListTasksBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: ListTasksCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: ListTasksStatusCode400$zodSchema,
+  type: ListTasksBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type ListTasksResponse =
+  | ListTasksBadRequestResponseBody
+  | AuthError
+  | ListTasksForbiddenResponseBody
+  | RateLimit
+  | PaginatedTasks
+  | ListTasksUnprocessableEntityResponseBody;
+
 export const ListTasksResponse$zodSchema: z.ZodType<
   ListTasksResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  PaginatedTasks: PaginatedTasks$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListTasksForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListTasksUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  z.lazy(() => ListTasksBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => ListTasksForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  PaginatedTasks$zodSchema,
+  z.lazy(() => ListTasksUnprocessableEntityResponseBody$zodSchema),
+]);