@steuerboard/mcp 0.3.0 → 0.3.4

package/src/models/deleteuserop.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
-import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import { DeleteResponse, DeleteResponse$zodSchema } from "./deleteresponse.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
@@ -152,31 +151,35 @@ export const DeleteUserResponseBody$zodSchema: z.ZodType<
   z.lazy(() => DeleteUserResponseBody2$zodSchema),
 ]).describe("The validation error(s)");
 
-export const DeleteUserStatusCode$zodSchema = z.literal(403);
+export const DeleteUserForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type DeleteUserStatusCode = z.infer<
-  typeof DeleteUserStatusCode$zodSchema
+export type DeleteUserForbiddenStatusCode = z.infer<
+  typeof DeleteUserForbiddenStatusCode$zodSchema
 >;
 
-export const DeleteUserType$zodSchema = z.enum([
+export const DeleteUserForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type DeleteUserType = z.infer<typeof DeleteUserType$zodSchema>;
+export type DeleteUserForbiddenType = z.infer<
+  typeof DeleteUserForbiddenType$zodSchema
+>;
 
-export const DeleteUserCode$zodSchema = z.enum([
+export const DeleteUserForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type DeleteUserCode = z.infer<typeof DeleteUserCode$zodSchema>;
+export type DeleteUserForbiddenCode = z.infer<
+  typeof DeleteUserForbiddenCode$zodSchema
+>;
 
 /**
  * Missing scope
  */
 export type DeleteUserForbiddenResponseBody = {
-  status_code: DeleteUserStatusCode;
-  type: DeleteUserType;
-  code: DeleteUserCode;
+  status_code: DeleteUserForbiddenStatusCode;
+  type: DeleteUserForbiddenType;
+  code: DeleteUserForbiddenCode;
   message: string;
 };
 
@@ -185,41 +188,78 @@ export const DeleteUserForbiddenResponseBody$zodSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: DeleteUserCode$zodSchema,
+  code: DeleteUserForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: DeleteUserStatusCode$zodSchema,
-  type: DeleteUserType$zodSchema,
+  status_code: DeleteUserForbiddenStatusCode$zodSchema,
+  type: DeleteUserForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type DeleteUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  DeleteResponse?: DeleteResponse | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  object?: DeleteUserForbiddenResponseBody | undefined;
-  not_found?: NotFound | undefined;
-  oneOf?: DeleteUserResponseBody1 | DeleteUserResponseBody2 | undefined;
-  rate_limit?: RateLimit | undefined;
+export const DeleteUserStatusCode400$zodSchema = z.literal(400);
+
+export type DeleteUserStatusCode400 = z.infer<
+  typeof DeleteUserStatusCode400$zodSchema
+>;
+
+export const DeleteUserBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type DeleteUserBadRequestType = z.infer<
+  typeof DeleteUserBadRequestType$zodSchema
+>;
+
+export const DeleteUserCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type DeleteUserCodeMissingClientID = z.infer<
+  typeof DeleteUserCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type DeleteUserBadRequestResponseBody = {
+  status_code: DeleteUserStatusCode400;
+  type: DeleteUserBadRequestType;
+  code: DeleteUserCodeMissingClientID;
+  message: string;
 };
 
+export const DeleteUserBadRequestResponseBody$zodSchema: z.ZodType<
+  DeleteUserBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DeleteUserCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: DeleteUserStatusCode400$zodSchema,
+  type: DeleteUserBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type DeleteUserResponse =
+  | DeleteUserBadRequestResponseBody
+  | AuthError
+  | DeleteUserForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | DeleteResponse
+  | DeleteUserResponseBody1
+  | DeleteUserResponseBody2;
+
 export const DeleteUserResponse$zodSchema: z.ZodType<
   DeleteUserResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  ContentType: z.string(),
-  DeleteResponse: DeleteResponse$zodSchema.optional(),
-  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(() => DeleteUserForbiddenResponseBody$zodSchema).optional(),
-  oneOf: z.union([
+> = z.union([
+  z.lazy(() => DeleteUserBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => DeleteUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  DeleteResponse$zodSchema,
+  z.union([
     z.lazy(() => DeleteUserResponseBody1$zodSchema),
     z.lazy(() => DeleteUserResponseBody2$zodSchema),
-  ]).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  ]),
+]);

package/src/models/downloadfilecontentop.ts

@@ -0,0 +1,203 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { AuthError, AuthError$zodSchema } from "./autherror.js";
+import { FileContent, FileContent$zodSchema } from "./filecontent.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+
+export type DownloadFileContentRequest = { id: string; xClientId: string };
+
+export const DownloadFileContentRequest$zodSchema: z.ZodType<
+  DownloadFileContentRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  xClientId: z.string(),
+});
+
+export type DownloadFileContentPath = string | number;
+
+export const DownloadFileContentPath$zodSchema: z.ZodType<
+  DownloadFileContentPath,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.string(),
+  z.number(),
+]);
+
+export type DownloadFileContentIssue = {
+  code: string;
+  path: Array<string | number>;
+  message?: string | undefined;
+};
+
+export const DownloadFileContentIssue$zodSchema: z.ZodType<
+  DownloadFileContentIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  message: z.string().optional(),
+  path: z.array(z.union([
+    z.string(),
+    z.number(),
+  ])),
+});
+
+export type DownloadFileContentError = {
+  issues: Array<DownloadFileContentIssue>;
+  name: string;
+};
+
+export const DownloadFileContentError$zodSchema: z.ZodType<
+  DownloadFileContentError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  issues: z.array(z.lazy(() => DownloadFileContentIssue$zodSchema)),
+  name: z.string(),
+});
+
+/**
+ * Invalid id error
+ */
+export type DownloadFileContentUnprocessableEntityResponseBody = {
+  success: boolean;
+  error: DownloadFileContentError;
+};
+
+export const DownloadFileContentUnprocessableEntityResponseBody$zodSchema:
+  z.ZodType<
+    DownloadFileContentUnprocessableEntityResponseBody,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    error: z.lazy(() => DownloadFileContentError$zodSchema),
+    success: z.boolean(),
+  }).describe("Invalid id error");
+
+/**
+ * File not found
+ */
+export type DownloadFileContentNotFoundResponseBody = { message: string };
+
+export const DownloadFileContentNotFoundResponseBody$zodSchema: z.ZodType<
+  DownloadFileContentNotFoundResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+}).describe("File not found");
+
+export const DownloadFileContentForbiddenStatusCode$zodSchema = z.literal(403);
+
+export type DownloadFileContentForbiddenStatusCode = z.infer<
+  typeof DownloadFileContentForbiddenStatusCode$zodSchema
+>;
+
+export const DownloadFileContentForbiddenType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export type DownloadFileContentForbiddenType = z.infer<
+  typeof DownloadFileContentForbiddenType$zodSchema
+>;
+
+export const DownloadFileContentForbiddenCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+export type DownloadFileContentForbiddenCode = z.infer<
+  typeof DownloadFileContentForbiddenCode$zodSchema
+>;
+
+/**
+ * Missing scope
+ */
+export type DownloadFileContentForbiddenResponseBody = {
+  status_code: DownloadFileContentForbiddenStatusCode;
+  type: DownloadFileContentForbiddenType;
+  code: DownloadFileContentForbiddenCode;
+  message: string;
+};
+
+export const DownloadFileContentForbiddenResponseBody$zodSchema: z.ZodType<
+  DownloadFileContentForbiddenResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DownloadFileContentForbiddenCode$zodSchema,
+  message: z.string(),
+  status_code: DownloadFileContentForbiddenStatusCode$zodSchema,
+  type: DownloadFileContentForbiddenType$zodSchema,
+}).describe("Missing scope");
+
+export const DownloadFileContentStatusCode400$zodSchema = z.literal(400);
+
+export type DownloadFileContentStatusCode400 = z.infer<
+  typeof DownloadFileContentStatusCode400$zodSchema
+>;
+
+export const DownloadFileContentBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type DownloadFileContentBadRequestType = z.infer<
+  typeof DownloadFileContentBadRequestType$zodSchema
+>;
+
+export const DownloadFileContentCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+export type DownloadFileContentCodeMissingClientID = z.infer<
+  typeof DownloadFileContentCodeMissingClientID$zodSchema
+>;
+
+/**
+ * Missing client ID
+ */
+export type DownloadFileContentBadRequestResponseBody = {
+  status_code: DownloadFileContentStatusCode400;
+  type: DownloadFileContentBadRequestType;
+  code: DownloadFileContentCodeMissingClientID;
+  message: string;
+};
+
+export const DownloadFileContentBadRequestResponseBody$zodSchema: z.ZodType<
+  DownloadFileContentBadRequestResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DownloadFileContentCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: DownloadFileContentStatusCode400$zodSchema,
+  type: DownloadFileContentBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type DownloadFileContentResponse =
+  | DownloadFileContentBadRequestResponseBody
+  | AuthError
+  | DownloadFileContentForbiddenResponseBody
+  | RateLimit
+  | FileContent
+  | DownloadFileContentUnprocessableEntityResponseBody
+  | DownloadFileContentNotFoundResponseBody;
+
+export const DownloadFileContentResponse$zodSchema: z.ZodType<
+  DownloadFileContentResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => DownloadFileContentBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => DownloadFileContentForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  FileContent$zodSchema,
+  z.lazy(() => DownloadFileContentUnprocessableEntityResponseBody$zodSchema),
+  z.lazy(() => DownloadFileContentNotFoundResponseBody$zodSchema),
+]);

package/src/models/filecontent.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type FileContent = { url: string; expiresIn: number };
+
+export const FileContent$zodSchema: z.ZodType<
+  FileContent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  expiresIn: z.number().int(),
+  url: z.string(),
+});

package/src/models/getaccountantuserop.ts

@@ -123,38 +123,23 @@ export const GetAccountantUserForbiddenResponseBody$zodSchema: z.ZodType<
   type: GetAccountantUserType$zodSchema,
 }).describe("Missing scope");
 
-export type GetAccountantUserResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  AccountantUser?: AccountantUser | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | GetAccountantUserForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | GetAccountantUserUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type GetAccountantUserResponse =
+  | AccountantUser
+  | AuthError
+  | GetAccountantUserForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | GetAccountantUserUnprocessableEntityResponseBody;
 
 export const GetAccountantUserResponse$zodSchema: z.ZodType<
   GetAccountantUserResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  AccountantUser: AccountantUser$zodSchema.optional(),
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    GetAccountantUserForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    GetAccountantUserUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  AccountantUser$zodSchema,
+  AuthError$zodSchema,
+  z.lazy(() => GetAccountantUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() => GetAccountantUserUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/getclientop.ts

@@ -113,38 +113,23 @@ export const GetClientForbiddenResponseBody$zodSchema: z.ZodType<
   type: GetClientType$zodSchema,
 }).describe("Missing scope");
 
-export type GetClientResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Client?: Client | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | GetClientForbiddenResponseBody
-    | undefined;
-  not_found?: NotFound | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | GetClientUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
-};
+export type GetClientResponse =
+  | Client
+  | AuthError
+  | GetClientForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | GetClientUnprocessableEntityResponseBody;
 
 export const GetClientResponse$zodSchema: z.ZodType<
   GetClientResponse,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  Client: Client$zodSchema.optional(),
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    GetClientForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    GetClientUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  not_found: NotFound$zodSchema.optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+> = z.union([
+  Client$zodSchema,
+  AuthError$zodSchema,
+  z.lazy(() => GetClientForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() => GetClientUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/getcollectsessionbytokenop.ts

@@ -0,0 +1,147 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
+import {
+  CollectSessionByToken,
+  CollectSessionByToken$zodSchema,
+} from "./collectsessionbytoken.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+
+export type GetcollectSessionByTokenRequest = { token: string };
+
+export const GetcollectSessionByTokenRequest$zodSchema: z.ZodType<
+  GetcollectSessionByTokenRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  token: z.string(),
+});
+
+export type GetcollectSessionByTokenPath = string | number;
+
+export const GetcollectSessionByTokenPath$zodSchema: z.ZodType<
+  GetcollectSessionByTokenPath,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.string(),
+  z.number(),
+]);
+
+export type GetcollectSessionByTokenIssue = {
+  code: string;
+  path: Array<string | number>;
+  message?: string | undefined;
+};
+
+export const GetcollectSessionByTokenIssue$zodSchema: z.ZodType<
+  GetcollectSessionByTokenIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  message: z.string().optional(),
+  path: z.array(z.union([
+    z.string(),
+    z.number(),
+  ])),
+});
+
+export type GetcollectSessionByTokenError = {
+  issues: Array<GetcollectSessionByTokenIssue>;
+  name: string;
+};
+
+export const GetcollectSessionByTokenError$zodSchema: z.ZodType<
+  GetcollectSessionByTokenError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  issues: z.array(z.lazy(() => GetcollectSessionByTokenIssue$zodSchema)),
+  name: z.string(),
+});
+
+/**
+ * The validation error(s)
+ */
+export type GetcollectSessionByTokenUnprocessableEntityResponseBody = {
+  success: boolean;
+  error: GetcollectSessionByTokenError;
+};
+
+export const GetcollectSessionByTokenUnprocessableEntityResponseBody$zodSchema:
+  z.ZodType<
+    GetcollectSessionByTokenUnprocessableEntityResponseBody,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    error: z.lazy(() => GetcollectSessionByTokenError$zodSchema),
+    success: z.boolean(),
+  }).describe("The validation error(s)");
+
+export const GetcollectSessionByTokenStatusCode$zodSchema = z.literal(404);
+
+export type GetcollectSessionByTokenStatusCode = z.infer<
+  typeof GetcollectSessionByTokenStatusCode$zodSchema
+>;
+
+export const GetcollectSessionByTokenType$zodSchema = z.enum([
+  "not_found",
+]);
+
+export type GetcollectSessionByTokenType = z.infer<
+  typeof GetcollectSessionByTokenType$zodSchema
+>;
+
+export const GetcollectSessionByTokenCode$zodSchema = z.enum([
+  "collect_token_not_found",
+]);
+
+export type GetcollectSessionByTokenCode = z.infer<
+  typeof GetcollectSessionByTokenCode$zodSchema
+>;
+
+/**
+ * Collect session not found. The token may be invalid or revoked.
+ */
+export type GetcollectSessionByTokenNotFoundResponseBody = {
+  status_code: GetcollectSessionByTokenStatusCode;
+  type: GetcollectSessionByTokenType;
+  code: GetcollectSessionByTokenCode;
+  message: string;
+};
+
+export const GetcollectSessionByTokenNotFoundResponseBody$zodSchema: z.ZodType<
+  GetcollectSessionByTokenNotFoundResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: GetcollectSessionByTokenCode$zodSchema,
+  message: z.string(),
+  status_code: GetcollectSessionByTokenStatusCode$zodSchema,
+  type: GetcollectSessionByTokenType$zodSchema,
+}).describe("Collect session not found. The token may be invalid or revoked.");
+
+export type GetcollectSessionByTokenResponse =
+  | CollectSessionByToken
+  | GetcollectSessionByTokenNotFoundResponseBody
+  | BadRequest
+  | RateLimit
+  | GetcollectSessionByTokenUnprocessableEntityResponseBody;
+
+export const GetcollectSessionByTokenResponse$zodSchema: z.ZodType<
+  GetcollectSessionByTokenResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  CollectSessionByToken$zodSchema,
+  z.lazy(() => GetcollectSessionByTokenNotFoundResponseBody$zodSchema),
+  BadRequest$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() =>
+    GetcollectSessionByTokenUnprocessableEntityResponseBody$zodSchema
+  ),
+]);