@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/listworkspacesop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import {
   PaginatedWorkspaces,
@@ -16,26 +17,20 @@ export type ListWorkspacesRequest = {
   xClientId: string;
 };
 
-export const ListWorkspacesRequest$zodSchema: z.ZodType<
-  ListWorkspacesRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  cursor: z.string().optional(),
-  limit: z.number().default(20),
-  xClientId: z.string(),
-});
+export const ListWorkspacesRequest$zodSchema: z.ZodType<ListWorkspacesRequest> =
+  z.object({
+    cursor: z.string().optional(),
+    limit: z.number().default(20),
+    xClientId: z.string(),
+  });
 
 export type ListWorkspacesPath = string | number;
 
-export const ListWorkspacesPath$zodSchema: z.ZodType<
-  ListWorkspacesPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const ListWorkspacesPath$zodSchema: z.ZodType<ListWorkspacesPath> = z
+  .union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type ListWorkspacesIssue = {
   code: string;
@@ -43,32 +38,26 @@ export type ListWorkspacesIssue = {
   message?: string | undefined;
 };
 
-export const ListWorkspacesIssue$zodSchema: z.ZodType<
-  ListWorkspacesIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const ListWorkspacesIssue$zodSchema: z.ZodType<ListWorkspacesIssue> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type ListWorkspacesError = {
   issues: Array<ListWorkspacesIssue>;
   name: string;
 };
 
-export const ListWorkspacesError$zodSchema: z.ZodType<
-  ListWorkspacesError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => ListWorkspacesIssue$zodSchema)),
-  name: z.string(),
-});
+export const ListWorkspacesError$zodSchema: z.ZodType<ListWorkspacesError> = z
+  .object({
+    issues: z.array(z.lazy(() => ListWorkspacesIssue$zodSchema)),
+    name: z.string(),
+  });
 
 /**
  * The validation error(s)
@@ -79,36 +68,43 @@ export type ListWorkspacesUnprocessableEntityResponseBody = {
 };
 
 export const ListWorkspacesUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  ListWorkspacesUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListWorkspacesUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => ListWorkspacesError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
+export const ListWorkspacesForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type ListWorkspacesForbiddenStatusCode = ClosedEnum<
+  typeof ListWorkspacesForbiddenStatusCode
+>;
+
 export const ListWorkspacesForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type ListWorkspacesForbiddenStatusCode = z.infer<
-  typeof ListWorkspacesForbiddenStatusCode$zodSchema
+export const ListWorkspacesForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type ListWorkspacesForbiddenType = ClosedEnum<
+  typeof ListWorkspacesForbiddenType
 >;
 
 export const ListWorkspacesForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type ListWorkspacesForbiddenType = z.infer<
-  typeof ListWorkspacesForbiddenType$zodSchema
+export const ListWorkspacesForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type ListWorkspacesForbiddenCode = ClosedEnum<
+  typeof ListWorkspacesForbiddenCode
 >;
 
 export const ListWorkspacesForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type ListWorkspacesForbiddenCode = z.infer<
-  typeof ListWorkspacesForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -120,9 +116,7 @@ export type ListWorkspacesForbiddenResponseBody = {
 };
 
 export const ListWorkspacesForbiddenResponseBody$zodSchema: z.ZodType<
-  ListWorkspacesForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListWorkspacesForbiddenResponseBody
 > = z.object({
   code: ListWorkspacesForbiddenCode$zodSchema,
   message: z.string(),
@@ -130,28 +124,37 @@ export const ListWorkspacesForbiddenResponseBody$zodSchema: z.ZodType<
   type: ListWorkspacesForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const ListWorkspacesStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type ListWorkspacesStatusCode400 = ClosedEnum<
+  typeof ListWorkspacesStatusCode400
+>;
+
 export const ListWorkspacesStatusCode400$zodSchema = z.literal(400);
 
-export type ListWorkspacesStatusCode400 = z.infer<
-  typeof ListWorkspacesStatusCode400$zodSchema
+export const ListWorkspacesBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type ListWorkspacesBadRequestType = ClosedEnum<
+  typeof ListWorkspacesBadRequestType
 >;
 
 export const ListWorkspacesBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type ListWorkspacesBadRequestType = z.infer<
-  typeof ListWorkspacesBadRequestType$zodSchema
+export const ListWorkspacesCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type ListWorkspacesCodeMissingClientID = ClosedEnum<
+  typeof ListWorkspacesCodeMissingClientID
 >;
 
 export const ListWorkspacesCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type ListWorkspacesCodeMissingClientID = z.infer<
-  typeof ListWorkspacesCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -163,9 +166,7 @@ export type ListWorkspacesBadRequestResponseBody = {
 };
 
 export const ListWorkspacesBadRequestResponseBody$zodSchema: z.ZodType<
-  ListWorkspacesBadRequestResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListWorkspacesBadRequestResponseBody
 > = z.object({
   code: ListWorkspacesCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -182,9 +183,7 @@ export type ListWorkspacesResponse =
   | ListWorkspacesUnprocessableEntityResponseBody;
 
 export const ListWorkspacesResponse$zodSchema: z.ZodType<
-  ListWorkspacesResponse,
-  z.ZodTypeDef,
-  unknown
+  ListWorkspacesResponse
 > = z.union([
   z.lazy(() => ListWorkspacesBadRequestResponseBody$zodSchema),
   AuthError$zodSchema,

package/src/models/meop.ts

@@ -3,25 +3,35 @@
  */
 
 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";
 
+export const MeStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type MeStatusCode = ClosedEnum<typeof MeStatusCode>;
+
 export const MeStatusCode$zodSchema = z.literal(403);
 
-export type MeStatusCode = z.infer<typeof MeStatusCode$zodSchema>;
+export const MeType = {
+  AuthError: "auth_error",
+} as const;
+export type MeType = ClosedEnum<typeof MeType>;
 
 export const MeType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type MeType = z.infer<typeof MeType$zodSchema>;
+export const MeCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type MeCode = ClosedEnum<typeof MeCode>;
 
 export const MeCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type MeCode = z.infer<typeof MeCode$zodSchema>;
-
 /**
  * Missing scope
  */
@@ -33,9 +43,7 @@ export type MeForbiddenResponseBody = {
 };
 
 export const MeForbiddenResponseBody$zodSchema: z.ZodType<
-  MeForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  MeForbiddenResponseBody
 > = z.object({
   code: MeCode$zodSchema,
   message: z.string(),
@@ -56,11 +64,7 @@ export type MeResponseBody = {
   permissions: Array<string>;
 };
 
-export const MeResponseBody$zodSchema: z.ZodType<
-  MeResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const MeResponseBody$zodSchema: z.ZodType<MeResponseBody> = z.object({
   accountantId: z.string(),
   apiKeyId: z.string(),
   clientId: z.string().nullable(),
@@ -76,11 +80,7 @@ export type MeResponse =
   | MeForbiddenResponseBody
   | RateLimit;
 
-export const MeResponse$zodSchema: z.ZodType<
-  MeResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const MeResponse$zodSchema: z.ZodType<MeResponse> = z.union([
   z.lazy(() => MeResponseBody$zodSchema),
   AuthError$zodSchema,
   z.lazy(() => MeForbiddenResponseBody$zodSchema),

package/src/models/notfound.ts

@@ -3,23 +3,33 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+export const NotFoundStatusCode = {
+  FourHundredAndFour: 404,
+} as const;
+export type NotFoundStatusCode = ClosedEnum<typeof NotFoundStatusCode>;
 
 export const NotFoundStatusCode$zodSchema = z.literal(404);
 
-export type NotFoundStatusCode = z.infer<typeof NotFoundStatusCode$zodSchema>;
+export const NotFoundType = {
+  NotFound: "not_found",
+} as const;
+export type NotFoundType = ClosedEnum<typeof NotFoundType>;
 
 export const NotFoundType$zodSchema = z.enum([
   "not_found",
 ]);
 
-export type NotFoundType = z.infer<typeof NotFoundType$zodSchema>;
+export const NotFoundCode = {
+  NotFound: "not_found",
+} as const;
+export type NotFoundCode = ClosedEnum<typeof NotFoundCode>;
 
 export const NotFoundCode$zodSchema = z.enum([
   "not_found",
 ]);
 
-export type NotFoundCode = z.infer<typeof NotFoundCode$zodSchema>;
-
 export type NotFound = {
   status_code: NotFoundStatusCode;
   type: NotFoundType;
@@ -27,10 +37,9 @@ export type NotFound = {
   message: string;
 };
 
-export const NotFound$zodSchema: z.ZodType<NotFound, z.ZodTypeDef, unknown> = z
-  .object({
-    code: NotFoundCode$zodSchema,
-    message: z.string(),
-    status_code: NotFoundStatusCode$zodSchema,
-    type: NotFoundType$zodSchema,
-  });
+export const NotFound$zodSchema: z.ZodType<NotFound> = z.object({
+  code: NotFoundCode$zodSchema,
+  message: z.string(),
+  status_code: NotFoundStatusCode$zodSchema,
+  type: NotFoundType$zodSchema,
+});

package/src/models/paginatedclients.ts

@@ -8,11 +8,9 @@ import { Pagination, Pagination$zodSchema } from "./pagination.js";
 
 export type PaginatedClients = { data: Array<Client>; pagination: Pagination };
 
-export const PaginatedClients$zodSchema: z.ZodType<
-  PaginatedClients,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  data: z.array(Client$zodSchema),
-  pagination: Pagination$zodSchema,
-});
+export const PaginatedClients$zodSchema: z.ZodType<PaginatedClients> = z.object(
+  {
+    data: z.array(Client$zodSchema),
+    pagination: Pagination$zodSchema,
+  },
+);

package/src/models/paginatedfiles.ts

@@ -8,11 +8,7 @@ import { Pagination, Pagination$zodSchema } from "./pagination.js";
 
 export type PaginatedFiles = { data: Array<FileT>; pagination: Pagination };
 
-export const PaginatedFiles$zodSchema: z.ZodType<
-  PaginatedFiles,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const PaginatedFiles$zodSchema: z.ZodType<PaginatedFiles> = z.object({
   data: z.array(FileT$zodSchema),
   pagination: Pagination$zodSchema,
 });

package/src/models/paginatedtasks.ts

@@ -8,11 +8,7 @@ import { Task, Task$zodSchema } from "./task.js";
 
 export type PaginatedTasks = { data: Array<Task>; pagination: Pagination };
 
-export const PaginatedTasks$zodSchema: z.ZodType<
-  PaginatedTasks,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const PaginatedTasks$zodSchema: z.ZodType<PaginatedTasks> = z.object({
   data: z.array(Task$zodSchema),
   pagination: Pagination$zodSchema,
 });

package/src/models/paginatedusers.ts

@@ -11,11 +11,7 @@ export type PaginatedUsers = {
   pagination: Pagination;
 };
 
-export const PaginatedUsers$zodSchema: z.ZodType<
-  PaginatedUsers,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const PaginatedUsers$zodSchema: z.ZodType<PaginatedUsers> = z.object({
   data: z.array(ClientUser$zodSchema),
   pagination: Pagination$zodSchema,
 });

package/src/models/paginatedworkspaces.ts

@@ -11,11 +11,8 @@ export type PaginatedWorkspaces = {
   pagination: Pagination;
 };
 
-export const PaginatedWorkspaces$zodSchema: z.ZodType<
-  PaginatedWorkspaces,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  data: z.array(Workspace$zodSchema),
-  pagination: Pagination$zodSchema,
-});
+export const PaginatedWorkspaces$zodSchema: z.ZodType<PaginatedWorkspaces> = z
+  .object({
+    data: z.array(Workspace$zodSchema),
+    pagination: Pagination$zodSchema,
+  });

package/src/models/pagination.ts

@@ -11,13 +11,13 @@ export type Pagination = {
   total: number;
 };
 
-export const Pagination$zodSchema: z.ZodType<
-  Pagination,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  limit: z.number().int(),
-  nextCursor: z.string().optional(),
-  previousCursor: z.string().optional(),
-  total: z.number().int(),
+export const Pagination$zodSchema: z.ZodType<Pagination> = z.object({
+  limit: z.int().describe("The number of items to return"),
+  nextCursor: z.string().optional().describe(
+    "The cursor to return the next page of items",
+  ),
+  previousCursor: z.string().optional().describe(
+    "The cursor to return the previous page of items",
+  ),
+  total: z.int().describe("The total number of items"),
 });

package/src/models/pingcollectsessionop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import {
   PingSessionResponse,
@@ -13,35 +14,38 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 export type PingCollectSessionRequest = { token: string };
 
 export const PingCollectSessionRequest$zodSchema: z.ZodType<
-  PingCollectSessionRequest,
-  z.ZodTypeDef,
-  unknown
+  PingCollectSessionRequest
 > = z.object({
   token: z.string(),
 });
 
+export const PingCollectSessionStatusCode = {
+  FourHundredAndFour: 404,
+} as const;
+export type PingCollectSessionStatusCode = ClosedEnum<
+  typeof PingCollectSessionStatusCode
+>;
+
 export const PingCollectSessionStatusCode$zodSchema = z.literal(404);
 
-export type PingCollectSessionStatusCode = z.infer<
-  typeof PingCollectSessionStatusCode$zodSchema
->;
+export const PingCollectSessionType = {
+  NotFound: "not_found",
+} as const;
+export type PingCollectSessionType = ClosedEnum<typeof PingCollectSessionType>;
 
 export const PingCollectSessionType$zodSchema = z.enum([
   "not_found",
 ]);
 
-export type PingCollectSessionType = z.infer<
-  typeof PingCollectSessionType$zodSchema
->;
+export const PingCollectSessionCode = {
+  CollectTokenNotFound: "collect_token_not_found",
+} as const;
+export type PingCollectSessionCode = ClosedEnum<typeof PingCollectSessionCode>;
 
 export const PingCollectSessionCode$zodSchema = z.enum([
   "collect_token_not_found",
 ]);
 
-export type PingCollectSessionCode = z.infer<
-  typeof PingCollectSessionCode$zodSchema
->;
-
 /**
  * Collect session not found. The token may be invalid or revoked.
  */
@@ -53,9 +57,7 @@ export type PingCollectSessionResponseBody = {
 };
 
 export const PingCollectSessionResponseBody$zodSchema: z.ZodType<
-  PingCollectSessionResponseBody,
-  z.ZodTypeDef,
-  unknown
+  PingCollectSessionResponseBody
 > = z.object({
   code: PingCollectSessionCode$zodSchema,
   message: z.string(),
@@ -70,9 +72,7 @@ export type PingCollectSessionResponse =
   | PingSessionResponse;
 
 export const PingCollectSessionResponse$zodSchema: z.ZodType<
-  PingCollectSessionResponse,
-  z.ZodTypeDef,
-  unknown
+  PingCollectSessionResponse
 > = z.union([
   z.lazy(() => PingCollectSessionResponseBody$zodSchema),
   BadRequest$zodSchema,

package/src/models/pingop.ts

@@ -10,21 +10,15 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
  */
 export type PingResponseBody = { ping: string };
 
-export const PingResponseBody$zodSchema: z.ZodType<
-  PingResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  ping: z.string(),
-}).describe("Pong");
+export const PingResponseBody$zodSchema: z.ZodType<PingResponseBody> = z.object(
+  {
+    ping: z.string(),
+  },
+).describe("Pong");
 
 export type PingResponse = RateLimit | PingResponseBody;
 
-export const PingResponse$zodSchema: z.ZodType<
-  PingResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const PingResponse$zodSchema: z.ZodType<PingResponse> = z.union([
   RateLimit$zodSchema,
   z.lazy(() => PingResponseBody$zodSchema),
 ]);

package/src/models/pingsessionresponse.ts

@@ -6,10 +6,7 @@ import * as z from "zod";
 
 export type PingSessionResponse = { success: boolean };
 
-export const PingSessionResponse$zodSchema: z.ZodType<
-  PingSessionResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  success: z.boolean(),
-});
+export const PingSessionResponse$zodSchema: z.ZodType<PingSessionResponse> = z
+  .object({
+    success: z.boolean(),
+  });

package/src/models/ratelimit.ts

@@ -3,23 +3,33 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+export const RateLimitStatusCode = {
+  FourHundredAndTwentyNine: 429,
+} as const;
+export type RateLimitStatusCode = ClosedEnum<typeof RateLimitStatusCode>;
 
 export const RateLimitStatusCode$zodSchema = z.literal(429);
 
-export type RateLimitStatusCode = z.infer<typeof RateLimitStatusCode$zodSchema>;
+export const RateLimitType = {
+  RateLimit: "rate_limit",
+} as const;
+export type RateLimitType = ClosedEnum<typeof RateLimitType>;
 
 export const RateLimitType$zodSchema = z.enum([
   "rate_limit",
 ]);
 
-export type RateLimitType = z.infer<typeof RateLimitType$zodSchema>;
+export const RateLimitCode = {
+  TooManyRequests: "too_many_requests",
+} as const;
+export type RateLimitCode = ClosedEnum<typeof RateLimitCode>;
 
 export const RateLimitCode$zodSchema = z.enum([
   "too_many_requests",
 ]);
 
-export type RateLimitCode = z.infer<typeof RateLimitCode$zodSchema>;
-
 export type RateLimit = {
   status_code: RateLimitStatusCode;
   type: RateLimitType;
@@ -27,10 +37,9 @@ export type RateLimit = {
   message: string;
 };
 
-export const RateLimit$zodSchema: z.ZodType<RateLimit, z.ZodTypeDef, unknown> =
-  z.object({
-    code: RateLimitCode$zodSchema,
-    message: z.string(),
-    status_code: RateLimitStatusCode$zodSchema,
-    type: RateLimitType$zodSchema,
-  });
+export const RateLimit$zodSchema: z.ZodType<RateLimit> = z.object({
+  code: RateLimitCode$zodSchema,
+  message: z.string(),
+  status_code: RateLimitStatusCode$zodSchema,
+  type: RateLimitType$zodSchema,
+});