@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/deleteuserop.ts

@@ -3,30 +3,23 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 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";
 
 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(),
 ]);
@@ -37,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;
@@ -70,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(),
@@ -80,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(),
 ]);
@@ -95,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;
@@ -128,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(),
@@ -144,82 +121,132 @@ 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 DeleteUserStatusCode$zodSchema = z.literal(403);
+export const DeleteUserForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type DeleteUserForbiddenStatusCode = ClosedEnum<
+  typeof DeleteUserForbiddenStatusCode
+>;
+
+export const DeleteUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type DeleteUserStatusCode = z.infer<
-  typeof DeleteUserStatusCode$zodSchema
+export const DeleteUserForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type DeleteUserForbiddenType = ClosedEnum<
+  typeof DeleteUserForbiddenType
 >;
 
-export const DeleteUserType$zodSchema = z.enum([
+export const DeleteUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DeleteUserType = z.infer<typeof DeleteUserType$zodSchema>;
+export const DeleteUserForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type DeleteUserForbiddenCode = ClosedEnum<
+  typeof DeleteUserForbiddenCode
+>;
 
-export const DeleteUserCode$zodSchema = z.enum([
+export const DeleteUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DeleteUserCode = z.infer<typeof DeleteUserCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type DeleteUserForbiddenResponseBody = {
-  status_code: DeleteUserStatusCode;
-  type: DeleteUserType;
-  code: DeleteUserCode;
+  status_code: DeleteUserForbiddenStatusCode;
+  type: DeleteUserForbiddenType;
+  code: DeleteUserForbiddenCode;
   message: string;
 };
 
 export const DeleteUserForbiddenResponseBody$zodSchema: z.ZodType<
-  DeleteUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DeleteUserForbiddenResponseBody
 > = z.object({
-  code: DeleteUserCode$zodSchema,
+  code: DeleteUserForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: DeleteUserStatusCode$zodSchema,
-  type: DeleteUserType$zodSchema,
+  status_code: DeleteUserForbiddenStatusCode$zodSchema,
+  type: DeleteUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type DeleteUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  DeleteResponse?: DeleteResponse | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: DeleteUserForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: DeleteUserResponseBody1 | DeleteUserResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
+export const DeleteUserStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type DeleteUserStatusCode400 = ClosedEnum<
+  typeof DeleteUserStatusCode400
+>;
+
+export const DeleteUserStatusCode400$zodSchema = z.literal(400);
+
+export const DeleteUserBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type DeleteUserBadRequestType = ClosedEnum<
+  typeof DeleteUserBadRequestType
+>;
+
+export const DeleteUserBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const DeleteUserCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type DeleteUserCodeMissingClientID = ClosedEnum<
+  typeof DeleteUserCodeMissingClientID
+>;
+
+export const DeleteUserCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type DeleteUserBadRequestResponseBody = {
+  status_code: DeleteUserStatusCode400;
+  type: DeleteUserBadRequestType;
+  code: DeleteUserCodeMissingClientID;
+  message: string;
 };
 
-export const DeleteUserResponse$zodSchema: z.ZodType<
-  DeleteUserResponse,
-  z.ZodTypeDef,
-  unknown
+export const DeleteUserBadRequestResponseBody$zodSchema: z.ZodType<
+  DeleteUserBadRequestResponseBody
 > = 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(),
-  not_found: NotFound$zodSchema.optional(),
-  object: z.lazy(() => DeleteUserForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
-    z.lazy(() => DeleteUserResponseBody1$zodSchema),
-    z.lazy(() => DeleteUserResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: DeleteUserCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: DeleteUserStatusCode400$zodSchema,
+  type: DeleteUserBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type DeleteUserResponse =
+  | DeleteUserBadRequestResponseBody
+  | AuthError
+  | DeleteUserForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | DeleteResponse
+  | DeleteUserResponseBody1
+  | DeleteUserResponseBody2;
+
+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

@@ -0,0 +1,202 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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";
+
+export type DownloadFileContentRequest = { id: string; xClientId: string };
+
+export const DownloadFileContentRequest$zodSchema: z.ZodType<
+  DownloadFileContentRequest
+> = z.object({
+  id: z.string(),
+  xClientId: z.string(),
+});
+
+export type DownloadFileContentPath = string | number;
+
+export const DownloadFileContentPath$zodSchema: z.ZodType<
+  DownloadFileContentPath
+> = z.union([
+  z.string(),
+  z.number(),
+]);
+
+export type DownloadFileContentIssue = {
+  code: string;
+  path: Array<string | number>;
+  message?: string | undefined;
+};
+
+export const DownloadFileContentIssue$zodSchema: z.ZodType<
+  DownloadFileContentIssue
+> = z.object({
+  code: z.string(),
+  message: z.string().optional(),
+  path: z.array(z.union([
+    z.string(),
+    z.number(),
+  ])),
+});
+
+export type DownloadFileContentError = {
+  issues: Array<DownloadFileContentIssue>;
+  name: string;
+};
+
+export const DownloadFileContentError$zodSchema: z.ZodType<
+  DownloadFileContentError
+> = z.object({
+  issues: z.array(z.lazy(() => DownloadFileContentIssue$zodSchema)),
+  name: z.string(),
+});
+
+/**
+ * Invalid id error
+ */
+export type DownloadFileContentUnprocessableEntityResponseBody = {
+  success: boolean;
+  error: DownloadFileContentError;
+};
+
+export const DownloadFileContentUnprocessableEntityResponseBody$zodSchema:
+  z.ZodType<DownloadFileContentUnprocessableEntityResponseBody> = z.object({
+    error: z.lazy(() => DownloadFileContentError$zodSchema),
+    success: z.boolean(),
+  }).describe("Invalid id error");
+
+/**
+ * File not found
+ */
+export type DownloadFileContentNotFoundResponseBody = { message: string };
+
+export const DownloadFileContentNotFoundResponseBody$zodSchema: z.ZodType<
+  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 const DownloadFileContentForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type DownloadFileContentForbiddenType = ClosedEnum<
+  typeof DownloadFileContentForbiddenType
+>;
+
+export const DownloadFileContentForbiddenType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export const DownloadFileContentForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type DownloadFileContentForbiddenCode = ClosedEnum<
+  typeof DownloadFileContentForbiddenCode
+>;
+
+export const DownloadFileContentForbiddenCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+/**
+ * Missing scope
+ */
+export type DownloadFileContentForbiddenResponseBody = {
+  status_code: DownloadFileContentForbiddenStatusCode;
+  type: DownloadFileContentForbiddenType;
+  code: DownloadFileContentForbiddenCode;
+  message: string;
+};
+
+export const DownloadFileContentForbiddenResponseBody$zodSchema: z.ZodType<
+  DownloadFileContentForbiddenResponseBody
+> = z.object({
+  code: DownloadFileContentForbiddenCode$zodSchema,
+  message: z.string(),
+  status_code: DownloadFileContentForbiddenStatusCode$zodSchema,
+  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 const DownloadFileContentBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type DownloadFileContentBadRequestType = ClosedEnum<
+  typeof DownloadFileContentBadRequestType
+>;
+
+export const DownloadFileContentBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const DownloadFileContentCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type DownloadFileContentCodeMissingClientID = ClosedEnum<
+  typeof DownloadFileContentCodeMissingClientID
+>;
+
+export const DownloadFileContentCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type DownloadFileContentBadRequestResponseBody = {
+  status_code: DownloadFileContentStatusCode400;
+  type: DownloadFileContentBadRequestType;
+  code: DownloadFileContentCodeMissingClientID;
+  message: string;
+};
+
+export const DownloadFileContentBadRequestResponseBody$zodSchema: z.ZodType<
+  DownloadFileContentBadRequestResponseBody
+> = z.object({
+  code: DownloadFileContentCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: DownloadFileContentStatusCode400$zodSchema,
+  type: DownloadFileContentBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type DownloadFileContentResponse =
+  | DownloadFileContentBadRequestResponseBody
+  | AuthError
+  | DownloadFileContentForbiddenResponseBody
+  | RateLimit
+  | FileContent
+  | DownloadFileContentUnprocessableEntityResponseBody
+  | DownloadFileContentNotFoundResponseBody;
+
+export const DownloadFileContentResponse$zodSchema: z.ZodType<
+  DownloadFileContentResponse
+> = z.union([
+  z.lazy(() => DownloadFileContentBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => DownloadFileContentForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  FileContent$zodSchema,
+  z.lazy(() => DownloadFileContentUnprocessableEntityResponseBody$zodSchema),
+  z.lazy(() => DownloadFileContentNotFoundResponseBody$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

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type FileContent = { url: string; expiresIn: number };
+
+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"),
+});