@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/filecreate.ts

@@ -3,15 +3,14 @@
  */
 
 import * as z from "zod";
+import * as b64$ from "../lib/base64.js";
 
 export type FileCreateFile = { fileName: string; content: Uint8Array | string };
 
-export const FileCreateFile$zodSchema: z.ZodType<
-  FileCreateFile,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  content: z.string().base64(),
+export const FileCreateFile$zodSchema: z.ZodType<FileCreateFile> = z.object({
+  content: z.string().describe("Base64-encoded binary content").transform(
+    b64$.bytesFromBase64,
+  ),
   fileName: z.string(),
 });
 
@@ -24,15 +23,17 @@ export type FileCreate = {
   taskId?: string | undefined;
 };
 
-export const FileCreate$zodSchema: z.ZodType<
-  FileCreate,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  file: z.lazy(() => FileCreateFile$zodSchema),
-  folderId: z.string().optional(),
-  labelIds: z.array(z.string()).optional(),
-  name: z.string().optional(),
-  taskId: z.string().optional(),
-  workspaceId: z.string(),
+export const FileCreate$zodSchema: z.ZodType<FileCreate> = z.object({
+  file: z.lazy(() => FileCreateFile$zodSchema).describe("The file to upload"),
+  folderId: z.string().optional().describe(
+    "The ID of the folder to upload the file to",
+  ),
+  labelIds: z.array(z.string()).optional().describe(
+    "The IDs of the labels to add to the file",
+  ),
+  name: z.string().optional().describe("The name of the file"),
+  taskId: z.string().optional().describe(
+    "The ID of the task to upload this file to.",
+  ),
+  workspaceId: z.string().describe("The ID of the workspace"),
 });

package/src/models/fileupdate.ts

@@ -10,12 +10,12 @@ export type FileUpdate = {
   folderId?: string | undefined;
 };
 
-export const FileUpdate$zodSchema: z.ZodType<
-  FileUpdate,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  documentDate: z.string().datetime({ offset: true }).optional(),
-  folderId: z.string().optional(),
-  name: z.string().optional(),
+export const FileUpdate$zodSchema: z.ZodType<FileUpdate> = z.object({
+  documentDate: z.iso.datetime({ offset: true }).optional().describe(
+    "The date of the document (not the upload date). ISO-8601 format (YYYY-MM-DDTHH:MM:SSZ).",
+  ),
+  folderId: z.string().optional().describe(
+    "The ID of the folder to place the file in",
+  ),
+  name: z.string().optional().describe("The name of the file"),
 });

package/src/models/getaccountantuserop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AccountantUser, AccountantUser$zodSchema } from "./accountantuser.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
@@ -11,23 +12,18 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 export type GetAccountantUserRequest = { id: string };
 
 export const GetAccountantUserRequest$zodSchema: z.ZodType<
-  GetAccountantUserRequest,
-  z.ZodTypeDef,
-  unknown
+  GetAccountantUserRequest
 > = z.object({
   id: z.string(),
 });
 
 export type GetAccountantUserPath = string | number;
 
-export const GetAccountantUserPath$zodSchema: z.ZodType<
-  GetAccountantUserPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.string(),
-  z.number(),
-]);
+export const GetAccountantUserPath$zodSchema: z.ZodType<GetAccountantUserPath> =
+  z.union([
+    z.string(),
+    z.number(),
+  ]);
 
 export type GetAccountantUserIssue = {
   code: string;
@@ -36,9 +32,7 @@ export type GetAccountantUserIssue = {
 };
 
 export const GetAccountantUserIssue$zodSchema: z.ZodType<
-  GetAccountantUserIssue,
-  z.ZodTypeDef,
-  unknown
+  GetAccountantUserIssue
 > = z.object({
   code: z.string(),
   message: z.string().optional(),
@@ -54,9 +48,7 @@ export type GetAccountantUserError = {
 };
 
 export const GetAccountantUserError$zodSchema: z.ZodType<
-  GetAccountantUserError,
-  z.ZodTypeDef,
-  unknown
+  GetAccountantUserError
 > = z.object({
   issues: z.array(z.lazy(() => GetAccountantUserIssue$zodSchema)),
   name: z.string(),
@@ -71,37 +63,38 @@ export type GetAccountantUserUnprocessableEntityResponseBody = {
 };
 
 export const GetAccountantUserUnprocessableEntityResponseBody$zodSchema:
-  z.ZodType<
-    GetAccountantUserUnprocessableEntityResponseBody,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
+  z.ZodType<GetAccountantUserUnprocessableEntityResponseBody> = z.object({
     error: z.lazy(() => GetAccountantUserError$zodSchema),
     success: z.boolean(),
   }).describe("The validation error(s)");
 
+export const GetAccountantUserStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetAccountantUserStatusCode = ClosedEnum<
+  typeof GetAccountantUserStatusCode
+>;
+
 export const GetAccountantUserStatusCode$zodSchema = z.literal(403);
 
-export type GetAccountantUserStatusCode = z.infer<
-  typeof GetAccountantUserStatusCode$zodSchema
->;
+export const GetAccountantUserType = {
+  AuthError: "auth_error",
+} as const;
+export type GetAccountantUserType = ClosedEnum<typeof GetAccountantUserType>;
 
 export const GetAccountantUserType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetAccountantUserType = z.infer<
-  typeof GetAccountantUserType$zodSchema
->;
+export const GetAccountantUserCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetAccountantUserCode = ClosedEnum<typeof GetAccountantUserCode>;
 
 export const GetAccountantUserCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetAccountantUserCode = z.infer<
-  typeof GetAccountantUserCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -113,9 +106,7 @@ export type GetAccountantUserForbiddenResponseBody = {
 };
 
 export const GetAccountantUserForbiddenResponseBody$zodSchema: z.ZodType<
-  GetAccountantUserForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetAccountantUserForbiddenResponseBody
 > = z.object({
   code: GetAccountantUserCode$zodSchema,
   message: z.string(),
@@ -123,38 +114,21 @@ 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(),
-});
+  GetAccountantUserResponse
+> = z.union([
+  AccountantUser$zodSchema,
+  AuthError$zodSchema,
+  z.lazy(() => GetAccountantUserForbiddenResponseBody$zodSchema),
+  NotFound$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() => GetAccountantUserUnprocessableEntityResponseBody$zodSchema),
+]);

package/src/models/getclientop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { Client, Client$zodSchema } from "./client.js";
 import { NotFound, NotFound$zodSchema } from "./notfound.js";
@@ -10,21 +11,15 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type GetClientRequest = { id: string };
 
-export const GetClientRequest$zodSchema: z.ZodType<
-  GetClientRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-});
+export const GetClientRequest$zodSchema: z.ZodType<GetClientRequest> = z.object(
+  {
+    id: z.string(),
+  },
+);
 
 export type GetClientPath = string | number;
 
-export const GetClientPath$zodSchema: z.ZodType<
-  GetClientPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const GetClientPath$zodSchema: z.ZodType<GetClientPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -35,11 +30,7 @@ export type GetClientIssue = {
   message?: string | undefined;
 };
 
-export const GetClientIssue$zodSchema: z.ZodType<
-  GetClientIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetClientIssue$zodSchema: z.ZodType<GetClientIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -50,11 +41,7 @@ export const GetClientIssue$zodSchema: z.ZodType<
 
 export type GetClientError = { issues: Array<GetClientIssue>; name: string };
 
-export const GetClientError$zodSchema: z.ZodType<
-  GetClientError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const GetClientError$zodSchema: z.ZodType<GetClientError> = z.object({
   issues: z.array(z.lazy(() => GetClientIssue$zodSchema)),
   name: z.string(),
 });
@@ -68,30 +55,37 @@ export type GetClientUnprocessableEntityResponseBody = {
 };
 
 export const GetClientUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  GetClientUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetClientUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => GetClientError$zodSchema),
   success: z.boolean(),
 }).describe("Invalid id error");
 
+export const GetClientStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type GetClientStatusCode = ClosedEnum<typeof GetClientStatusCode>;
+
 export const GetClientStatusCode$zodSchema = z.literal(403);
 
-export type GetClientStatusCode = z.infer<typeof GetClientStatusCode$zodSchema>;
+export const GetClientType = {
+  AuthError: "auth_error",
+} as const;
+export type GetClientType = ClosedEnum<typeof GetClientType>;
 
 export const GetClientType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type GetClientType = z.infer<typeof GetClientType$zodSchema>;
+export const GetClientCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type GetClientCode = ClosedEnum<typeof GetClientCode>;
 
 export const GetClientCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type GetClientCode = z.infer<typeof GetClientCode$zodSchema>;
-
 /**
  * Missing scope
  */
@@ -103,9 +97,7 @@ export type GetClientForbiddenResponseBody = {
 };
 
 export const GetClientForbiddenResponseBody$zodSchema: z.ZodType<
-  GetClientForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  GetClientForbiddenResponseBody
 > = z.object({
   code: GetClientCode$zodSchema,
   message: z.string(),
@@ -113,38 +105,20 @@ 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 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(),
-});
+export type GetClientResponse =
+  | Client
+  | AuthError
+  | GetClientForbiddenResponseBody
+  | NotFound
+  | RateLimit
+  | GetClientUnprocessableEntityResponseBody;
+
+export const GetClientResponse$zodSchema: z.ZodType<GetClientResponse> = 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,143 @@
+/*
+ * 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 {
+  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.object({
+  token: z.string(),
+});
+
+export type GetcollectSessionByTokenPath = string | number;
+
+export const GetcollectSessionByTokenPath$zodSchema: z.ZodType<
+  GetcollectSessionByTokenPath
+> = 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.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.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.object(
+    {
+      error: z.lazy(() => GetcollectSessionByTokenError$zodSchema),
+      success: z.boolean(),
+    },
+  ).describe("The validation error(s)");
+
+export const GetcollectSessionByTokenStatusCode = {
+  FourHundredAndFour: 404,
+} as const;
+export type GetcollectSessionByTokenStatusCode = ClosedEnum<
+  typeof GetcollectSessionByTokenStatusCode
+>;
+
+export const GetcollectSessionByTokenStatusCode$zodSchema = z.literal(404);
+
+export const GetcollectSessionByTokenType = {
+  NotFound: "not_found",
+} as const;
+export type GetcollectSessionByTokenType = ClosedEnum<
+  typeof GetcollectSessionByTokenType
+>;
+
+export const GetcollectSessionByTokenType$zodSchema = z.enum([
+  "not_found",
+]);
+
+export const GetcollectSessionByTokenCode = {
+  CollectTokenNotFound: "collect_token_not_found",
+} as const;
+export type GetcollectSessionByTokenCode = ClosedEnum<
+  typeof GetcollectSessionByTokenCode
+>;
+
+export const GetcollectSessionByTokenCode$zodSchema = z.enum([
+  "collect_token_not_found",
+]);
+
+/**
+ * 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.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.union([
+  CollectSessionByToken$zodSchema,
+  z.lazy(() => GetcollectSessionByTokenNotFoundResponseBody$zodSchema),
+  BadRequest$zodSchema,
+  RateLimit$zodSchema,
+  z.lazy(() =>
+    GetcollectSessionByTokenUnprocessableEntityResponseBody$zodSchema
+  ),
+]);