@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/updateuserop.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 { ClientUser, ClientUser$zodSchema } from "./clientuser.js";
 import {
   ClientUserUpdate,
@@ -19,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(),
 ]);
@@ -46,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;
@@ -79,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(),
@@ -89,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(),
 ]);
@@ -104,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;
@@ -137,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(),
@@ -153,82 +130,132 @@ 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 UpdateUserStatusCode$zodSchema = z.literal(403);
+export const UpdateUserForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type UpdateUserForbiddenStatusCode = ClosedEnum<
+  typeof UpdateUserForbiddenStatusCode
+>;
+
+export const UpdateUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type UpdateUserStatusCode = z.infer<
-  typeof UpdateUserStatusCode$zodSchema
+export const UpdateUserForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type UpdateUserForbiddenType = ClosedEnum<
+  typeof UpdateUserForbiddenType
 >;
 
-export const UpdateUserType$zodSchema = z.enum([
+export const UpdateUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type UpdateUserType = z.infer<typeof UpdateUserType$zodSchema>;
+export const UpdateUserForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type UpdateUserForbiddenCode = ClosedEnum<
+  typeof UpdateUserForbiddenCode
+>;
 
-export const UpdateUserCode$zodSchema = z.enum([
+export const UpdateUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type UpdateUserCode = z.infer<typeof UpdateUserCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type UpdateUserForbiddenResponseBody = {
-  status_code: UpdateUserStatusCode;
-  type: UpdateUserType;
-  code: UpdateUserCode;
+  status_code: UpdateUserForbiddenStatusCode;
+  type: UpdateUserForbiddenType;
+  code: UpdateUserForbiddenCode;
   message: string;
 };
 
 export const UpdateUserForbiddenResponseBody$zodSchema: z.ZodType<
-  UpdateUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  UpdateUserForbiddenResponseBody
 > = z.object({
-  code: UpdateUserCode$zodSchema,
+  code: UpdateUserForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: UpdateUserStatusCode$zodSchema,
-  type: UpdateUserType$zodSchema,
+  status_code: UpdateUserForbiddenStatusCode$zodSchema,
+  type: UpdateUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type UpdateUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  ClientUser?: ClientUser | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: UpdateUserForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: UpdateUserResponseBody1 | UpdateUserResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
+export const UpdateUserStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type UpdateUserStatusCode400 = ClosedEnum<
+  typeof UpdateUserStatusCode400
+>;
+
+export const UpdateUserStatusCode400$zodSchema = z.literal(400);
+
+export const UpdateUserBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type UpdateUserBadRequestType = ClosedEnum<
+  typeof UpdateUserBadRequestType
+>;
+
+export const UpdateUserBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const UpdateUserCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type UpdateUserCodeMissingClientID = ClosedEnum<
+  typeof UpdateUserCodeMissingClientID
+>;
+
+export const UpdateUserCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type UpdateUserBadRequestResponseBody = {
+  status_code: UpdateUserStatusCode400;
+  type: UpdateUserBadRequestType;
+  code: UpdateUserCodeMissingClientID;
+  message: string;
 };
 
-export const UpdateUserResponse$zodSchema: z.ZodType<
-  UpdateUserResponse,
-  z.ZodTypeDef,
-  unknown
+export const UpdateUserBadRequestResponseBody$zodSchema: z.ZodType<
+  UpdateUserBadRequestResponseBody
 > = z.object({
-  ClientUser: ClientUser$zodSchema.optional(),
-  ContentType: z.string(),
-  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(() => UpdateUserForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
-    z.lazy(() => UpdateUserResponseBody1$zodSchema),
-    z.lazy(() => UpdateUserResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: UpdateUserCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: UpdateUserStatusCode400$zodSchema,
+  type: UpdateUserBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type UpdateUserResponse =
+  | ClientUser
+  | UpdateUserBadRequestResponseBody
+  | AuthError
+  | UpdateUserForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | UpdateUserResponseBody1
+  | UpdateUserResponseBody2;
+
+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),
+    ]),
+  ]);