@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/updateclientop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { Client, Client$zodSchema } from "./client.js";
 import { ClientUpdate, ClientUpdate$zodSchema } from "./clientupdate.js";
@@ -11,25 +12,19 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type UpdateClientRequest = { id: string; ClientUpdate: ClientUpdate };
 
-export const UpdateClientRequest$zodSchema: z.ZodType<
-  UpdateClientRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  ClientUpdate: ClientUpdate$zodSchema,
-  id: z.string(),
-});
+export const UpdateClientRequest$zodSchema: z.ZodType<UpdateClientRequest> = z
+  .object({
+    ClientUpdate: ClientUpdate$zodSchema.describe("Client update"),
+    id: z.string(),
+  });
 
 export type UpdateClientPath2 = string | number;
 
-export const UpdateClientPath2$zodSchema: z.ZodType<
-  UpdateClientPath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const UpdateClientPath2$zodSchema: z.ZodType<UpdateClientPath2> = z
+  .union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type UpdateClientIssue2 = {
   code: string;
@@ -37,32 +32,26 @@ export type UpdateClientIssue2 = {
   message?: string | undefined;
 };
 
-export const UpdateClientIssue2$zodSchema: z.ZodType<
-  UpdateClientIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateClientIssue2$zodSchema: z.ZodType<UpdateClientIssue2> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type UpdateClientError2 = {
   issues: Array<UpdateClientIssue2>;
   name: string;
 };
 
-export const UpdateClientError2$zodSchema: z.ZodType<
-  UpdateClientError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateClientIssue2$zodSchema)),
-  name: z.string(),
-});
+export const UpdateClientError2$zodSchema: z.ZodType<UpdateClientError2> = z
+  .object({
+    issues: z.array(z.lazy(() => UpdateClientIssue2$zodSchema)),
+    name: z.string(),
+  });
 
 export type UpdateClientResponseBody2 = {
   success: boolean;
@@ -70,9 +59,7 @@ export type UpdateClientResponseBody2 = {
 };
 
 export const UpdateClientResponseBody2$zodSchema: z.ZodType<
-  UpdateClientResponseBody2,
-  z.ZodTypeDef,
-  unknown
+  UpdateClientResponseBody2
 > = z.object({
   error: z.lazy(() => UpdateClientError2$zodSchema),
   success: z.boolean(),
@@ -80,14 +67,11 @@ export const UpdateClientResponseBody2$zodSchema: z.ZodType<
 
 export type UpdateClientPath1 = string | number;
 
-export const UpdateClientPath1$zodSchema: z.ZodType<
-  UpdateClientPath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const UpdateClientPath1$zodSchema: z.ZodType<UpdateClientPath1> = z
+  .union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type UpdateClientIssue1 = {
   code: string;
@@ -95,32 +79,26 @@ export type UpdateClientIssue1 = {
   message?: string | undefined;
 };
 
-export const UpdateClientIssue1$zodSchema: z.ZodType<
-  UpdateClientIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const UpdateClientIssue1$zodSchema: z.ZodType<UpdateClientIssue1> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type UpdateClientError1 = {
   issues: Array<UpdateClientIssue1>;
   name: string;
 };
 
-export const UpdateClientError1$zodSchema: z.ZodType<
-  UpdateClientError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => UpdateClientIssue1$zodSchema)),
-  name: z.string(),
-});
+export const UpdateClientError1$zodSchema: z.ZodType<UpdateClientError1> = z
+  .object({
+    issues: z.array(z.lazy(() => UpdateClientIssue1$zodSchema)),
+    name: z.string(),
+  });
 
 export type UpdateClientResponseBody1 = {
   success: boolean;
@@ -128,9 +106,7 @@ export type UpdateClientResponseBody1 = {
 };
 
 export const UpdateClientResponseBody1$zodSchema: z.ZodType<
-  UpdateClientResponseBody1,
-  z.ZodTypeDef,
-  unknown
+  UpdateClientResponseBody1
 > = z.object({
   error: z.lazy(() => UpdateClientError1$zodSchema),
   success: z.boolean(),
@@ -144,32 +120,37 @@ export type UpdateClientResponseBody =
   | UpdateClientResponseBody2;
 
 export const UpdateClientResponseBody$zodSchema: z.ZodType<
-  UpdateClientResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateClientResponseBody
 > = z.union([
   z.lazy(() => UpdateClientResponseBody1$zodSchema),
   z.lazy(() => UpdateClientResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
+export const UpdateClientStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateClientStatusCode = ClosedEnum<typeof UpdateClientStatusCode>;
+
 export const UpdateClientStatusCode$zodSchema = z.literal(403);
 
-export type UpdateClientStatusCode = z.infer<
-  typeof UpdateClientStatusCode$zodSchema
->;
+export const UpdateClientType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateClientType = ClosedEnum<typeof UpdateClientType>;
 
 export const UpdateClientType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateClientType = z.infer<typeof UpdateClientType$zodSchema>;
+export const UpdateClientCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateClientCode = ClosedEnum<typeof UpdateClientCode>;
 
 export const UpdateClientCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateClientCode = z.infer<typeof UpdateClientCode$zodSchema>;
-
 /**
  * Missing scope
  */
@@ -181,9 +162,7 @@ export type UpdateClientForbiddenResponseBody = {
 };
 
 export const UpdateClientForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateClientForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateClientForbiddenResponseBody
 > = z.object({
   code: UpdateClientCode$zodSchema,
   message: z.string(),
@@ -191,33 +170,24 @@ export const UpdateClientForbiddenResponseBody$zodSchema: z.ZodType<
   type: UpdateClientType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateClientResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Client?: Client | undefined;
-  auth_error?: AuthError | undefined;
-  object?: UpdateClientForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: UpdateClientResponseBody1 | UpdateClientResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type UpdateClientResponse =
+  | Client
+  | AuthError
+  | UpdateClientForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | UpdateClientResponseBody1
+  | UpdateClientResponseBody2;
 
-export const UpdateClientResponse$zodSchema: z.ZodType<
-  UpdateClientResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  Client: Client$zodSchema.optional(),
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  not_found: NotFound$zodSchema.optional(),
-  object: z.lazy(() => UpdateClientForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
-    z.lazy(() => UpdateClientResponseBody1$zodSchema),
-    z.lazy(() => UpdateClientResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+export const UpdateClientResponse$zodSchema: z.ZodType<UpdateClientResponse> = z
+  .union([
+    Client$zodSchema,
+    AuthError$zodSchema,
+    z.lazy(() => UpdateClientForbiddenResponseBody$zodSchema),
+    NotFound$zodSchema,
+    RateLimit$zodSchema,
+    z.union([
+      z.lazy(() => UpdateClientResponseBody1$zodSchema),
+      z.lazy(() => UpdateClientResponseBody2$zodSchema),
+    ]),
+  ]);

package/src/models/updatefileop.ts

@@ -3,8 +3,8 @@
  */
 
 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 { FileT, FileT$zodSchema } from "./file.js";
 import { FileUpdate, FileUpdate$zodSchema } from "./fileupdate.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -15,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(),
 ]);
@@ -42,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;
@@ -75,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(),
@@ -85,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(),
 ]);
@@ -100,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;
@@ -133,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(),
@@ -149,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),
@@ -163,92 +138,131 @@ 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 UpdateFileStatusCode$zodSchema = z.literal(403);
+export const UpdateFileForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateFileForbiddenStatusCode = ClosedEnum<
+  typeof UpdateFileForbiddenStatusCode
+>;
+
+export const UpdateFileForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateFileStatusCode = z.infer<
-  typeof UpdateFileStatusCode$zodSchema
+export const UpdateFileForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateFileForbiddenType = ClosedEnum<
+  typeof UpdateFileForbiddenType
 >;
 
-export const UpdateFileType$zodSchema = z.enum([
+export const UpdateFileForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateFileType = z.infer<typeof UpdateFileType$zodSchema>;
+export const UpdateFileForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateFileForbiddenCode = ClosedEnum<
+  typeof UpdateFileForbiddenCode
+>;
 
-export const UpdateFileCode$zodSchema = z.enum([
+export const UpdateFileForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateFileCode = z.infer<typeof UpdateFileCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type UpdateFileForbiddenResponseBody = {
-  status_code: UpdateFileStatusCode;
-  type: UpdateFileType;
-  code: UpdateFileCode;
+  status_code: UpdateFileForbiddenStatusCode;
+  type: UpdateFileForbiddenType;
+  code: UpdateFileForbiddenCode;
   message: string;
 };
 
 export const UpdateFileForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateFileForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateFileForbiddenResponseBody
 > = z.object({
-  code: UpdateFileCode$zodSchema,
+  code: UpdateFileForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: UpdateFileStatusCode$zodSchema,
-  type: UpdateFileType$zodSchema,
+  status_code: UpdateFileForbiddenStatusCode$zodSchema,
+  type: UpdateFileForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateFileResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  FileT?: FileT | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | UpdateFileForbiddenResponseBody
-    | undefined;
-  fourHundredAndFourApplicationJsonObject?:
-    | UpdateFileNotFoundResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonOneOf?:
-    | UpdateFileResponseBody1
-    | UpdateFileResponseBody2
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const UpdateFileStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type UpdateFileStatusCode400 = ClosedEnum<
+  typeof UpdateFileStatusCode400
+>;
+
+export const UpdateFileStatusCode400$zodSchema = z.literal(400);
+
+export const UpdateFileBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type UpdateFileBadRequestType = ClosedEnum<
+  typeof UpdateFileBadRequestType
+>;
+
+export const UpdateFileBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const UpdateFileCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type UpdateFileCodeMissingClientID = ClosedEnum<
+  typeof UpdateFileCodeMissingClientID
+>;
+
+export const UpdateFileCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type UpdateFileBadRequestResponseBody = {
+  status_code: UpdateFileStatusCode400;
+  type: UpdateFileBadRequestType;
+  code: UpdateFileCodeMissingClientID;
+  message: string;
 };
 
-export const UpdateFileResponse$zodSchema: z.ZodType<
-  UpdateFileResponse,
-  z.ZodTypeDef,
-  unknown
+export const UpdateFileBadRequestResponseBody$zodSchema: z.ZodType<
+  UpdateFileBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  FileT: FileT$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndFourApplicationJsonObject: z.lazy(() =>
-    UpdateFileNotFoundResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    UpdateFileForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonOneOf: z.union([
-    z.lazy(() => UpdateFileResponseBody1$zodSchema),
-    z.lazy(() => UpdateFileResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: UpdateFileCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: UpdateFileStatusCode400$zodSchema,
+  type: UpdateFileBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type UpdateFileResponse =
+  | FileT
+  | UpdateFileBadRequestResponseBody
+  | AuthError
+  | UpdateFileForbiddenResponseBody
+  | RateLimit
+  | UpdateFileNotFoundResponseBody
+  | UpdateFileResponseBody1
+  | UpdateFileResponseBody2;
+
+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),
+    ]),
+  ]);