@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/updateuserop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { ClientUser, ClientUser$zodSchema } from "./clientuser.js";
 import {
@@ -18,23 +19,16 @@ export type UpdateUserRequest = {
   ClientUserUpdate: ClientUserUpdate;
 };
 
-export const UpdateUserRequest$zodSchema: z.ZodType<
-  UpdateUserRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  ClientUserUpdate: ClientUserUpdate$zodSchema,
-  id: z.string(),
-  xClientId: z.string(),
-});
+export const UpdateUserRequest$zodSchema: z.ZodType<UpdateUserRequest> = z
+  .object({
+    ClientUserUpdate: ClientUserUpdate$zodSchema.describe("User update"),
+    id: z.string(),
+    xClientId: z.string(),
+  });
 
 export type UpdateUserPath2 = string | number;
 
-export const UpdateUserPath2$zodSchema: z.ZodType<
-  UpdateUserPath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const UpdateUserPath2$zodSchema: z.ZodType<UpdateUserPath2> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -45,32 +39,28 @@ export type UpdateUserIssue2 = {
   message?: string | undefined;
 };
 
-export const UpdateUserIssue2$zodSchema: z.ZodType<
-  UpdateUserIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateUserIssue2$zodSchema: z.ZodType<UpdateUserIssue2> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type UpdateUserError2 = {
   issues: Array<UpdateUserIssue2>;
   name: string;
 };
 
-export const UpdateUserError2$zodSchema: z.ZodType<
-  UpdateUserError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateUserIssue2$zodSchema)),
-  name: z.string(),
-});
+export const UpdateUserError2$zodSchema: z.ZodType<UpdateUserError2> = z.object(
+  {
+    issues: z.array(z.lazy(() => UpdateUserIssue2$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type UpdateUserResponseBody2 = {
   success: boolean;
@@ -78,9 +68,7 @@ export type UpdateUserResponseBody2 = {
 };
 
 export const UpdateUserResponseBody2$zodSchema: z.ZodType<
-  UpdateUserResponseBody2,
-  z.ZodTypeDef,
-  unknown
+  UpdateUserResponseBody2
 > = z.object({
   error: z.lazy(() => UpdateUserError2$zodSchema),
   success: z.boolean(),
@@ -88,11 +76,7 @@ export const UpdateUserResponseBody2$zodSchema: z.ZodType<
 
 export type UpdateUserPath1 = string | number;
 
-export const UpdateUserPath1$zodSchema: z.ZodType<
-  UpdateUserPath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const UpdateUserPath1$zodSchema: z.ZodType<UpdateUserPath1> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -103,32 +87,28 @@ export type UpdateUserIssue1 = {
   message?: string | undefined;
 };
 
-export const UpdateUserIssue1$zodSchema: z.ZodType<
-  UpdateUserIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateUserIssue1$zodSchema: z.ZodType<UpdateUserIssue1> = z.object(
+  {
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  },
+);
 
 export type UpdateUserError1 = {
   issues: Array<UpdateUserIssue1>;
   name: string;
 };
 
-export const UpdateUserError1$zodSchema: z.ZodType<
-  UpdateUserError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateUserIssue1$zodSchema)),
-  name: z.string(),
-});
+export const UpdateUserError1$zodSchema: z.ZodType<UpdateUserError1> = z.object(
+  {
+    issues: z.array(z.lazy(() => UpdateUserIssue1$zodSchema)),
+    name: z.string(),
+  },
+);
 
 export type UpdateUserResponseBody1 = {
   success: boolean;
@@ -136,9 +116,7 @@ export type UpdateUserResponseBody1 = {
 };
 
 export const UpdateUserResponseBody1$zodSchema: z.ZodType<
-  UpdateUserResponseBody1,
-  z.ZodTypeDef,
-  unknown
+  UpdateUserResponseBody1
 > = z.object({
   error: z.lazy(() => UpdateUserError1$zodSchema),
   success: z.boolean(),
@@ -152,36 +130,43 @@ export type UpdateUserResponseBody =
   | UpdateUserResponseBody2;
 
 export const UpdateUserResponseBody$zodSchema: z.ZodType<
-  UpdateUserResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateUserResponseBody
 > = z.union([
   z.lazy(() => UpdateUserResponseBody1$zodSchema),
   z.lazy(() => UpdateUserResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
+export const UpdateUserForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateUserForbiddenStatusCode = ClosedEnum<
+  typeof UpdateUserForbiddenStatusCode
+>;
+
 export const UpdateUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateUserForbiddenStatusCode = z.infer<
-  typeof UpdateUserForbiddenStatusCode$zodSchema
+export const UpdateUserForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateUserForbiddenType = ClosedEnum<
+  typeof UpdateUserForbiddenType
 >;
 
 export const UpdateUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateUserForbiddenType = z.infer<
-  typeof UpdateUserForbiddenType$zodSchema
+export const UpdateUserForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateUserForbiddenCode = ClosedEnum<
+  typeof UpdateUserForbiddenCode
 >;
 
 export const UpdateUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateUserForbiddenCode = z.infer<
-  typeof UpdateUserForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -193,9 +178,7 @@ export type UpdateUserForbiddenResponseBody = {
 };
 
 export const UpdateUserForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateUserForbiddenResponseBody
 > = z.object({
   code: UpdateUserForbiddenCode$zodSchema,
   message: z.string(),
@@ -203,28 +186,37 @@ export const UpdateUserForbiddenResponseBody$zodSchema: z.ZodType<
   type: UpdateUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const UpdateUserStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type UpdateUserStatusCode400 = ClosedEnum<
+  typeof UpdateUserStatusCode400
+>;
+
 export const UpdateUserStatusCode400$zodSchema = z.literal(400);
 
-export type UpdateUserStatusCode400 = z.infer<
-  typeof UpdateUserStatusCode400$zodSchema
+export const UpdateUserBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type UpdateUserBadRequestType = ClosedEnum<
+  typeof UpdateUserBadRequestType
 >;
 
 export const UpdateUserBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type UpdateUserBadRequestType = z.infer<
-  typeof UpdateUserBadRequestType$zodSchema
+export const UpdateUserCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type UpdateUserCodeMissingClientID = ClosedEnum<
+  typeof UpdateUserCodeMissingClientID
 >;
 
 export const UpdateUserCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type UpdateUserCodeMissingClientID = z.infer<
-  typeof UpdateUserCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -236,9 +228,7 @@ export type UpdateUserBadRequestResponseBody = {
 };
 
 export const UpdateUserBadRequestResponseBody$zodSchema: z.ZodType<
-  UpdateUserBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateUserBadRequestResponseBody
 > = z.object({
   code: UpdateUserCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -256,19 +246,16 @@ export type UpdateUserResponse =
   | UpdateUserResponseBody1
   | UpdateUserResponseBody2;
 
-export const UpdateUserResponse$zodSchema: z.ZodType<
-  UpdateUserResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  ClientUser$zodSchema,
-  z.lazy(() => UpdateUserBadRequestResponseBody$zodSchema),
-  AuthError$zodSchema,
-  z.lazy(() => UpdateUserForbiddenResponseBody$zodSchema),
-  NotFound$zodSchema,
-  RateLimit$zodSchema,
-  z.union([
-    z.lazy(() => UpdateUserResponseBody1$zodSchema),
-    z.lazy(() => UpdateUserResponseBody2$zodSchema),
-  ]),
-]);
+export const UpdateUserResponse$zodSchema: z.ZodType<UpdateUserResponse> = z
+  .union([
+    ClientUser$zodSchema,
+    z.lazy(() => UpdateUserBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => UpdateUserForbiddenResponseBody$zodSchema),
+    NotFound$zodSchema,
+    RateLimit$zodSchema,
+    z.union([
+      z.lazy(() => UpdateUserResponseBody1$zodSchema),
+      z.lazy(() => UpdateUserResponseBody2$zodSchema),
+    ]),
+  ]);

package/src/models/updateworkspaceop.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";
@@ -19,25 +20,20 @@ export type UpdateWorkspaceRequest = {
 };
 
 export const UpdateWorkspaceRequest$zodSchema: z.ZodType<
-  UpdateWorkspaceRequest,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceRequest
 > = z.object({
-  WorkspaceUpdate: WorkspaceUpdate$zodSchema,
+  WorkspaceUpdate: WorkspaceUpdate$zodSchema.describe("Workspace update"),
   id: z.string(),
   xClientId: z.string(),
 });
 
 export type UpdateWorkspacePath2 = string | number;
 
-export const UpdateWorkspacePath2$zodSchema: z.ZodType<
-  UpdateWorkspacePath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const UpdateWorkspacePath2$zodSchema: z.ZodType<UpdateWorkspacePath2> = z
+  .union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type UpdateWorkspaceIssue2 = {
   code: string;
@@ -45,32 +41,26 @@ export type UpdateWorkspaceIssue2 = {
   message?: string | undefined;
 };
 
-export const UpdateWorkspaceIssue2$zodSchema: z.ZodType<
-  UpdateWorkspaceIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateWorkspaceIssue2$zodSchema: z.ZodType<UpdateWorkspaceIssue2> =
+  z.object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type UpdateWorkspaceError2 = {
   issues: Array<UpdateWorkspaceIssue2>;
   name: string;
 };
 
-export const UpdateWorkspaceError2$zodSchema: z.ZodType<
-  UpdateWorkspaceError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateWorkspaceIssue2$zodSchema)),
-  name: z.string(),
-});
+export const UpdateWorkspaceError2$zodSchema: z.ZodType<UpdateWorkspaceError2> =
+  z.object({
+    issues: z.array(z.lazy(() => UpdateWorkspaceIssue2$zodSchema)),
+    name: z.string(),
+  });
 
 export type UpdateWorkspaceResponseBody2 = {
   success: boolean;
@@ -78,9 +68,7 @@ export type UpdateWorkspaceResponseBody2 = {
 };
 
 export const UpdateWorkspaceResponseBody2$zodSchema: z.ZodType<
-  UpdateWorkspaceResponseBody2,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceResponseBody2
 > = z.object({
   error: z.lazy(() => UpdateWorkspaceError2$zodSchema),
   success: z.boolean(),
@@ -88,14 +76,11 @@ export const UpdateWorkspaceResponseBody2$zodSchema: z.ZodType<
 
 export type UpdateWorkspacePath1 = string | number;
 
-export const UpdateWorkspacePath1$zodSchema: z.ZodType<
-  UpdateWorkspacePath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const UpdateWorkspacePath1$zodSchema: z.ZodType<UpdateWorkspacePath1> = z
+  .union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type UpdateWorkspaceIssue1 = {
   code: string;
@@ -103,32 +88,26 @@ export type UpdateWorkspaceIssue1 = {
   message?: string | undefined;
 };
 
-export const UpdateWorkspaceIssue1$zodSchema: z.ZodType<
-  UpdateWorkspaceIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateWorkspaceIssue1$zodSchema: z.ZodType<UpdateWorkspaceIssue1> =
+  z.object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type UpdateWorkspaceError1 = {
   issues: Array<UpdateWorkspaceIssue1>;
   name: string;
 };
 
-export const UpdateWorkspaceError1$zodSchema: z.ZodType<
-  UpdateWorkspaceError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateWorkspaceIssue1$zodSchema)),
-  name: z.string(),
-});
+export const UpdateWorkspaceError1$zodSchema: z.ZodType<UpdateWorkspaceError1> =
+  z.object({
+    issues: z.array(z.lazy(() => UpdateWorkspaceIssue1$zodSchema)),
+    name: z.string(),
+  });
 
 export type UpdateWorkspaceResponseBody1 = {
   success: boolean;
@@ -136,9 +115,7 @@ export type UpdateWorkspaceResponseBody1 = {
 };
 
 export const UpdateWorkspaceResponseBody1$zodSchema: z.ZodType<
-  UpdateWorkspaceResponseBody1,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceResponseBody1
 > = z.object({
   error: z.lazy(() => UpdateWorkspaceError1$zodSchema),
   success: z.boolean(),
@@ -152,36 +129,43 @@ export type UpdateWorkspaceResponseBody =
   | UpdateWorkspaceResponseBody2;
 
 export const UpdateWorkspaceResponseBody$zodSchema: z.ZodType<
-  UpdateWorkspaceResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceResponseBody
 > = z.union([
   z.lazy(() => UpdateWorkspaceResponseBody1$zodSchema),
   z.lazy(() => UpdateWorkspaceResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
+export const UpdateWorkspaceForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateWorkspaceForbiddenStatusCode = ClosedEnum<
+  typeof UpdateWorkspaceForbiddenStatusCode
+>;
+
 export const UpdateWorkspaceForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateWorkspaceForbiddenStatusCode = z.infer<
-  typeof UpdateWorkspaceForbiddenStatusCode$zodSchema
+export const UpdateWorkspaceForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateWorkspaceForbiddenType = ClosedEnum<
+  typeof UpdateWorkspaceForbiddenType
 >;
 
 export const UpdateWorkspaceForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateWorkspaceForbiddenType = z.infer<
-  typeof UpdateWorkspaceForbiddenType$zodSchema
+export const UpdateWorkspaceForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateWorkspaceForbiddenCode = ClosedEnum<
+  typeof UpdateWorkspaceForbiddenCode
 >;
 
 export const UpdateWorkspaceForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateWorkspaceForbiddenCode = z.infer<
-  typeof UpdateWorkspaceForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -193,9 +177,7 @@ export type UpdateWorkspaceForbiddenResponseBody = {
 };
 
 export const UpdateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateWorkspaceForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceForbiddenResponseBody
 > = z.object({
   code: UpdateWorkspaceForbiddenCode$zodSchema,
   message: z.string(),
@@ -203,28 +185,37 @@ export const UpdateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
   type: UpdateWorkspaceForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const UpdateWorkspaceStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type UpdateWorkspaceStatusCode400 = ClosedEnum<
+  typeof UpdateWorkspaceStatusCode400
+>;
+
 export const UpdateWorkspaceStatusCode400$zodSchema = z.literal(400);
 
-export type UpdateWorkspaceStatusCode400 = z.infer<
-  typeof UpdateWorkspaceStatusCode400$zodSchema
+export const UpdateWorkspaceBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type UpdateWorkspaceBadRequestType = ClosedEnum<
+  typeof UpdateWorkspaceBadRequestType
 >;
 
 export const UpdateWorkspaceBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type UpdateWorkspaceBadRequestType = z.infer<
-  typeof UpdateWorkspaceBadRequestType$zodSchema
+export const UpdateWorkspaceCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type UpdateWorkspaceCodeMissingClientID = ClosedEnum<
+  typeof UpdateWorkspaceCodeMissingClientID
 >;
 
 export const UpdateWorkspaceCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type UpdateWorkspaceCodeMissingClientID = z.infer<
-  typeof UpdateWorkspaceCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -236,9 +227,7 @@ export type UpdateWorkspaceBadRequestResponseBody = {
 };
 
 export const UpdateWorkspaceBadRequestResponseBody$zodSchema: z.ZodType<
-  UpdateWorkspaceBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceBadRequestResponseBody
 > = z.object({
   code: UpdateWorkspaceCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -257,9 +246,7 @@ export type UpdateWorkspaceResponse =
   | UpdateWorkspaceResponseBody2;
 
 export const UpdateWorkspaceResponse$zodSchema: z.ZodType<
-  UpdateWorkspaceResponse,
-  z.ZodTypeDef,
-  unknown
+  UpdateWorkspaceResponse
 > = z.union([
   Workspace$zodSchema,
   z.lazy(() => UpdateWorkspaceBadRequestResponseBody$zodSchema),

package/src/models/workspace.ts

@@ -13,12 +13,17 @@ export type Workspace = {
   clientId: string;
 };
 
-export const Workspace$zodSchema: z.ZodType<Workspace, z.ZodTypeDef, unknown> =
-  z.object({
-    archivedAt: z.string().datetime({ offset: true }).nullable(),
-    clientId: z.string(),
-    createdAt: z.string().datetime({ offset: true }),
-    id: z.string(),
-    name: z.string(),
-    updatedAt: z.string().datetime({ offset: true }),
-  });
+export const Workspace$zodSchema: z.ZodType<Workspace> = z.object({
+  archivedAt: z.iso.datetime({ offset: true }).nullable().describe(
+    "The date and time the workspace was archived. ISO-8601 format (YYYY-MM-DDTHH:MM:SSZ).",
+  ),
+  clientId: z.string().describe("The ID of the client"),
+  createdAt: z.iso.datetime({ offset: true }).describe(
+    "The date and time of the creation for the workspace. ISO-8601 format (YYYY-MM-DDTHH:MM:SSZ).",
+  ),
+  id: z.string().describe("The ID of the workspace"),
+  name: z.string().describe("The name of the workspace"),
+  updatedAt: z.iso.datetime({ offset: true }).describe(
+    "The date and time of the last update for the workspace. ISO-8601 format (YYYY-MM-DDTHH:MM:SSZ).",
+  ),
+});

package/src/models/workspacecreate.ts

@@ -6,10 +6,6 @@ import * as z from "zod";
 
 export type WorkspaceCreate = { name: string };
 
-export const WorkspaceCreate$zodSchema: z.ZodType<
-  WorkspaceCreate,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  name: z.string(),
+export const WorkspaceCreate$zodSchema: z.ZodType<WorkspaceCreate> = z.object({
+  name: z.string().describe("The name of the workspace"),
 });