@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/updatefileop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { FileT, FileT$zodSchema } from "./file.js";
 import { FileUpdate, FileUpdate$zodSchema } from "./fileupdate.js";
@@ -14,23 +15,16 @@ export type UpdateFileRequest = {
   FileUpdate: FileUpdate;
 };
 
-export const UpdateFileRequest$zodSchema: z.ZodType<
-  UpdateFileRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  FileUpdate: FileUpdate$zodSchema,
-  id: z.string(),
-  xClientId: z.string(),
-});
+export const UpdateFileRequest$zodSchema: z.ZodType<UpdateFileRequest> = z
+  .object({
+    FileUpdate: FileUpdate$zodSchema.describe("File update"),
+    id: z.string(),
+    xClientId: z.string(),
+  });
 
 export type UpdateFilePath2 = string | number;
 
-export const UpdateFilePath2$zodSchema: z.ZodType<
-  UpdateFilePath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const UpdateFilePath2$zodSchema: z.ZodType<UpdateFilePath2> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -41,32 +35,28 @@ export type UpdateFileIssue2 = {
   message?: string | undefined;
 };
 
-export const UpdateFileIssue2$zodSchema: z.ZodType<
-  UpdateFileIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateFileIssue2$zodSchema: z.ZodType<UpdateFileIssue2> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type UpdateFileError2 = {
   issues: Array<UpdateFileIssue2>;
   name: string;
 };
 
-export const UpdateFileError2$zodSchema: z.ZodType<
-  UpdateFileError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateFileIssue2$zodSchema)),
-  name: z.string(),
-});
+export const UpdateFileError2$zodSchema: z.ZodType<UpdateFileError2> = z.object(
+  {
+    issues: z.array(z.lazy(() => UpdateFileIssue2$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type UpdateFileResponseBody2 = {
   success: boolean;
@@ -74,9 +64,7 @@ export type UpdateFileResponseBody2 = {
 };
 
 export const UpdateFileResponseBody2$zodSchema: z.ZodType<
-  UpdateFileResponseBody2,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileResponseBody2
 > = z.object({
   error: z.lazy(() => UpdateFileError2$zodSchema),
   success: z.boolean(),
@@ -84,11 +72,7 @@ export const UpdateFileResponseBody2$zodSchema: z.ZodType<
 
 export type UpdateFilePath1 = string | number;
 
-export const UpdateFilePath1$zodSchema: z.ZodType<
-  UpdateFilePath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const UpdateFilePath1$zodSchema: z.ZodType<UpdateFilePath1> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -99,32 +83,28 @@ export type UpdateFileIssue1 = {
   message?: string | undefined;
 };
 
-export const UpdateFileIssue1$zodSchema: z.ZodType<
-  UpdateFileIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateFileIssue1$zodSchema: z.ZodType<UpdateFileIssue1> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type UpdateFileError1 = {
   issues: Array<UpdateFileIssue1>;
   name: string;
 };
 
-export const UpdateFileError1$zodSchema: z.ZodType<
-  UpdateFileError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateFileIssue1$zodSchema)),
-  name: z.string(),
-});
+export const UpdateFileError1$zodSchema: z.ZodType<UpdateFileError1> = z.object(
+  {
+    issues: z.array(z.lazy(() => UpdateFileIssue1$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type UpdateFileResponseBody1 = {
   success: boolean;
@@ -132,9 +112,7 @@ export type UpdateFileResponseBody1 = {
 };
 
 export const UpdateFileResponseBody1$zodSchema: z.ZodType<
-  UpdateFileResponseBody1,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileResponseBody1
 > = z.object({
   error: z.lazy(() => UpdateFileError1$zodSchema),
   success: z.boolean(),
@@ -148,9 +126,7 @@ export type UpdateFileResponseBody =
   | UpdateFileResponseBody2;
 
 export const UpdateFileResponseBody$zodSchema: z.ZodType<
-  UpdateFileResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileResponseBody
 > = z.union([
   z.lazy(() => UpdateFileResponseBody1$zodSchema),
   z.lazy(() => UpdateFileResponseBody2$zodSchema),
@@ -162,35 +138,42 @@ export const UpdateFileResponseBody$zodSchema: z.ZodType<
 export type UpdateFileNotFoundResponseBody = { message: string };
 
 export const UpdateFileNotFoundResponseBody$zodSchema: z.ZodType<
-  UpdateFileNotFoundResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileNotFoundResponseBody
 > = z.object({
   message: z.string(),
 }).describe("File not found");
 
+export const UpdateFileForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateFileForbiddenStatusCode = ClosedEnum<
+  typeof UpdateFileForbiddenStatusCode
+>;
+
 export const UpdateFileForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateFileForbiddenStatusCode = z.infer<
-  typeof UpdateFileForbiddenStatusCode$zodSchema
+export const UpdateFileForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateFileForbiddenType = ClosedEnum<
+  typeof UpdateFileForbiddenType
 >;
 
 export const UpdateFileForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateFileForbiddenType = z.infer<
-  typeof UpdateFileForbiddenType$zodSchema
+export const UpdateFileForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateFileForbiddenCode = ClosedEnum<
+  typeof UpdateFileForbiddenCode
 >;
 
 export const UpdateFileForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateFileForbiddenCode = z.infer<
-  typeof UpdateFileForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -202,9 +185,7 @@ export type UpdateFileForbiddenResponseBody = {
 };
 
 export const UpdateFileForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateFileForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileForbiddenResponseBody
 > = z.object({
   code: UpdateFileForbiddenCode$zodSchema,
   message: z.string(),
@@ -212,28 +193,37 @@ export const UpdateFileForbiddenResponseBody$zodSchema: z.ZodType<
   type: UpdateFileForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const UpdateFileStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type UpdateFileStatusCode400 = ClosedEnum<
+  typeof UpdateFileStatusCode400
+>;
+
 export const UpdateFileStatusCode400$zodSchema = z.literal(400);
 
-export type UpdateFileStatusCode400 = z.infer<
-  typeof UpdateFileStatusCode400$zodSchema
+export const UpdateFileBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type UpdateFileBadRequestType = ClosedEnum<
+  typeof UpdateFileBadRequestType
 >;
 
 export const UpdateFileBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type UpdateFileBadRequestType = z.infer<
-  typeof UpdateFileBadRequestType$zodSchema
+export const UpdateFileCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type UpdateFileCodeMissingClientID = ClosedEnum<
+  typeof UpdateFileCodeMissingClientID
 >;
 
 export const UpdateFileCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type UpdateFileCodeMissingClientID = z.infer<
-  typeof UpdateFileCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -245,9 +235,7 @@ export type UpdateFileBadRequestResponseBody = {
 };
 
 export const UpdateFileBadRequestResponseBody$zodSchema: z.ZodType<
-  UpdateFileBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileBadRequestResponseBody
 > = z.object({
   code: UpdateFileCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -265,19 +253,16 @@ export type UpdateFileResponse =
   | UpdateFileResponseBody1
   | UpdateFileResponseBody2;
 
-export const UpdateFileResponse$zodSchema: z.ZodType<
-  UpdateFileResponse,
-  z.ZodTypeDef,
-  unknown
-> = 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),
-  ]),
-]);
+export const UpdateFileResponse$zodSchema: z.ZodType<UpdateFileResponse> = 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),
+    ]),
+  ]);

package/src/models/updatetaskop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -15,23 +16,16 @@ export type UpdateTaskRequest = {
   TaskUpdate: TaskUpdate;
 };
 
-export const UpdateTaskRequest$zodSchema: z.ZodType<
-  UpdateTaskRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  TaskUpdate: TaskUpdate$zodSchema,
-  id: z.string(),
-  xClientId: z.string(),
-});
+export const UpdateTaskRequest$zodSchema: z.ZodType<UpdateTaskRequest> = z
+  .object({
+    TaskUpdate: TaskUpdate$zodSchema.describe("Task update"),
+    id: z.string(),
+    xClientId: z.string(),
+  });
 
 export type UpdateTaskPath2 = string | number;
 
-export const UpdateTaskPath2$zodSchema: z.ZodType<
-  UpdateTaskPath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const UpdateTaskPath2$zodSchema: z.ZodType<UpdateTaskPath2> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -42,32 +36,28 @@ export type UpdateTaskIssue2 = {
   message?: string | undefined;
 };
 
-export const UpdateTaskIssue2$zodSchema: z.ZodType<
-  UpdateTaskIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateTaskIssue2$zodSchema: z.ZodType<UpdateTaskIssue2> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type UpdateTaskError2 = {
   issues: Array<UpdateTaskIssue2>;
   name: string;
 };
 
-export const UpdateTaskError2$zodSchema: z.ZodType<
-  UpdateTaskError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateTaskIssue2$zodSchema)),
-  name: z.string(),
-});
+export const UpdateTaskError2$zodSchema: z.ZodType<UpdateTaskError2> = z.object(
+  {
+    issues: z.array(z.lazy(() => UpdateTaskIssue2$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type UpdateTaskResponseBody2 = {
   success: boolean;
@@ -75,9 +65,7 @@ export type UpdateTaskResponseBody2 = {
 };
 
 export const UpdateTaskResponseBody2$zodSchema: z.ZodType<
-  UpdateTaskResponseBody2,
-  z.ZodTypeDef,
-  unknown
+  UpdateTaskResponseBody2
 > = z.object({
   error: z.lazy(() => UpdateTaskError2$zodSchema),
   success: z.boolean(),
@@ -85,11 +73,7 @@ export const UpdateTaskResponseBody2$zodSchema: z.ZodType<
 
 export type UpdateTaskPath1 = string | number;
 
-export const UpdateTaskPath1$zodSchema: z.ZodType<
-  UpdateTaskPath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const UpdateTaskPath1$zodSchema: z.ZodType<UpdateTaskPath1> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -100,32 +84,28 @@ export type UpdateTaskIssue1 = {
   message?: string | undefined;
 };
 
-export const UpdateTaskIssue1$zodSchema: z.ZodType<
-  UpdateTaskIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateTaskIssue1$zodSchema: z.ZodType<UpdateTaskIssue1> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type UpdateTaskError1 = {
   issues: Array<UpdateTaskIssue1>;
   name: string;
 };
 
-export const UpdateTaskError1$zodSchema: z.ZodType<
-  UpdateTaskError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateTaskIssue1$zodSchema)),
-  name: z.string(),
-});
+export const UpdateTaskError1$zodSchema: z.ZodType<UpdateTaskError1> = z.object(
+  {
+    issues: z.array(z.lazy(() => UpdateTaskIssue1$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type UpdateTaskResponseBody1 = {
   success: boolean;
@@ -133,9 +113,7 @@ export type UpdateTaskResponseBody1 = {
 };
 
 export const UpdateTaskResponseBody1$zodSchema: z.ZodType<
-  UpdateTaskResponseBody1,
-  z.ZodTypeDef,
-  unknown
+  UpdateTaskResponseBody1
 > = z.object({
   error: z.lazy(() => UpdateTaskError1$zodSchema),
   success: z.boolean(),
@@ -149,36 +127,43 @@ export type UpdateTaskResponseBody =
   | UpdateTaskResponseBody2;
 
 export const UpdateTaskResponseBody$zodSchema: z.ZodType<
-  UpdateTaskResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateTaskResponseBody
 > = z.union([
   z.lazy(() => UpdateTaskResponseBody1$zodSchema),
   z.lazy(() => UpdateTaskResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
+export const UpdateTaskForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateTaskForbiddenStatusCode = ClosedEnum<
+  typeof UpdateTaskForbiddenStatusCode
+>;
+
 export const UpdateTaskForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateTaskForbiddenStatusCode = z.infer<
-  typeof UpdateTaskForbiddenStatusCode$zodSchema
+export const UpdateTaskForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateTaskForbiddenType = ClosedEnum<
+  typeof UpdateTaskForbiddenType
 >;
 
 export const UpdateTaskForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateTaskForbiddenType = z.infer<
-  typeof UpdateTaskForbiddenType$zodSchema
+export const UpdateTaskForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateTaskForbiddenCode = ClosedEnum<
+  typeof UpdateTaskForbiddenCode
 >;
 
 export const UpdateTaskForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateTaskForbiddenCode = z.infer<
-  typeof UpdateTaskForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -190,9 +175,7 @@ export type UpdateTaskForbiddenResponseBody = {
 };
 
 export const UpdateTaskForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateTaskForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateTaskForbiddenResponseBody
 > = z.object({
   code: UpdateTaskForbiddenCode$zodSchema,
   message: z.string(),
@@ -200,28 +183,37 @@ export const UpdateTaskForbiddenResponseBody$zodSchema: z.ZodType<
   type: UpdateTaskForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const UpdateTaskStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type UpdateTaskStatusCode400 = ClosedEnum<
+  typeof UpdateTaskStatusCode400
+>;
+
 export const UpdateTaskStatusCode400$zodSchema = z.literal(400);
 
-export type UpdateTaskStatusCode400 = z.infer<
-  typeof UpdateTaskStatusCode400$zodSchema
+export const UpdateTaskBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type UpdateTaskBadRequestType = ClosedEnum<
+  typeof UpdateTaskBadRequestType
 >;
 
 export const UpdateTaskBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type UpdateTaskBadRequestType = z.infer<
-  typeof UpdateTaskBadRequestType$zodSchema
+export const UpdateTaskCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type UpdateTaskCodeMissingClientID = ClosedEnum<
+  typeof UpdateTaskCodeMissingClientID
 >;
 
 export const UpdateTaskCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type UpdateTaskCodeMissingClientID = z.infer<
-  typeof UpdateTaskCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -233,9 +225,7 @@ export type UpdateTaskBadRequestResponseBody = {
 };
 
 export const UpdateTaskBadRequestResponseBody$zodSchema: z.ZodType<
-  UpdateTaskBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateTaskBadRequestResponseBody
 > = z.object({
   code: UpdateTaskCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -253,19 +243,16 @@ export type UpdateTaskResponse =
   | UpdateTaskResponseBody1
   | UpdateTaskResponseBody2;
 
-export const UpdateTaskResponse$zodSchema: z.ZodType<
-  UpdateTaskResponse,
-  z.ZodTypeDef,
-  unknown
-> = 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),
-  ]),
-]);
+export const UpdateTaskResponse$zodSchema: z.ZodType<UpdateTaskResponse> = 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),
+    ]),
+  ]);