@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/createtaskop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Task, Task$zodSchema } from "./task.js";
@@ -10,22 +11,15 @@ import { TaskCreate, TaskCreate$zodSchema } from "./taskcreate.js";
 
 export type CreateTaskRequest = { xClientId: string; TaskCreate: TaskCreate };
 
-export const CreateTaskRequest$zodSchema: z.ZodType<
-  CreateTaskRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  TaskCreate: TaskCreate$zodSchema,
-  xClientId: z.string(),
-});
+export const CreateTaskRequest$zodSchema: z.ZodType<CreateTaskRequest> = z
+  .object({
+    TaskCreate: TaskCreate$zodSchema.describe("Task create"),
+    xClientId: z.string(),
+  });
 
 export type CreateTaskPath = string | number;
 
-export const CreateTaskPath$zodSchema: z.ZodType<
-  CreateTaskPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const CreateTaskPath$zodSchema: z.ZodType<CreateTaskPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -36,11 +30,7 @@ export type CreateTaskIssue = {
   message?: string | undefined;
 };
 
-export const CreateTaskIssue$zodSchema: z.ZodType<
-  CreateTaskIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const CreateTaskIssue$zodSchema: z.ZodType<CreateTaskIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -51,11 +41,7 @@ export const CreateTaskIssue$zodSchema: z.ZodType<
 
 export type CreateTaskError = { issues: Array<CreateTaskIssue>; name: string };
 
-export const CreateTaskError$zodSchema: z.ZodType<
-  CreateTaskError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const CreateTaskError$zodSchema: z.ZodType<CreateTaskError> = z.object({
   issues: z.array(z.lazy(() => CreateTaskIssue$zodSchema)),
   name: z.string(),
 });
@@ -69,36 +55,43 @@ export type CreateTaskUnprocessableEntityResponseBody = {
 };
 
 export const CreateTaskUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  CreateTaskUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateTaskUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => CreateTaskError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
+export const CreateTaskForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateTaskForbiddenStatusCode = ClosedEnum<
+  typeof CreateTaskForbiddenStatusCode
+>;
+
 export const CreateTaskForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type CreateTaskForbiddenStatusCode = z.infer<
-  typeof CreateTaskForbiddenStatusCode$zodSchema
+export const CreateTaskForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateTaskForbiddenType = ClosedEnum<
+  typeof CreateTaskForbiddenType
 >;
 
 export const CreateTaskForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateTaskForbiddenType = z.infer<
-  typeof CreateTaskForbiddenType$zodSchema
+export const CreateTaskForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateTaskForbiddenCode = ClosedEnum<
+  typeof CreateTaskForbiddenCode
 >;
 
 export const CreateTaskForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateTaskForbiddenCode = z.infer<
-  typeof CreateTaskForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -110,9 +103,7 @@ export type CreateTaskForbiddenResponseBody = {
 };
 
 export const CreateTaskForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateTaskForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateTaskForbiddenResponseBody
 > = z.object({
   code: CreateTaskForbiddenCode$zodSchema,
   message: z.string(),
@@ -120,28 +111,37 @@ export const CreateTaskForbiddenResponseBody$zodSchema: z.ZodType<
   type: CreateTaskForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const CreateTaskStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type CreateTaskStatusCode400 = ClosedEnum<
+  typeof CreateTaskStatusCode400
+>;
+
 export const CreateTaskStatusCode400$zodSchema = z.literal(400);
 
-export type CreateTaskStatusCode400 = z.infer<
-  typeof CreateTaskStatusCode400$zodSchema
+export const CreateTaskBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateTaskBadRequestType = ClosedEnum<
+  typeof CreateTaskBadRequestType
 >;
 
 export const CreateTaskBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type CreateTaskBadRequestType = z.infer<
-  typeof CreateTaskBadRequestType$zodSchema
+export const CreateTaskCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type CreateTaskCodeMissingClientID = ClosedEnum<
+  typeof CreateTaskCodeMissingClientID
 >;
 
 export const CreateTaskCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type CreateTaskCodeMissingClientID = z.infer<
-  typeof CreateTaskCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -153,9 +153,7 @@ export type CreateTaskBadRequestResponseBody = {
 };
 
 export const CreateTaskBadRequestResponseBody$zodSchema: z.ZodType<
-  CreateTaskBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateTaskBadRequestResponseBody
 > = z.object({
   code: CreateTaskCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -171,15 +169,12 @@ export type CreateTaskResponse =
   | RateLimit
   | CreateTaskUnprocessableEntityResponseBody;
 
-export const CreateTaskResponse$zodSchema: z.ZodType<
-  CreateTaskResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  Task$zodSchema,
-  z.lazy(() => CreateTaskBadRequestResponseBody$zodSchema),
-  AuthError$zodSchema,
-  z.lazy(() => CreateTaskForbiddenResponseBody$zodSchema),
-  RateLimit$zodSchema,
-  z.lazy(() => CreateTaskUnprocessableEntityResponseBody$zodSchema),
-]);
+export const CreateTaskResponse$zodSchema: z.ZodType<CreateTaskResponse> = z
+  .union([
+    Task$zodSchema,
+    z.lazy(() => CreateTaskBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => CreateTaskForbiddenResponseBody$zodSchema),
+    RateLimit$zodSchema,
+    z.lazy(() => CreateTaskUnprocessableEntityResponseBody$zodSchema),
+  ]);

package/src/models/createworkspacememberop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import {
@@ -21,11 +22,11 @@ export type CreateWorkspaceMemberRequest = {
 };
 
 export const CreateWorkspaceMemberRequest$zodSchema: z.ZodType<
-  CreateWorkspaceMemberRequest,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberRequest
 > = z.object({
-  WorkspaceMemberCreate: WorkspaceMemberCreate$zodSchema,
+  WorkspaceMemberCreate: WorkspaceMemberCreate$zodSchema.describe(
+    "Workspace member create",
+  ),
   id: z.string(),
   xClientId: z.string(),
 });
@@ -33,9 +34,7 @@ export const CreateWorkspaceMemberRequest$zodSchema: z.ZodType<
 export type CreateWorkspaceMemberPath = string | number;
 
 export const CreateWorkspaceMemberPath$zodSchema: z.ZodType<
-  CreateWorkspaceMemberPath,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberPath
 > = z.union([
   z.string(),
   z.number(),
@@ -48,9 +47,7 @@ export type CreateWorkspaceMemberIssue = {
 };
 
 export const CreateWorkspaceMemberIssue$zodSchema: z.ZodType<
-  CreateWorkspaceMemberIssue,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberIssue
 > = z.object({
   code: z.string(),
   message: z.string().optional(),
@@ -66,9 +63,7 @@ export type CreateWorkspaceMemberError = {
 };
 
 export const CreateWorkspaceMemberError$zodSchema: z.ZodType<
-  CreateWorkspaceMemberError,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberError
 > = z.object({
   issues: z.array(z.lazy(() => CreateWorkspaceMemberIssue$zodSchema)),
   name: z.string(),
@@ -83,39 +78,44 @@ export type CreateWorkspaceMemberUnprocessableEntityResponseBody = {
 };
 
 export const CreateWorkspaceMemberUnprocessableEntityResponseBody$zodSchema:
-  z.ZodType<
-    CreateWorkspaceMemberUnprocessableEntityResponseBody,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
+  z.ZodType<CreateWorkspaceMemberUnprocessableEntityResponseBody> = z.object({
     error: z.lazy(() => CreateWorkspaceMemberError$zodSchema),
     success: z.boolean(),
   }).describe("The validation error(s)");
 
+export const CreateWorkspaceMemberForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateWorkspaceMemberForbiddenStatusCode = ClosedEnum<
+  typeof CreateWorkspaceMemberForbiddenStatusCode
+>;
+
 export const CreateWorkspaceMemberForbiddenStatusCode$zodSchema = z.literal(
   403,
 );
 
-export type CreateWorkspaceMemberForbiddenStatusCode = z.infer<
-  typeof CreateWorkspaceMemberForbiddenStatusCode$zodSchema
+export const CreateWorkspaceMemberForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateWorkspaceMemberForbiddenType = ClosedEnum<
+  typeof CreateWorkspaceMemberForbiddenType
 >;
 
 export const CreateWorkspaceMemberForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateWorkspaceMemberForbiddenType = z.infer<
-  typeof CreateWorkspaceMemberForbiddenType$zodSchema
+export const CreateWorkspaceMemberForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateWorkspaceMemberForbiddenCode = ClosedEnum<
+  typeof CreateWorkspaceMemberForbiddenCode
 >;
 
 export const CreateWorkspaceMemberForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateWorkspaceMemberForbiddenCode = z.infer<
-  typeof CreateWorkspaceMemberForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -127,9 +127,7 @@ export type CreateWorkspaceMemberForbiddenResponseBody = {
 };
 
 export const CreateWorkspaceMemberForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateWorkspaceMemberForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberForbiddenResponseBody
 > = z.object({
   code: CreateWorkspaceMemberForbiddenCode$zodSchema,
   message: z.string(),
@@ -137,28 +135,37 @@ export const CreateWorkspaceMemberForbiddenResponseBody$zodSchema: z.ZodType<
   type: CreateWorkspaceMemberForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const CreateWorkspaceMemberStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type CreateWorkspaceMemberStatusCode400 = ClosedEnum<
+  typeof CreateWorkspaceMemberStatusCode400
+>;
+
 export const CreateWorkspaceMemberStatusCode400$zodSchema = z.literal(400);
 
-export type CreateWorkspaceMemberStatusCode400 = z.infer<
-  typeof CreateWorkspaceMemberStatusCode400$zodSchema
+export const CreateWorkspaceMemberBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateWorkspaceMemberBadRequestType = ClosedEnum<
+  typeof CreateWorkspaceMemberBadRequestType
 >;
 
 export const CreateWorkspaceMemberBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type CreateWorkspaceMemberBadRequestType = z.infer<
-  typeof CreateWorkspaceMemberBadRequestType$zodSchema
+export const CreateWorkspaceMemberCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type CreateWorkspaceMemberCodeMissingClientID = ClosedEnum<
+  typeof CreateWorkspaceMemberCodeMissingClientID
 >;
 
 export const CreateWorkspaceMemberCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type CreateWorkspaceMemberCodeMissingClientID = z.infer<
-  typeof CreateWorkspaceMemberCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -170,9 +177,7 @@ export type CreateWorkspaceMemberBadRequestResponseBody = {
 };
 
 export const CreateWorkspaceMemberBadRequestResponseBody$zodSchema: z.ZodType<
-  CreateWorkspaceMemberBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberBadRequestResponseBody
 > = z.object({
   code: CreateWorkspaceMemberCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -189,9 +194,7 @@ export type CreateWorkspaceMemberResponse =
   | CreateWorkspaceMemberUnprocessableEntityResponseBody;
 
 export const CreateWorkspaceMemberResponse$zodSchema: z.ZodType<
-  CreateWorkspaceMemberResponse,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberResponse
 > = z.union([
   WorkspaceMember$zodSchema,
   z.lazy(() => CreateWorkspaceMemberBadRequestResponseBody$zodSchema),

package/src/models/createworkspaceop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Workspace, Workspace$zodSchema } from "./workspace.js";
@@ -17,24 +18,19 @@ export type CreateWorkspaceRequest = {
 };
 
 export const CreateWorkspaceRequest$zodSchema: z.ZodType<
-  CreateWorkspaceRequest,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceRequest
 > = z.object({
-  WorkspaceCreate: WorkspaceCreate$zodSchema,
+  WorkspaceCreate: WorkspaceCreate$zodSchema.describe("Workspace create"),
   xClientId: z.string(),
 });
 
 export type CreateWorkspacePath = string | number;
 
-export const CreateWorkspacePath$zodSchema: z.ZodType<
-  CreateWorkspacePath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const CreateWorkspacePath$zodSchema: z.ZodType<CreateWorkspacePath> = z
+  .union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type CreateWorkspaceIssue = {
   code: string;
@@ -42,32 +38,26 @@ export type CreateWorkspaceIssue = {
   message?: string | undefined;
 };
 
-export const CreateWorkspaceIssue$zodSchema: z.ZodType<
-  CreateWorkspaceIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const CreateWorkspaceIssue$zodSchema: z.ZodType<CreateWorkspaceIssue> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type CreateWorkspaceError = {
   issues: Array<CreateWorkspaceIssue>;
   name: string;
 };
 
-export const CreateWorkspaceError$zodSchema: z.ZodType<
-  CreateWorkspaceError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => CreateWorkspaceIssue$zodSchema)),
-  name: z.string(),
-});
+export const CreateWorkspaceError$zodSchema: z.ZodType<CreateWorkspaceError> = z
+  .object({
+    issues: z.array(z.lazy(() => CreateWorkspaceIssue$zodSchema)),
+    name: z.string(),
+  });
 
 /**
  * The validation error(s)
@@ -78,37 +68,42 @@ export type CreateWorkspaceUnprocessableEntityResponseBody = {
 };
 
 export const CreateWorkspaceUnprocessableEntityResponseBody$zodSchema:
-  z.ZodType<
-    CreateWorkspaceUnprocessableEntityResponseBody,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
+  z.ZodType<CreateWorkspaceUnprocessableEntityResponseBody> = z.object({
     error: z.lazy(() => CreateWorkspaceError$zodSchema),
     success: z.boolean(),
   }).describe("The validation error(s)");
 
+export const CreateWorkspaceForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateWorkspaceForbiddenStatusCode = ClosedEnum<
+  typeof CreateWorkspaceForbiddenStatusCode
+>;
+
 export const CreateWorkspaceForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type CreateWorkspaceForbiddenStatusCode = z.infer<
-  typeof CreateWorkspaceForbiddenStatusCode$zodSchema
+export const CreateWorkspaceForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateWorkspaceForbiddenType = ClosedEnum<
+  typeof CreateWorkspaceForbiddenType
 >;
 
 export const CreateWorkspaceForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateWorkspaceForbiddenType = z.infer<
-  typeof CreateWorkspaceForbiddenType$zodSchema
+export const CreateWorkspaceForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateWorkspaceForbiddenCode = ClosedEnum<
+  typeof CreateWorkspaceForbiddenCode
 >;
 
 export const CreateWorkspaceForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateWorkspaceForbiddenCode = z.infer<
-  typeof CreateWorkspaceForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -120,9 +115,7 @@ export type CreateWorkspaceForbiddenResponseBody = {
 };
 
 export const CreateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateWorkspaceForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceForbiddenResponseBody
 > = z.object({
   code: CreateWorkspaceForbiddenCode$zodSchema,
   message: z.string(),
@@ -130,28 +123,37 @@ export const CreateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
   type: CreateWorkspaceForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const CreateWorkspaceStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type CreateWorkspaceStatusCode400 = ClosedEnum<
+  typeof CreateWorkspaceStatusCode400
+>;
+
 export const CreateWorkspaceStatusCode400$zodSchema = z.literal(400);
 
-export type CreateWorkspaceStatusCode400 = z.infer<
-  typeof CreateWorkspaceStatusCode400$zodSchema
+export const CreateWorkspaceBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateWorkspaceBadRequestType = ClosedEnum<
+  typeof CreateWorkspaceBadRequestType
 >;
 
 export const CreateWorkspaceBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type CreateWorkspaceBadRequestType = z.infer<
-  typeof CreateWorkspaceBadRequestType$zodSchema
+export const CreateWorkspaceCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type CreateWorkspaceCodeMissingClientID = ClosedEnum<
+  typeof CreateWorkspaceCodeMissingClientID
 >;
 
 export const CreateWorkspaceCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type CreateWorkspaceCodeMissingClientID = z.infer<
-  typeof CreateWorkspaceCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -163,9 +165,7 @@ export type CreateWorkspaceBadRequestResponseBody = {
 };
 
 export const CreateWorkspaceBadRequestResponseBody$zodSchema: z.ZodType<
-  CreateWorkspaceBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceBadRequestResponseBody
 > = z.object({
   code: CreateWorkspaceCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -182,9 +182,7 @@ export type CreateWorkspaceResponse =
   | CreateWorkspaceUnprocessableEntityResponseBody;
 
 export const CreateWorkspaceResponse$zodSchema: z.ZodType<
-  CreateWorkspaceResponse,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceResponse
 > = z.union([
   Workspace$zodSchema,
   z.lazy(() => CreateWorkspaceBadRequestResponseBody$zodSchema),

package/src/models/deleteaccountantuserop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { Conflict, Conflict$zodSchema } from "./conflict.js";
 import { DeleteResponse, DeleteResponse$zodSchema } from "./deleteresponse.js";
@@ -12,35 +13,42 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 export type DeleteAccountantUserRequest = { id: string };
 
 export const DeleteAccountantUserRequest$zodSchema: z.ZodType<
-  DeleteAccountantUserRequest,
-  z.ZodTypeDef,
-  unknown
+  DeleteAccountantUserRequest
 > = z.object({
   id: z.string(),
 });
 
+export const DeleteAccountantUserStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type DeleteAccountantUserStatusCode = ClosedEnum<
+  typeof DeleteAccountantUserStatusCode
+>;
+
 export const DeleteAccountantUserStatusCode$zodSchema = z.literal(403);
 
-export type DeleteAccountantUserStatusCode = z.infer<
-  typeof DeleteAccountantUserStatusCode$zodSchema
+export const DeleteAccountantUserType = {
+  AuthError: "auth_error",
+} as const;
+export type DeleteAccountantUserType = ClosedEnum<
+  typeof DeleteAccountantUserType
 >;
 
 export const DeleteAccountantUserType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DeleteAccountantUserType = z.infer<
-  typeof DeleteAccountantUserType$zodSchema
+export const DeleteAccountantUserCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type DeleteAccountantUserCode = ClosedEnum<
+  typeof DeleteAccountantUserCode
 >;
 
 export const DeleteAccountantUserCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DeleteAccountantUserCode = z.infer<
-  typeof DeleteAccountantUserCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -52,9 +60,7 @@ export type DeleteAccountantUserResponseBody = {
 };
 
 export const DeleteAccountantUserResponseBody$zodSchema: z.ZodType<
-  DeleteAccountantUserResponseBody,
-  z.ZodTypeDef,
-  unknown
+  DeleteAccountantUserResponseBody
 > = z.object({
   code: DeleteAccountantUserCode$zodSchema,
   message: z.string(),
@@ -71,9 +77,7 @@ export type DeleteAccountantUserResponse =
   | DeleteResponse;
 
 export const DeleteAccountantUserResponse$zodSchema: z.ZodType<
-  DeleteAccountantUserResponse,
-  z.ZodTypeDef,
-  unknown
+  DeleteAccountantUserResponse
 > = z.union([
   AuthError$zodSchema,
   z.lazy(() => DeleteAccountantUserResponseBody$zodSchema),