@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/listworkspacesop.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 {
   PaginatedWorkspaces,
   PaginatedWorkspaces$zodSchema,
@@ -17,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;
@@ -44,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)
@@ -80,85 +68,127 @@ 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 ListWorkspacesStatusCode$zodSchema = z.literal(403);
+export const ListWorkspacesForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type ListWorkspacesForbiddenStatusCode = ClosedEnum<
+  typeof ListWorkspacesForbiddenStatusCode
+>;
+
+export const ListWorkspacesForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type ListWorkspacesStatusCode = z.infer<
-  typeof ListWorkspacesStatusCode$zodSchema
+export const ListWorkspacesForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type ListWorkspacesForbiddenType = ClosedEnum<
+  typeof ListWorkspacesForbiddenType
 >;
 
-export const ListWorkspacesType$zodSchema = z.enum([
+export const ListWorkspacesForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type ListWorkspacesType = z.infer<typeof ListWorkspacesType$zodSchema>;
+export const ListWorkspacesForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type ListWorkspacesForbiddenCode = ClosedEnum<
+  typeof ListWorkspacesForbiddenCode
+>;
 
-export const ListWorkspacesCode$zodSchema = z.enum([
+export const ListWorkspacesForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type ListWorkspacesCode = z.infer<typeof ListWorkspacesCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type ListWorkspacesForbiddenResponseBody = {
-  status_code: ListWorkspacesStatusCode;
-  type: ListWorkspacesType;
-  code: ListWorkspacesCode;
+  status_code: ListWorkspacesForbiddenStatusCode;
+  type: ListWorkspacesForbiddenType;
+  code: ListWorkspacesForbiddenCode;
   message: string;
 };
 
 export const ListWorkspacesForbiddenResponseBody$zodSchema: z.ZodType<
-  ListWorkspacesForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListWorkspacesForbiddenResponseBody
 > = z.object({
-  code: ListWorkspacesCode$zodSchema,
+  code: ListWorkspacesForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: ListWorkspacesStatusCode$zodSchema,
-  type: ListWorkspacesType$zodSchema,
+  status_code: ListWorkspacesForbiddenStatusCode$zodSchema,
+  type: ListWorkspacesForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type ListWorkspacesResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  PaginatedWorkspaces?: PaginatedWorkspaces | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListWorkspacesForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListWorkspacesUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const ListWorkspacesStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type ListWorkspacesStatusCode400 = ClosedEnum<
+  typeof ListWorkspacesStatusCode400
+>;
+
+export const ListWorkspacesStatusCode400$zodSchema = z.literal(400);
+
+export const ListWorkspacesBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type ListWorkspacesBadRequestType = ClosedEnum<
+  typeof ListWorkspacesBadRequestType
+>;
+
+export const ListWorkspacesBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const ListWorkspacesCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type ListWorkspacesCodeMissingClientID = ClosedEnum<
+  typeof ListWorkspacesCodeMissingClientID
+>;
+
+export const ListWorkspacesCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type ListWorkspacesBadRequestResponseBody = {
+  status_code: ListWorkspacesStatusCode400;
+  type: ListWorkspacesBadRequestType;
+  code: ListWorkspacesCodeMissingClientID;
+  message: string;
 };
 
-export const ListWorkspacesResponse$zodSchema: z.ZodType<
-  ListWorkspacesResponse,
-  z.ZodTypeDef,
-  unknown
+export const ListWorkspacesBadRequestResponseBody$zodSchema: z.ZodType<
+  ListWorkspacesBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  PaginatedWorkspaces: PaginatedWorkspaces$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListWorkspacesForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListWorkspacesUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: ListWorkspacesCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: ListWorkspacesStatusCode400$zodSchema,
+  type: ListWorkspacesBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type ListWorkspacesResponse =
+  | ListWorkspacesBadRequestResponseBody
+  | AuthError
+  | ListWorkspacesForbiddenResponseBody
+  | RateLimit
+  | PaginatedWorkspaces
+  | ListWorkspacesUnprocessableEntityResponseBody;
+
+export const ListWorkspacesResponse$zodSchema: z.ZodType<
+  ListWorkspacesResponse
+> = z.union([
+  z.lazy(() => ListWorkspacesBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => ListWorkspacesForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  PaginatedWorkspaces$zodSchema,
+  z.lazy(() => ListWorkspacesUnprocessableEntityResponseBody$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(),
@@ -70,31 +74,15 @@ export const MeResponseBody$zodSchema: z.ZodType<
   type: z.string(),
 }).describe("Me");
 
-export type MeResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  twoHundredApplicationJsonObject?: MeResponseBody | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | MeForbiddenResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type MeResponse =
+  | MeResponseBody
+  | AuthError
+  | MeForbiddenResponseBody
+  | RateLimit;
 
-export const MeResponse$zodSchema: z.ZodType<
-  MeResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    MeForbiddenResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-  twoHundredApplicationJsonObject: z.lazy(() => MeResponseBody$zodSchema)
-    .optional(),
-});
+export const MeResponse$zodSchema: z.ZodType<MeResponse> = z.union([
+  z.lazy(() => MeResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => MeForbiddenResponseBody$zodSchema),
+  RateLimit$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

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
+import {
+  PingSessionResponse,
+  PingSessionResponse$zodSchema,
+} from "./pingsessionresponse.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+
+export type PingCollectSessionRequest = { token: string };
+
+export const PingCollectSessionRequest$zodSchema: z.ZodType<
+  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 const PingCollectSessionType = {
+  NotFound: "not_found",
+} as const;
+export type PingCollectSessionType = ClosedEnum<typeof PingCollectSessionType>;
+
+export const PingCollectSessionType$zodSchema = z.enum([
+  "not_found",
+]);
+
+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",
+]);
+
+/**
+ * Collect session not found. The token may be invalid or revoked.
+ */
+export type PingCollectSessionResponseBody = {
+  status_code: PingCollectSessionStatusCode;
+  type: PingCollectSessionType;
+  code: PingCollectSessionCode;
+  message: string;
+};
+
+export const PingCollectSessionResponseBody$zodSchema: z.ZodType<
+  PingCollectSessionResponseBody
+> = z.object({
+  code: PingCollectSessionCode$zodSchema,
+  message: z.string(),
+  status_code: PingCollectSessionStatusCode$zodSchema,
+  type: PingCollectSessionType$zodSchema,
+}).describe("Collect session not found. The token may be invalid or revoked.");
+
+export type PingCollectSessionResponse =
+  | PingCollectSessionResponseBody
+  | BadRequest
+  | RateLimit
+  | PingSessionResponse;
+
+export const PingCollectSessionResponse$zodSchema: z.ZodType<
+  PingCollectSessionResponse
+> = z.union([
+  z.lazy(() => PingCollectSessionResponseBody$zodSchema),
+  BadRequest$zodSchema,
+  RateLimit$zodSchema,
+  PingSessionResponse$zodSchema,
+]);

package/src/models/pingop.ts

@@ -10,30 +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 = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  object?: PingResponseBody | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type PingResponse = RateLimit | PingResponseBody;
 
-export const PingResponse$zodSchema: z.ZodType<
-  PingResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  object: z.lazy(() => PingResponseBody$zodSchema).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+export const PingResponse$zodSchema: z.ZodType<PingResponse> = z.union([
+  RateLimit$zodSchema,
+  z.lazy(() => PingResponseBody$zodSchema),
+]);

package/src/models/pingsessionresponse.ts

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type PingSessionResponse = { success: boolean };
+
+export const PingSessionResponse$zodSchema: z.ZodType<PingSessionResponse> = z
+  .object({
+    success: z.boolean(),
+  });