@steuerboard/mcp 0.3.0 → 0.3.4

package/src/models/createworkspaceop.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 { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Workspace, Workspace$zodSchema } from "./workspace.js";
 import {
@@ -88,31 +87,35 @@ export const CreateWorkspaceUnprocessableEntityResponseBody$zodSchema:
     success: z.boolean(),
   }).describe("The validation error(s)");
 
-export const CreateWorkspaceStatusCode$zodSchema = z.literal(403);
+export const CreateWorkspaceForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type CreateWorkspaceStatusCode = z.infer<
-  typeof CreateWorkspaceStatusCode$zodSchema
+export type CreateWorkspaceForbiddenStatusCode = z.infer<
+  typeof CreateWorkspaceForbiddenStatusCode$zodSchema
 >;
 
-export const CreateWorkspaceType$zodSchema = z.enum([
+export const CreateWorkspaceForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateWorkspaceType = z.infer<typeof CreateWorkspaceType$zodSchema>;
+export type CreateWorkspaceForbiddenType = z.infer<
+  typeof CreateWorkspaceForbiddenType$zodSchema
+>;
 
-export const CreateWorkspaceCode$zodSchema = z.enum([
+export const CreateWorkspaceForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateWorkspaceCode = z.infer<typeof CreateWorkspaceCode$zodSchema>;
+export type CreateWorkspaceForbiddenCode = z.infer<
+  typeof CreateWorkspaceForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type CreateWorkspaceForbiddenResponseBody = {
-  status_code: CreateWorkspaceStatusCode;
-  type: CreateWorkspaceType;
-  code: CreateWorkspaceCode;
+  status_code: CreateWorkspaceForbiddenStatusCode;
+  type: CreateWorkspaceForbiddenType;
+  code: CreateWorkspaceForbiddenCode;
   message: string;
 };
 
@@ -121,44 +124,72 @@ export const CreateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: CreateWorkspaceCode$zodSchema,
+  code: CreateWorkspaceForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: CreateWorkspaceStatusCode$zodSchema,
-  type: CreateWorkspaceType$zodSchema,
+  status_code: CreateWorkspaceForbiddenStatusCode$zodSchema,
+  type: CreateWorkspaceForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type CreateWorkspaceResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Workspace?: Workspace | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | CreateWorkspaceForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | CreateWorkspaceUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const CreateWorkspaceStatusCode400$zodSchema = z.literal(400);
+
+export type CreateWorkspaceStatusCode400 = z.infer<
+  typeof CreateWorkspaceStatusCode400$zodSchema
+>;
+
+export const CreateWorkspaceBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type CreateWorkspaceBadRequestType = z.infer<
+  typeof CreateWorkspaceBadRequestType$zodSchema
+>;
+
+export const CreateWorkspaceCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type CreateWorkspaceCodeMissingClientID = z.infer<
+  typeof CreateWorkspaceCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type CreateWorkspaceBadRequestResponseBody = {
+  status_code: CreateWorkspaceStatusCode400;
+  type: CreateWorkspaceBadRequestType;
+  code: CreateWorkspaceCodeMissingClientID;
+  message: string;
 };
 
+export const CreateWorkspaceBadRequestResponseBody$zodSchema: z.ZodType<
+  CreateWorkspaceBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: CreateWorkspaceCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: CreateWorkspaceStatusCode400$zodSchema,
+  type: CreateWorkspaceBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type CreateWorkspaceResponse =
+  | Workspace
+  | CreateWorkspaceBadRequestResponseBody
+  | AuthError
+  | CreateWorkspaceForbiddenResponseBody
+  | RateLimit
+  | CreateWorkspaceUnprocessableEntityResponseBody;
+
 export const CreateWorkspaceResponse$zodSchema: z.ZodType<
   CreateWorkspaceResponse,
   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(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    CreateWorkspaceForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    CreateWorkspaceUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  Workspace$zodSchema,
+  z.lazy(() => CreateWorkspaceBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => CreateWorkspaceForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  z.lazy(() => CreateWorkspaceUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/deleteaccountantuserop.ts

@@ -62,30 +62,23 @@ export const DeleteAccountantUserResponseBody$zodSchema: z.ZodType<
   type: DeleteAccountantUserType$zodSchema,
 }).describe("Missing scope");
 
-export type DeleteAccountantUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  DeleteResponse?: DeleteResponse | undefined;
-  auth_error?: AuthError | undefined;
-  object?: DeleteAccountantUserResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  conflict?: Conflict | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type DeleteAccountantUserResponse =
+  | AuthError
+  | DeleteAccountantUserResponseBody
+  | NotFound
+  | Conflict
+  | RateLimit
+  | DeleteResponse;
 
 export const DeleteAccountantUserResponse$zodSchema: z.ZodType<
   DeleteAccountantUserResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  DeleteResponse: DeleteResponse$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  conflict: Conflict$zodSchema.optional(),
-  not_found: NotFound$zodSchema.optional(),
-  object: z.lazy(() => DeleteAccountantUserResponseBody$zodSchema).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  AuthError$zodSchema,
+  z.lazy(() => DeleteAccountantUserResponseBody$zodSchema),
+  NotFound$zodSchema,
+  Conflict$zodSchema,
+  RateLimit$zodSchema,
+  DeleteResponse$zodSchema,
+]);

package/src/models/deletecollectsubmissionop.ts

@@ -0,0 +1,130 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
+import {
+  DeleteCollectSubmissionResponse,
+  DeleteCollectSubmissionResponse$zodSchema,
+} from "./deletecollectsubmissionresponse.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+
+export type DeleteCollectSubmissionRequest = {
+  token: string;
+  submissionId: string;
+};
+
+export const DeleteCollectSubmissionRequest$zodSchema: z.ZodType<
+  DeleteCollectSubmissionRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  submissionId: z.string(),
+  token: z.string(),
+});
+
+export const DeleteCollectSubmissionNotFoundStatusCode$zodSchema = z.literal(
+  404,
+);
+
+export type DeleteCollectSubmissionNotFoundStatusCode = z.infer<
+  typeof DeleteCollectSubmissionNotFoundStatusCode$zodSchema
+>;
+
+export const DeleteCollectSubmissionNotFoundType$zodSchema = z.enum([
+  "not_found",
+]);
+
+export type DeleteCollectSubmissionNotFoundType = z.infer<
+  typeof DeleteCollectSubmissionNotFoundType$zodSchema
+>;
+
+export const DeleteCollectSubmissionNotFoundCode$zodSchema = z.enum([
+  "collect_token_not_found",
+]);
+
+export type DeleteCollectSubmissionNotFoundCode = z.infer<
+  typeof DeleteCollectSubmissionNotFoundCode$zodSchema
+>;
+
+/**
+ * Collect session not found. The token may be invalid or revoked.
+ */
+export type DeleteCollectSubmissionNotFoundResponseBody = {
+  status_code: DeleteCollectSubmissionNotFoundStatusCode;
+  type: DeleteCollectSubmissionNotFoundType;
+  code: DeleteCollectSubmissionNotFoundCode;
+  message: string;
+};
+
+export const DeleteCollectSubmissionNotFoundResponseBody$zodSchema: z.ZodType<
+  DeleteCollectSubmissionNotFoundResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DeleteCollectSubmissionNotFoundCode$zodSchema,
+  message: z.string(),
+  status_code: DeleteCollectSubmissionNotFoundStatusCode$zodSchema,
+  type: DeleteCollectSubmissionNotFoundType$zodSchema,
+}).describe("Collect session not found. The token may be invalid or revoked.");
+
+export const DeleteCollectSubmissionStatusCode400$zodSchema = z.literal(400);
+
+export type DeleteCollectSubmissionStatusCode400 = z.infer<
+  typeof DeleteCollectSubmissionStatusCode400$zodSchema
+>;
+
+export const DeleteCollectSubmissionBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type DeleteCollectSubmissionBadRequestType = z.infer<
+  typeof DeleteCollectSubmissionBadRequestType$zodSchema
+>;
+
+export const CodeInvalidInput$zodSchema = z.enum([
+  "invalid_input",
+]);
+
+export type CodeInvalidInput = z.infer<typeof CodeInvalidInput$zodSchema>;
+
+/**
+ * Cannot delete a non-pending submission
+ */
+export type DeleteCollectSubmissionBadRequestResponseBody = {
+  status_code: DeleteCollectSubmissionStatusCode400;
+  type: DeleteCollectSubmissionBadRequestType;
+  code: CodeInvalidInput;
+  message: string;
+};
+
+export const DeleteCollectSubmissionBadRequestResponseBody$zodSchema: z.ZodType<
+  DeleteCollectSubmissionBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: CodeInvalidInput$zodSchema,
+  message: z.string(),
+  status_code: DeleteCollectSubmissionStatusCode400$zodSchema,
+  type: DeleteCollectSubmissionBadRequestType$zodSchema,
+}).describe("Cannot delete a non-pending submission");
+
+export type DeleteCollectSubmissionResponseResponse =
+  | DeleteCollectSubmissionBadRequestResponseBody
+  | DeleteCollectSubmissionNotFoundResponseBody
+  | BadRequest
+  | RateLimit
+  | DeleteCollectSubmissionResponse;
+
+export const DeleteCollectSubmissionResponseResponse$zodSchema: z.ZodType<
+  DeleteCollectSubmissionResponseResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => DeleteCollectSubmissionBadRequestResponseBody$zodSchema),
+  z.lazy(() => DeleteCollectSubmissionNotFoundResponseBody$zodSchema),
+  BadRequest$zodSchema,
+  RateLimit$zodSchema,
+  DeleteCollectSubmissionResponse$zodSchema,
+]);

package/src/models/deletecollectsubmissionresponse.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type DeleteCollectSubmissionResponse = { deleted: boolean };
+
+export const DeleteCollectSubmissionResponse$zodSchema: z.ZodType<
+  DeleteCollectSubmissionResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  deleted: z.boolean(),
+});

package/src/models/deletefileop.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 { DeleteResponse, DeleteResponse$zodSchema } from "./deleteresponse.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -78,31 +77,35 @@ export const DeleteFileUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("Invalid id error");
 
-export const DeleteFileStatusCode$zodSchema = z.literal(403);
+export const DeleteFileForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type DeleteFileStatusCode = z.infer<
-  typeof DeleteFileStatusCode$zodSchema
+export type DeleteFileForbiddenStatusCode = z.infer<
+  typeof DeleteFileForbiddenStatusCode$zodSchema
 >;
 
-export const DeleteFileType$zodSchema = z.enum([
+export const DeleteFileForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DeleteFileType = z.infer<typeof DeleteFileType$zodSchema>;
+export type DeleteFileForbiddenType = z.infer<
+  typeof DeleteFileForbiddenType$zodSchema
+>;
 
-export const DeleteFileCode$zodSchema = z.enum([
+export const DeleteFileForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DeleteFileCode = z.infer<typeof DeleteFileCode$zodSchema>;
+export type DeleteFileForbiddenCode = z.infer<
+  typeof DeleteFileForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type DeleteFileForbiddenResponseBody = {
-  status_code: DeleteFileStatusCode;
-  type: DeleteFileType;
-  code: DeleteFileCode;
+  status_code: DeleteFileForbiddenStatusCode;
+  type: DeleteFileForbiddenType;
+  code: DeleteFileForbiddenCode;
   message: string;
 };
 
@@ -111,46 +114,74 @@ export const DeleteFileForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: DeleteFileCode$zodSchema,
+  code: DeleteFileForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: DeleteFileStatusCode$zodSchema,
-  type: DeleteFileType$zodSchema,
+  status_code: DeleteFileForbiddenStatusCode$zodSchema,
+  type: DeleteFileForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type DeleteFileResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  DeleteResponse?: DeleteResponse | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | DeleteFileForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | DeleteFileUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const DeleteFileStatusCode400$zodSchema = z.literal(400);
+
+export type DeleteFileStatusCode400 = z.infer<
+  typeof DeleteFileStatusCode400$zodSchema
+>;
+
+export const DeleteFileBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type DeleteFileBadRequestType = z.infer<
+  typeof DeleteFileBadRequestType$zodSchema
+>;
+
+export const DeleteFileCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type DeleteFileCodeMissingClientID = z.infer<
+  typeof DeleteFileCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type DeleteFileBadRequestResponseBody = {
+  status_code: DeleteFileStatusCode400;
+  type: DeleteFileBadRequestType;
+  code: DeleteFileCodeMissingClientID;
+  message: string;
 };
 
+export const DeleteFileBadRequestResponseBody$zodSchema: z.ZodType<
+  DeleteFileBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DeleteFileCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: DeleteFileStatusCode400$zodSchema,
+  type: DeleteFileBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type DeleteFileResponse =
+  | DeleteFileBadRequestResponseBody
+  | AuthError
+  | DeleteFileForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | DeleteResponse
+  | DeleteFileUnprocessableEntityResponseBody;
+
 export const DeleteFileResponse$zodSchema: z.ZodType<
   DeleteFileResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  DeleteResponse: DeleteResponse$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    DeleteFileForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    DeleteFileUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  z.lazy(() => DeleteFileBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => DeleteFileForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  DeleteResponse$zodSchema,
+  z.lazy(() => DeleteFileUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/deletetaskop.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";
@@ -78,31 +77,35 @@ export const DeleteTaskUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("Invalid id error");
 
-export const DeleteTaskStatusCode$zodSchema = z.literal(403);
+export const DeleteTaskForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type DeleteTaskStatusCode = z.infer<
-  typeof DeleteTaskStatusCode$zodSchema
+export type DeleteTaskForbiddenStatusCode = z.infer<
+  typeof DeleteTaskForbiddenStatusCode$zodSchema
 >;
 
-export const DeleteTaskType$zodSchema = z.enum([
+export const DeleteTaskForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DeleteTaskType = z.infer<typeof DeleteTaskType$zodSchema>;
+export type DeleteTaskForbiddenType = z.infer<
+  typeof DeleteTaskForbiddenType$zodSchema
+>;
 
-export const DeleteTaskCode$zodSchema = z.enum([
+export const DeleteTaskForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DeleteTaskCode = z.infer<typeof DeleteTaskCode$zodSchema>;
+export type DeleteTaskForbiddenCode = z.infer<
+  typeof DeleteTaskForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type DeleteTaskForbiddenResponseBody = {
-  status_code: DeleteTaskStatusCode;
-  type: DeleteTaskType;
-  code: DeleteTaskCode;
+  status_code: DeleteTaskForbiddenStatusCode;
+  type: DeleteTaskForbiddenType;
+  code: DeleteTaskForbiddenCode;
   message: string;
 };
 
@@ -111,46 +114,74 @@ export const DeleteTaskForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: DeleteTaskCode$zodSchema,
+  code: DeleteTaskForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: DeleteTaskStatusCode$zodSchema,
-  type: DeleteTaskType$zodSchema,
+  status_code: DeleteTaskForbiddenStatusCode$zodSchema,
+  type: DeleteTaskForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type DeleteTaskResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Task?: Task | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | DeleteTaskForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | DeleteTaskUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const DeleteTaskStatusCode400$zodSchema = z.literal(400);
+
+export type DeleteTaskStatusCode400 = z.infer<
+  typeof DeleteTaskStatusCode400$zodSchema
+>;
+
+export const DeleteTaskBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type DeleteTaskBadRequestType = z.infer<
+  typeof DeleteTaskBadRequestType$zodSchema
+>;
+
+export const DeleteTaskCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type DeleteTaskCodeMissingClientID = z.infer<
+  typeof DeleteTaskCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type DeleteTaskBadRequestResponseBody = {
+  status_code: DeleteTaskStatusCode400;
+  type: DeleteTaskBadRequestType;
+  code: DeleteTaskCodeMissingClientID;
+  message: string;
 };
 
+export const DeleteTaskBadRequestResponseBody$zodSchema: z.ZodType<
+  DeleteTaskBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DeleteTaskCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: DeleteTaskStatusCode400$zodSchema,
+  type: DeleteTaskBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type DeleteTaskResponse =
+  | Task
+  | DeleteTaskBadRequestResponseBody
+  | AuthError
+  | DeleteTaskForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | DeleteTaskUnprocessableEntityResponseBody;
+
 export const DeleteTaskResponse$zodSchema: z.ZodType<
   DeleteTaskResponse,
   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(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    DeleteTaskForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    DeleteTaskUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  Task$zodSchema,
+  z.lazy(() => DeleteTaskBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => DeleteTaskForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() => DeleteTaskUnprocessableEntityResponseBody$zodSchema),
+]);