@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/getuserop.ts

@@ -3,30 +3,22 @@
  */
 
 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 { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type GetUserRequest = { id: string; xClientId: string };
 
-export const GetUserRequest$zodSchema: z.ZodType<
-  GetUserRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserRequest$zodSchema: z.ZodType<GetUserRequest> = z.object({
   id: z.string(),
   xClientId: z.string(),
 });
 
 export type GetUserPath2 = string | number;
 
-export const GetUserPath2$zodSchema: z.ZodType<
-  GetUserPath2,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetUserPath2$zodSchema: z.ZodType<GetUserPath2> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -37,11 +29,7 @@ export type GetUserIssue2 = {
   message?: string | undefined;
 };
 
-export const GetUserIssue2$zodSchema: z.ZodType<
-  GetUserIssue2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserIssue2$zodSchema: z.ZodType<GetUserIssue2> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -52,33 +40,22 @@ export const GetUserIssue2$zodSchema: z.ZodType<
 
 export type GetUserError2 = { issues: Array<GetUserIssue2>; name: string };
 
-export const GetUserError2$zodSchema: z.ZodType<
-  GetUserError2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserError2$zodSchema: z.ZodType<GetUserError2> = z.object({
   issues: z.array(z.lazy(() => GetUserIssue2$zodSchema)),
   name: z.string(),
 });
 
 export type GetUserResponseBody2 = { success: boolean; error: GetUserError2 };
 
-export const GetUserResponseBody2$zodSchema: z.ZodType<
-  GetUserResponseBody2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => GetUserError2$zodSchema),
-  success: z.boolean(),
-});
+export const GetUserResponseBody2$zodSchema: z.ZodType<GetUserResponseBody2> = z
+  .object({
+    error: z.lazy(() => GetUserError2$zodSchema),
+    success: z.boolean(),
+  });
 
 export type GetUserPath1 = string | number;
 
-export const GetUserPath1$zodSchema: z.ZodType<
-  GetUserPath1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetUserPath1$zodSchema: z.ZodType<GetUserPath1> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -89,11 +66,7 @@ export type GetUserIssue1 = {
   message?: string | undefined;
 };
 
-export const GetUserIssue1$zodSchema: z.ZodType<
-  GetUserIssue1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserIssue1$zodSchema: z.ZodType<GetUserIssue1> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -104,106 +77,141 @@ export const GetUserIssue1$zodSchema: z.ZodType<
 
 export type GetUserError1 = { issues: Array<GetUserIssue1>; name: string };
 
-export const GetUserError1$zodSchema: z.ZodType<
-  GetUserError1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetUserError1$zodSchema: z.ZodType<GetUserError1> = z.object({
   issues: z.array(z.lazy(() => GetUserIssue1$zodSchema)),
   name: z.string(),
 });
 
 export type GetUserResponseBody1 = { success: boolean; error: GetUserError1 };
 
-export const GetUserResponseBody1$zodSchema: z.ZodType<
-  GetUserResponseBody1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => GetUserError1$zodSchema),
-  success: z.boolean(),
-});
+export const GetUserResponseBody1$zodSchema: z.ZodType<GetUserResponseBody1> = z
+  .object({
+    error: z.lazy(() => GetUserError1$zodSchema),
+    success: z.boolean(),
+  });
 
 /**
  * The validation error(s)
  */
 export type GetUserResponseBody = GetUserResponseBody1 | GetUserResponseBody2;
 
-export const GetUserResponseBody$zodSchema: z.ZodType<
-  GetUserResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => GetUserResponseBody1$zodSchema),
-  z.lazy(() => GetUserResponseBody2$zodSchema),
-]).describe("The validation error(s)");
+export const GetUserResponseBody$zodSchema: z.ZodType<GetUserResponseBody> = z
+  .union([
+    z.lazy(() => GetUserResponseBody1$zodSchema),
+    z.lazy(() => GetUserResponseBody2$zodSchema),
+  ]).describe("The validation error(s)");
 
-export const GetUserStatusCode$zodSchema = z.literal(403);
+export const GetUserForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetUserForbiddenStatusCode = ClosedEnum<
+  typeof GetUserForbiddenStatusCode
+>;
 
-export type GetUserStatusCode = z.infer<typeof GetUserStatusCode$zodSchema>;
+export const GetUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export const GetUserType$zodSchema = z.enum([
+export const GetUserForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type GetUserForbiddenType = ClosedEnum<typeof GetUserForbiddenType>;
+
+export const GetUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetUserType = z.infer<typeof GetUserType$zodSchema>;
+export const GetUserForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetUserForbiddenCode = ClosedEnum<typeof GetUserForbiddenCode>;
 
-export const GetUserCode$zodSchema = z.enum([
+export const GetUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetUserCode = z.infer<typeof GetUserCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type GetUserForbiddenResponseBody = {
-  status_code: GetUserStatusCode;
-  type: GetUserType;
-  code: GetUserCode;
+  status_code: GetUserForbiddenStatusCode;
+  type: GetUserForbiddenType;
+  code: GetUserForbiddenCode;
   message: string;
 };
 
 export const GetUserForbiddenResponseBody$zodSchema: z.ZodType<
-  GetUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetUserForbiddenResponseBody
 > = z.object({
-  code: GetUserCode$zodSchema,
+  code: GetUserForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: GetUserStatusCode$zodSchema,
-  type: GetUserType$zodSchema,
+  status_code: GetUserForbiddenStatusCode$zodSchema,
+  type: GetUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type GetUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  ClientUser?: ClientUser | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: GetUserForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: GetUserResponseBody1 | GetUserResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
+export const GetUserStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type GetUserStatusCode400 = ClosedEnum<typeof GetUserStatusCode400>;
+
+export const GetUserStatusCode400$zodSchema = z.literal(400);
+
+export const GetUserBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type GetUserBadRequestType = ClosedEnum<typeof GetUserBadRequestType>;
+
+export const GetUserBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const GetUserCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type GetUserCodeMissingClientID = ClosedEnum<
+  typeof GetUserCodeMissingClientID
+>;
+
+export const GetUserCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type GetUserBadRequestResponseBody = {
+  status_code: GetUserStatusCode400;
+  type: GetUserBadRequestType;
+  code: GetUserCodeMissingClientID;
+  message: string;
 };
 
-export const GetUserResponse$zodSchema: z.ZodType<
-  GetUserResponse,
-  z.ZodTypeDef,
-  unknown
+export const GetUserBadRequestResponseBody$zodSchema: z.ZodType<
+  GetUserBadRequestResponseBody
 > = 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(() => GetUserForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
+  code: GetUserCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: GetUserStatusCode400$zodSchema,
+  type: GetUserBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type GetUserResponse =
+  | ClientUser
+  | GetUserBadRequestResponseBody
+  | AuthError
+  | GetUserForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | GetUserResponseBody1
+  | GetUserResponseBody2;
+
+export const GetUserResponse$zodSchema: z.ZodType<GetUserResponse> = z.union([
+  ClientUser$zodSchema,
+  z.lazy(() => GetUserBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => GetUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.union([
     z.lazy(() => GetUserResponseBody1$zodSchema),
     z.lazy(() => GetUserResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  ]),
+]);

package/src/models/getworkspaceop.ts

@@ -3,30 +3,23 @@
  */
 
 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 { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Workspace, Workspace$zodSchema } from "./workspace.js";
 
 export type GetWorkspaceRequest = { id: string; xClientId: string };
 
-export const GetWorkspaceRequest$zodSchema: z.ZodType<
-  GetWorkspaceRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  xClientId: z.string(),
-});
+export const GetWorkspaceRequest$zodSchema: z.ZodType<GetWorkspaceRequest> = z
+  .object({
+    id: z.string(),
+    xClientId: z.string(),
+  });
 
 export type GetWorkspacePath = string | number;
 
-export const GetWorkspacePath$zodSchema: z.ZodType<
-  GetWorkspacePath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetWorkspacePath$zodSchema: z.ZodType<GetWorkspacePath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -37,32 +30,26 @@ export type GetWorkspaceIssue = {
   message?: string | undefined;
 };
 
-export const GetWorkspaceIssue$zodSchema: z.ZodType<
-  GetWorkspaceIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const GetWorkspaceIssue$zodSchema: z.ZodType<GetWorkspaceIssue> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type GetWorkspaceError = {
   issues: Array<GetWorkspaceIssue>;
   name: string;
 };
 
-export const GetWorkspaceError$zodSchema: z.ZodType<
-  GetWorkspaceError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => GetWorkspaceIssue$zodSchema)),
-  name: z.string(),
-});
+export const GetWorkspaceError$zodSchema: z.ZodType<GetWorkspaceError> = z
+  .object({
+    issues: z.array(z.lazy(() => GetWorkspaceIssue$zodSchema)),
+    name: z.string(),
+  });
 
 /**
  * Invalid id error
@@ -73,87 +60,128 @@ export type GetWorkspaceUnprocessableEntityResponseBody = {
 };
 
 export const GetWorkspaceUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  GetWorkspaceUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetWorkspaceUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => GetWorkspaceError$zodSchema),
   success: z.boolean(),
 }).describe("Invalid id error");
 
-export const GetWorkspaceStatusCode$zodSchema = z.literal(403);
+export const GetWorkspaceForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetWorkspaceForbiddenStatusCode = ClosedEnum<
+  typeof GetWorkspaceForbiddenStatusCode
+>;
+
+export const GetWorkspaceForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type GetWorkspaceStatusCode = z.infer<
-  typeof GetWorkspaceStatusCode$zodSchema
+export const GetWorkspaceForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type GetWorkspaceForbiddenType = ClosedEnum<
+  typeof GetWorkspaceForbiddenType
 >;
 
-export const GetWorkspaceType$zodSchema = z.enum([
+export const GetWorkspaceForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetWorkspaceType = z.infer<typeof GetWorkspaceType$zodSchema>;
+export const GetWorkspaceForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetWorkspaceForbiddenCode = ClosedEnum<
+  typeof GetWorkspaceForbiddenCode
+>;
 
-export const GetWorkspaceCode$zodSchema = z.enum([
+export const GetWorkspaceForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetWorkspaceCode = z.infer<typeof GetWorkspaceCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type GetWorkspaceForbiddenResponseBody = {
-  status_code: GetWorkspaceStatusCode;
-  type: GetWorkspaceType;
-  code: GetWorkspaceCode;
+  status_code: GetWorkspaceForbiddenStatusCode;
+  type: GetWorkspaceForbiddenType;
+  code: GetWorkspaceForbiddenCode;
   message: string;
 };
 
 export const GetWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
-  GetWorkspaceForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetWorkspaceForbiddenResponseBody
 > = z.object({
-  code: GetWorkspaceCode$zodSchema,
+  code: GetWorkspaceForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: GetWorkspaceStatusCode$zodSchema,
-  type: GetWorkspaceType$zodSchema,
+  status_code: GetWorkspaceForbiddenStatusCode$zodSchema,
+  type: GetWorkspaceForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type GetWorkspaceResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Workspace?: Workspace | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | GetWorkspaceForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | GetWorkspaceUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const GetWorkspaceStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type GetWorkspaceStatusCode400 = ClosedEnum<
+  typeof GetWorkspaceStatusCode400
+>;
+
+export const GetWorkspaceStatusCode400$zodSchema = z.literal(400);
+
+export const GetWorkspaceBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type GetWorkspaceBadRequestType = ClosedEnum<
+  typeof GetWorkspaceBadRequestType
+>;
+
+export const GetWorkspaceBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const GetWorkspaceCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type GetWorkspaceCodeMissingClientID = ClosedEnum<
+  typeof GetWorkspaceCodeMissingClientID
+>;
+
+export const GetWorkspaceCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type GetWorkspaceBadRequestResponseBody = {
+  status_code: GetWorkspaceStatusCode400;
+  type: GetWorkspaceBadRequestType;
+  code: GetWorkspaceCodeMissingClientID;
+  message: string;
 };
 
-export const GetWorkspaceResponse$zodSchema: z.ZodType<
-  GetWorkspaceResponse,
-  z.ZodTypeDef,
-  unknown
+export const GetWorkspaceBadRequestResponseBody$zodSchema: z.ZodType<
+  GetWorkspaceBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  Workspace: Workspace$zodSchema.optional(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    GetWorkspaceForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    GetWorkspaceUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: GetWorkspaceCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: GetWorkspaceStatusCode400$zodSchema,
+  type: GetWorkspaceBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type GetWorkspaceResponse =
+  | Workspace
+  | GetWorkspaceBadRequestResponseBody
+  | AuthError
+  | GetWorkspaceForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | GetWorkspaceUnprocessableEntityResponseBody;
+
+export const GetWorkspaceResponse$zodSchema: z.ZodType<GetWorkspaceResponse> = z
+  .union([
+    Workspace$zodSchema,
+    z.lazy(() => GetWorkspaceBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => GetWorkspaceForbiddenResponseBody$zodSchema),
+    NotFound$zodSchema,
+    RateLimit$zodSchema,
+    z.lazy(() => GetWorkspaceUnprocessableEntityResponseBody$zodSchema),
+  ]);

package/src/models/healthop.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+
+/**
+ * Health Check Response
+ */
+export type HealthResponseBody = { status: string; timestamp: string };
+
+export const HealthResponseBody$zodSchema: z.ZodType<HealthResponseBody> = z
+  .object({
+    status: z.string(),
+    timestamp: z.string(),
+  }).describe("Health Check Response");
+
+export type HealthResponse = RateLimit | HealthResponseBody;
+
+export const HealthResponse$zodSchema: z.ZodType<HealthResponse> = z.union([
+  RateLimit$zodSchema,
+  z.lazy(() => HealthResponseBody$zodSchema),
+]);

package/src/models/indexop.ts

@@ -10,30 +10,14 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
  */
 export type IndexResponseBody = { message: string };
 
-export const IndexResponseBody$zodSchema: z.ZodType<
-  IndexResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  message: z.string(),
-}).describe("Steuerboard API Index");
+export const IndexResponseBody$zodSchema: z.ZodType<IndexResponseBody> = z
+  .object({
+    message: z.string(),
+  }).describe("Steuerboard API Index");
 
-export type IndexResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  object?: IndexResponseBody | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type IndexResponse = RateLimit | IndexResponseBody;
 
-export const IndexResponse$zodSchema: z.ZodType<
-  IndexResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  object: z.lazy(() => IndexResponseBody$zodSchema).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+export const IndexResponse$zodSchema: z.ZodType<IndexResponse> = z.union([
+  RateLimit$zodSchema,
+  z.lazy(() => IndexResponseBody$zodSchema),
+]);