@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/deleteuserop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { DeleteResponse, DeleteResponse$zodSchema } from "./deleteresponse.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
@@ -10,22 +11,15 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type DeleteUserRequest = { id: string; xClientId: string };
 
-export const DeleteUserRequest$zodSchema: z.ZodType<
-  DeleteUserRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  xClientId: z.string(),
-});
+export const DeleteUserRequest$zodSchema: z.ZodType<DeleteUserRequest> = z
+  .object({
+    id: z.string(),
+    xClientId: z.string(),
+  });
 
 export type DeleteUserPath2 = string | number;
 
-export const DeleteUserPath2$zodSchema: z.ZodType<
-  DeleteUserPath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const DeleteUserPath2$zodSchema: z.ZodType<DeleteUserPath2> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -36,32 +30,28 @@ export type DeleteUserIssue2 = {
   message?: string | undefined;
 };
 
-export const DeleteUserIssue2$zodSchema: z.ZodType<
-  DeleteUserIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const DeleteUserIssue2$zodSchema: z.ZodType<DeleteUserIssue2> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type DeleteUserError2 = {
   issues: Array<DeleteUserIssue2>;
   name: string;
 };
 
-export const DeleteUserError2$zodSchema: z.ZodType<
-  DeleteUserError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => DeleteUserIssue2$zodSchema)),
-  name: z.string(),
-});
+export const DeleteUserError2$zodSchema: z.ZodType<DeleteUserError2> = z.object(
+  {
+    issues: z.array(z.lazy(() => DeleteUserIssue2$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type DeleteUserResponseBody2 = {
   success: boolean;
@@ -69,9 +59,7 @@ export type DeleteUserResponseBody2 = {
 };
 
 export const DeleteUserResponseBody2$zodSchema: z.ZodType<
-  DeleteUserResponseBody2,
-  z.ZodTypeDef,
-  unknown
+  DeleteUserResponseBody2
 > = z.object({
   error: z.lazy(() => DeleteUserError2$zodSchema),
   success: z.boolean(),
@@ -79,11 +67,7 @@ export const DeleteUserResponseBody2$zodSchema: z.ZodType<
 
 export type DeleteUserPath1 = string | number;
 
-export const DeleteUserPath1$zodSchema: z.ZodType<
-  DeleteUserPath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const DeleteUserPath1$zodSchema: z.ZodType<DeleteUserPath1> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -94,32 +78,28 @@ export type DeleteUserIssue1 = {
   message?: string | undefined;
 };
 
-export const DeleteUserIssue1$zodSchema: z.ZodType<
-  DeleteUserIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const DeleteUserIssue1$zodSchema: z.ZodType<DeleteUserIssue1> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type DeleteUserError1 = {
   issues: Array<DeleteUserIssue1>;
   name: string;
 };
 
-export const DeleteUserError1$zodSchema: z.ZodType<
-  DeleteUserError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => DeleteUserIssue1$zodSchema)),
-  name: z.string(),
-});
+export const DeleteUserError1$zodSchema: z.ZodType<DeleteUserError1> = z.object(
+  {
+    issues: z.array(z.lazy(() => DeleteUserIssue1$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type DeleteUserResponseBody1 = {
   success: boolean;
@@ -127,9 +107,7 @@ export type DeleteUserResponseBody1 = {
 };
 
 export const DeleteUserResponseBody1$zodSchema: z.ZodType<
-  DeleteUserResponseBody1,
-  z.ZodTypeDef,
-  unknown
+  DeleteUserResponseBody1
 > = z.object({
   error: z.lazy(() => DeleteUserError1$zodSchema),
   success: z.boolean(),
@@ -143,36 +121,43 @@ export type DeleteUserResponseBody =
   | DeleteUserResponseBody2;
 
 export const DeleteUserResponseBody$zodSchema: z.ZodType<
-  DeleteUserResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DeleteUserResponseBody
 > = z.union([
   z.lazy(() => DeleteUserResponseBody1$zodSchema),
   z.lazy(() => DeleteUserResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
+export const DeleteUserForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type DeleteUserForbiddenStatusCode = ClosedEnum<
+  typeof DeleteUserForbiddenStatusCode
+>;
+
 export const DeleteUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type DeleteUserForbiddenStatusCode = z.infer<
-  typeof DeleteUserForbiddenStatusCode$zodSchema
+export const DeleteUserForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type DeleteUserForbiddenType = ClosedEnum<
+  typeof DeleteUserForbiddenType
 >;
 
 export const DeleteUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DeleteUserForbiddenType = z.infer<
-  typeof DeleteUserForbiddenType$zodSchema
+export const DeleteUserForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type DeleteUserForbiddenCode = ClosedEnum<
+  typeof DeleteUserForbiddenCode
 >;
 
 export const DeleteUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DeleteUserForbiddenCode = z.infer<
-  typeof DeleteUserForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -184,9 +169,7 @@ export type DeleteUserForbiddenResponseBody = {
 };
 
 export const DeleteUserForbiddenResponseBody$zodSchema: z.ZodType<
-  DeleteUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DeleteUserForbiddenResponseBody
 > = z.object({
   code: DeleteUserForbiddenCode$zodSchema,
   message: z.string(),
@@ -194,28 +177,37 @@ export const DeleteUserForbiddenResponseBody$zodSchema: z.ZodType<
   type: DeleteUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const DeleteUserStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type DeleteUserStatusCode400 = ClosedEnum<
+  typeof DeleteUserStatusCode400
+>;
+
 export const DeleteUserStatusCode400$zodSchema = z.literal(400);
 
-export type DeleteUserStatusCode400 = z.infer<
-  typeof DeleteUserStatusCode400$zodSchema
+export const DeleteUserBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type DeleteUserBadRequestType = ClosedEnum<
+  typeof DeleteUserBadRequestType
 >;
 
 export const DeleteUserBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type DeleteUserBadRequestType = z.infer<
-  typeof DeleteUserBadRequestType$zodSchema
+export const DeleteUserCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type DeleteUserCodeMissingClientID = ClosedEnum<
+  typeof DeleteUserCodeMissingClientID
 >;
 
 export const DeleteUserCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type DeleteUserCodeMissingClientID = z.infer<
-  typeof DeleteUserCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -227,9 +219,7 @@ export type DeleteUserBadRequestResponseBody = {
 };
 
 export const DeleteUserBadRequestResponseBody$zodSchema: z.ZodType<
-  DeleteUserBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DeleteUserBadRequestResponseBody
 > = z.object({
   code: DeleteUserCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -247,19 +237,16 @@ export type DeleteUserResponse =
   | DeleteUserResponseBody1
   | DeleteUserResponseBody2;
 
-export const DeleteUserResponse$zodSchema: z.ZodType<
-  DeleteUserResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => DeleteUserBadRequestResponseBody$zodSchema),
-  AuthError$zodSchema,
-  z.lazy(() => DeleteUserForbiddenResponseBody$zodSchema),
-  NotFound$zodSchema,
-  RateLimit$zodSchema,
-  DeleteResponse$zodSchema,
-  z.union([
-    z.lazy(() => DeleteUserResponseBody1$zodSchema),
-    z.lazy(() => DeleteUserResponseBody2$zodSchema),
-  ]),
-]);
+export const DeleteUserResponse$zodSchema: z.ZodType<DeleteUserResponse> = z
+  .union([
+    z.lazy(() => DeleteUserBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => DeleteUserForbiddenResponseBody$zodSchema),
+    NotFound$zodSchema,
+    RateLimit$zodSchema,
+    DeleteResponse$zodSchema,
+    z.union([
+      z.lazy(() => DeleteUserResponseBody1$zodSchema),
+      z.lazy(() => DeleteUserResponseBody2$zodSchema),
+    ]),
+  ]);

package/src/models/downloadfilecontentop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { FileContent, FileContent$zodSchema } from "./filecontent.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -10,9 +11,7 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 export type DownloadFileContentRequest = { id: string; xClientId: string };
 
 export const DownloadFileContentRequest$zodSchema: z.ZodType<
-  DownloadFileContentRequest,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentRequest
 > = z.object({
   id: z.string(),
   xClientId: z.string(),
@@ -21,9 +20,7 @@ export const DownloadFileContentRequest$zodSchema: z.ZodType<
 export type DownloadFileContentPath = string | number;
 
 export const DownloadFileContentPath$zodSchema: z.ZodType<
-  DownloadFileContentPath,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentPath
 > = z.union([
   z.string(),
   z.number(),
@@ -36,9 +33,7 @@ export type DownloadFileContentIssue = {
 };
 
 export const DownloadFileContentIssue$zodSchema: z.ZodType<
-  DownloadFileContentIssue,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentIssue
 > = z.object({
   code: z.string(),
   message: z.string().optional(),
@@ -54,9 +49,7 @@ export type DownloadFileContentError = {
 };
 
 export const DownloadFileContentError$zodSchema: z.ZodType<
-  DownloadFileContentError,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentError
 > = z.object({
   issues: z.array(z.lazy(() => DownloadFileContentIssue$zodSchema)),
   name: z.string(),
@@ -71,11 +64,7 @@ export type DownloadFileContentUnprocessableEntityResponseBody = {
 };
 
 export const DownloadFileContentUnprocessableEntityResponseBody$zodSchema:
-  z.ZodType<
-    DownloadFileContentUnprocessableEntityResponseBody,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
+  z.ZodType<DownloadFileContentUnprocessableEntityResponseBody> = z.object({
     error: z.lazy(() => DownloadFileContentError$zodSchema),
     success: z.boolean(),
   }).describe("Invalid id error");
@@ -86,35 +75,42 @@ export const DownloadFileContentUnprocessableEntityResponseBody$zodSchema:
 export type DownloadFileContentNotFoundResponseBody = { message: string };
 
 export const DownloadFileContentNotFoundResponseBody$zodSchema: z.ZodType<
-  DownloadFileContentNotFoundResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentNotFoundResponseBody
 > = z.object({
   message: z.string(),
 }).describe("File not found");
 
+export const DownloadFileContentForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type DownloadFileContentForbiddenStatusCode = ClosedEnum<
+  typeof DownloadFileContentForbiddenStatusCode
+>;
+
 export const DownloadFileContentForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type DownloadFileContentForbiddenStatusCode = z.infer<
-  typeof DownloadFileContentForbiddenStatusCode$zodSchema
+export const DownloadFileContentForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type DownloadFileContentForbiddenType = ClosedEnum<
+  typeof DownloadFileContentForbiddenType
 >;
 
 export const DownloadFileContentForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DownloadFileContentForbiddenType = z.infer<
-  typeof DownloadFileContentForbiddenType$zodSchema
+export const DownloadFileContentForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type DownloadFileContentForbiddenCode = ClosedEnum<
+  typeof DownloadFileContentForbiddenCode
 >;
 
 export const DownloadFileContentForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DownloadFileContentForbiddenCode = z.infer<
-  typeof DownloadFileContentForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -126,9 +122,7 @@ export type DownloadFileContentForbiddenResponseBody = {
 };
 
 export const DownloadFileContentForbiddenResponseBody$zodSchema: z.ZodType<
-  DownloadFileContentForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentForbiddenResponseBody
 > = z.object({
   code: DownloadFileContentForbiddenCode$zodSchema,
   message: z.string(),
@@ -136,28 +130,37 @@ export const DownloadFileContentForbiddenResponseBody$zodSchema: z.ZodType<
   type: DownloadFileContentForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const DownloadFileContentStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type DownloadFileContentStatusCode400 = ClosedEnum<
+  typeof DownloadFileContentStatusCode400
+>;
+
 export const DownloadFileContentStatusCode400$zodSchema = z.literal(400);
 
-export type DownloadFileContentStatusCode400 = z.infer<
-  typeof DownloadFileContentStatusCode400$zodSchema
+export const DownloadFileContentBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type DownloadFileContentBadRequestType = ClosedEnum<
+  typeof DownloadFileContentBadRequestType
 >;
 
 export const DownloadFileContentBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type DownloadFileContentBadRequestType = z.infer<
-  typeof DownloadFileContentBadRequestType$zodSchema
+export const DownloadFileContentCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type DownloadFileContentCodeMissingClientID = ClosedEnum<
+  typeof DownloadFileContentCodeMissingClientID
 >;
 
 export const DownloadFileContentCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type DownloadFileContentCodeMissingClientID = z.infer<
-  typeof DownloadFileContentCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -169,9 +172,7 @@ export type DownloadFileContentBadRequestResponseBody = {
 };
 
 export const DownloadFileContentBadRequestResponseBody$zodSchema: z.ZodType<
-  DownloadFileContentBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentBadRequestResponseBody
 > = z.object({
   code: DownloadFileContentCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -189,9 +190,7 @@ export type DownloadFileContentResponse =
   | DownloadFileContentNotFoundResponseBody;
 
 export const DownloadFileContentResponse$zodSchema: z.ZodType<
-  DownloadFileContentResponse,
-  z.ZodTypeDef,
-  unknown
+  DownloadFileContentResponse
 > = z.union([
   z.lazy(() => DownloadFileContentBadRequestResponseBody$zodSchema),
   AuthError$zodSchema,

package/src/models/errors/sdkvalidationerror.ts

@@ -37,61 +37,6 @@ export class SDKValidationError extends Error {
   }
 }
 
-export function formatZodError(err: z.ZodError, level = 0): string {
-  let pre = "  ".repeat(level);
-  pre = level > 0 ? `│${pre}` : pre;
-  pre += " ".repeat(level);
-
-  let message = "";
-  const append = (str: string) => (message += `\n${pre}${str}`);
-
-  const len = err.issues.length;
-  const headline = len === 1 ? `${len} issue found` : `${len} issues found`;
-
-  if (len) {
-    append(`┌ ${headline}:`);
-  }
-
-  for (const issue of err.issues) {
-    let path = issue.path.join(".");
-    path = path ? `<root>.${path}` : "<root>";
-    append(`│ • [${path}]: ${issue.message} (${issue.code})`);
-    switch (issue.code) {
-      case "invalid_literal":
-      case "invalid_type": {
-        append(`│     Want: ${issue.expected}`);
-        append(`│      Got: ${issue.received}`);
-        break;
-      }
-      case "unrecognized_keys": {
-        append(`│     Keys: ${issue.keys.join(", ")}`);
-        break;
-      }
-      case "invalid_enum_value": {
-        append(`│     Allowed: ${issue.options.join(", ")}`);
-        append(`│         Got: ${issue.received}`);
-        break;
-      }
-      case "invalid_union_discriminator": {
-        append(`│     Allowed: ${issue.options.join(", ")}`);
-        break;
-      }
-      case "invalid_union": {
-        const len = issue.unionErrors.length;
-        append(
-          `│   ✖︎ Attemped to deserialize into one of ${len} union members:`,
-        );
-        issue.unionErrors.forEach((err, i) => {
-          append(`│   ✖︎ Member ${i + 1} of ${len}`);
-          append(`${formatZodError(err, level + 1)}`);
-        });
-      }
-    }
-  }
-
-  if (err.issues.length) {
-    append(`└─*`);
-  }
-
-  return message.slice(1);
+export function formatZodError(err: z.ZodError): string {
+  return z.prettifyError(err);
 }

package/src/models/file.ts

@@ -19,18 +19,29 @@ export type FileT = {
   labelIds: Array<string> | null;
 };
 
-export const FileT$zodSchema: z.ZodType<FileT, z.ZodTypeDef, unknown> = z
-  .object({
-    createdAt: z.string().datetime({ offset: true }),
-    createdById: z.string().nullable(),
-    documentDate: z.string().datetime({ offset: true }).nullable(),
-    folderId: z.string().nullable(),
-    id: z.string(),
-    labelIds: z.array(z.string()).nullable(),
-    mimetype: z.string(),
-    name: z.string(),
-    size: z.number(),
-    taskId: z.string().nullable(),
-    updatedAt: z.string().datetime({ offset: true }),
-    workspaceId: z.string(),
-  });
+export const FileT$zodSchema: z.ZodType<FileT> = z.object({
+  createdAt: z.iso.datetime({ offset: true }).describe(
+    "The date and time of the creation for the file. ISO-8601 format (YYYY-MM-DDTHH:MM:SSZ).",
+  ),
+  createdById: z.string().nullable().describe("The ID of the creator"),
+  documentDate: z.iso.datetime({ offset: true }).nullable().describe(
+    "The date of the document (not the upload date)",
+  ),
+  folderId: z.string().nullable().describe(
+    "The ID of the folder this file was uploaded to.",
+  ),
+  id: z.string().describe("The ID of the file"),
+  labelIds: z.array(z.string()).nullable().describe(
+    "The IDs of the assigned labels",
+  ),
+  mimetype: z.string().describe("The mime type of the file"),
+  name: z.string().describe("The name of the file"),
+  size: z.number().describe("The size of the file in bytes"),
+  taskId: z.string().nullable().describe(
+    "The ID of the task this file was uploaded to.",
+  ),
+  updatedAt: z.iso.datetime({ offset: true }).describe(
+    "The date and time of the last update for the file. ISO-8601 format (YYYY-MM-DDTHH:MM:SSZ).",
+  ),
+  workspaceId: z.string().describe("The ID of the workspace"),
+});

package/src/models/filecontent.ts

@@ -6,11 +6,7 @@ import * as z from "zod";
 
 export type FileContent = { url: string; expiresIn: number };
 
-export const FileContent$zodSchema: z.ZodType<
-  FileContent,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  expiresIn: z.number().int(),
-  url: z.string(),
+export const FileContent$zodSchema: z.ZodType<FileContent> = z.object({
+  expiresIn: z.int().describe("Seconds until the URL expires"),
+  url: z.string().describe("A temporary presigned URL to download the file"),
 });

package/src/models/filecreate.ts

@@ -3,15 +3,14 @@
  */
 
 import * as z from "zod";
+import * as b64$ from "../lib/base64.js";
 
 export type FileCreateFile = { fileName: string; content: Uint8Array | string };
 
-export const FileCreateFile$zodSchema: z.ZodType<
-  FileCreateFile,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  content: z.string().base64(),
+export const FileCreateFile$zodSchema: z.ZodType<FileCreateFile> = z.object({
+  content: z.string().describe("Base64-encoded binary content").transform(
+    b64$.bytesFromBase64,
+  ),
   fileName: z.string(),
 });
 
@@ -24,15 +23,17 @@ export type FileCreate = {
   taskId?: string | undefined;
 };
 
-export const FileCreate$zodSchema: z.ZodType<
-  FileCreate,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  file: z.lazy(() => FileCreateFile$zodSchema),
-  folderId: z.string().optional(),
-  labelIds: z.array(z.string()).optional(),
-  name: z.string().optional(),
-  taskId: z.string().optional(),
-  workspaceId: z.string(),
+export const FileCreate$zodSchema: z.ZodType<FileCreate> = z.object({
+  file: z.lazy(() => FileCreateFile$zodSchema).describe("The file to upload"),
+  folderId: z.string().optional().describe(
+    "The ID of the folder to upload the file to",
+  ),
+  labelIds: z.array(z.string()).optional().describe(
+    "The IDs of the labels to add to the file",
+  ),
+  name: z.string().optional().describe("The name of the file"),
+  taskId: z.string().optional().describe(
+    "The ID of the task to upload this file to.",
+  ),
+  workspaceId: z.string().describe("The ID of the workspace"),
 });