@steuerboard/mcp 0.0.7 → 0.1.0

package/src/models/createfileop.ts

@@ -3,38 +3,23 @@
  */
 
 import * as z from "zod";
+import { AuthError, AuthError$zodSchema } from "./autherror.js";
+import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
 import { FileT, FileT$zodSchema } from "./file.js";
 import { FileCreate, FileCreate$zodSchema } from "./filecreate.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
-export type CreateFileRequest = {
-  xClientId: string;
-  FileCreate?: FileCreate | undefined;
-};
+export type CreateFileRequest = { xClientId: string; FileCreate: FileCreate };
 
 export const CreateFileRequest$zodSchema: z.ZodType<
   CreateFileRequest,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  FileCreate: FileCreate$zodSchema.optional(),
+  FileCreate: FileCreate$zodSchema,
   xClientId: z.string(),
 });
 
-/**
- * Rate limit exceeded. Slow down requests or retry after the time specified in the rate limit response headers
- */
-export type CreateFileTooManyRequestsResponseBody = { message: string };
-
-export const CreateFileTooManyRequestsResponseBody$zodSchema: z.ZodType<
-  CreateFileTooManyRequestsResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  message: z.string(),
-}).describe(
-  "Rate limit exceeded. Slow down requests or retry after the time specified in the rate limit response headers",
-);
-
 export type CreateFilePath = string | number;
 
 export const CreateFilePath$zodSchema: z.ZodType<
@@ -93,33 +78,97 @@ export const CreateFileUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("The validation error(s)");
 
+export const RequestEntityTooLargeType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export type RequestEntityTooLargeType = z.infer<
+  typeof RequestEntityTooLargeType$zodSchema
+>;
+
+export const RequestEntityTooLargeCode$zodSchema = z.enum([
+  "payload_too_large",
+]);
+
+export type RequestEntityTooLargeCode = z.infer<
+  typeof RequestEntityTooLargeCode$zodSchema
+>;
+
 /**
  * Payload too large
  */
-export type CreateFileRequestEntityTooLargeResponseBody = { message: string };
+export type CreateFileRequestEntityTooLargeResponseBody = {
+  status_code: number;
+  type: RequestEntityTooLargeType;
+  code: RequestEntityTooLargeCode;
+  message: string;
+};
 
 export const CreateFileRequestEntityTooLargeResponseBody$zodSchema: z.ZodType<
   CreateFileRequestEntityTooLargeResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  code: RequestEntityTooLargeCode$zodSchema,
   message: z.string(),
+  status_code: z.number(),
+  type: RequestEntityTooLargeType$zodSchema,
 }).describe("Payload too large");
 
+export const CreateFileForbiddenType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export type CreateFileForbiddenType = z.infer<
+  typeof CreateFileForbiddenType$zodSchema
+>;
+
+export const CreateFileForbiddenCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+export type CreateFileForbiddenCode = z.infer<
+  typeof CreateFileForbiddenCode$zodSchema
+>;
+
+/**
+ * Missing scope
+ */
+export type CreateFileForbiddenResponseBody = {
+  status_code: number;
+  type: CreateFileForbiddenType;
+  code: CreateFileForbiddenCode;
+  message: string;
+};
+
+export const CreateFileForbiddenResponseBody$zodSchema: z.ZodType<
+  CreateFileForbiddenResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: CreateFileForbiddenCode$zodSchema,
+  message: z.string(),
+  status_code: z.number(),
+  type: CreateFileForbiddenType$zodSchema,
+}).describe("Missing scope");
+
 export type CreateFileResponse = {
   ContentType: string;
   StatusCode: number;
   RawResponse: Response;
   FileT?: FileT | undefined;
+  bad_request?: BadRequest | undefined;
+  auth_error?: AuthError | undefined;
+  fourHundredAndThreeApplicationJsonObject?:
+    | CreateFileForbiddenResponseBody
+    | undefined;
   fourHundredAndThirteenApplicationJsonObject?:
     | CreateFileRequestEntityTooLargeResponseBody
     | undefined;
   fourHundredAndTwentyTwoApplicationJsonObject?:
     | CreateFileUnprocessableEntityResponseBody
     | undefined;
-  fourHundredAndTwentyNineApplicationJsonObject?:
-    | CreateFileTooManyRequestsResponseBody
-    | undefined;
+  rate_limit?: RateLimit | undefined;
 };
 
 export const CreateFileResponse$zodSchema: z.ZodType<
@@ -131,13 +180,16 @@ export const CreateFileResponse$zodSchema: z.ZodType<
   FileT: FileT$zodSchema.optional(),
   RawResponse: z.instanceof(Response),
   StatusCode: z.number().int(),
+  auth_error: AuthError$zodSchema.optional(),
+  bad_request: BadRequest$zodSchema.optional(),
   fourHundredAndThirteenApplicationJsonObject: z.lazy(() =>
     CreateFileRequestEntityTooLargeResponseBody$zodSchema
   ).optional(),
-  fourHundredAndTwentyNineApplicationJsonObject: z.lazy(() =>
-    CreateFileTooManyRequestsResponseBody$zodSchema
+  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
+    CreateFileForbiddenResponseBody$zodSchema
   ).optional(),
   fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
     CreateFileUnprocessableEntityResponseBody$zodSchema
   ).optional(),
+  rate_limit: RateLimit$zodSchema.optional(),
 });

package/src/models/createtaskop.ts

@@ -3,20 +3,20 @@
  */
 
 import * as z from "zod";
+import { AuthError, AuthError$zodSchema } from "./autherror.js";
+import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import { Task, Task$zodSchema } from "./task.js";
 import { TaskCreate, TaskCreate$zodSchema } from "./taskcreate.js";
 
-export type CreateTaskRequest = {
-  xClientId: string;
-  TaskCreate?: TaskCreate | undefined;
-};
+export type CreateTaskRequest = { xClientId: string; TaskCreate: TaskCreate };
 
 export const CreateTaskRequest$zodSchema: z.ZodType<
   CreateTaskRequest,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  TaskCreate: TaskCreate$zodSchema.optional(),
+  TaskCreate: TaskCreate$zodSchema,
   xClientId: z.string(),
 });
 
@@ -64,13 +64,13 @@ export const CreateTaskError$zodSchema: z.ZodType<
 /**
  * The validation error(s)
  */
-export type CreateTaskResponseBody = {
+export type CreateTaskUnprocessableEntityResponseBody = {
   success: boolean;
   error: CreateTaskError;
 };
 
-export const CreateTaskResponseBody$zodSchema: z.ZodType<
-  CreateTaskResponseBody,
+export const CreateTaskUnprocessableEntityResponseBody$zodSchema: z.ZodType<
+  CreateTaskUnprocessableEntityResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -78,12 +78,53 @@ export const CreateTaskResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("The validation error(s)");
 
+export const CreateTaskType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export type CreateTaskType = z.infer<typeof CreateTaskType$zodSchema>;
+
+export const CreateTaskCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+export type CreateTaskCode = z.infer<typeof CreateTaskCode$zodSchema>;
+
+/**
+ * Missing scope
+ */
+export type CreateTaskForbiddenResponseBody = {
+  status_code: number;
+  type: CreateTaskType;
+  code: CreateTaskCode;
+  message: string;
+};
+
+export const CreateTaskForbiddenResponseBody$zodSchema: z.ZodType<
+  CreateTaskForbiddenResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: CreateTaskCode$zodSchema,
+  message: z.string(),
+  status_code: z.number(),
+  type: CreateTaskType$zodSchema,
+}).describe("Missing scope");
+
 export type CreateTaskResponse = {
   ContentType: string;
   StatusCode: number;
   RawResponse: Response;
   Task?: Task | undefined;
-  object?: CreateTaskResponseBody | undefined;
+  bad_request?: BadRequest | undefined;
+  auth_error?: AuthError | undefined;
+  fourHundredAndThreeApplicationJsonObject?:
+    | CreateTaskForbiddenResponseBody
+    | undefined;
+  fourHundredAndTwentyTwoApplicationJsonObject?:
+    | CreateTaskUnprocessableEntityResponseBody
+    | undefined;
+  rate_limit?: RateLimit | undefined;
 };
 
 export const CreateTaskResponse$zodSchema: z.ZodType<
@@ -95,5 +136,13 @@ export const CreateTaskResponse$zodSchema: z.ZodType<
   RawResponse: z.instanceof(Response),
   StatusCode: z.number().int(),
   Task: Task$zodSchema.optional(),
-  object: z.lazy(() => CreateTaskResponseBody$zodSchema).optional(),
+  auth_error: AuthError$zodSchema.optional(),
+  bad_request: BadRequest$zodSchema.optional(),
+  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
+    CreateTaskForbiddenResponseBody$zodSchema
+  ).optional(),
+  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
+    CreateTaskUnprocessableEntityResponseBody$zodSchema
+  ).optional(),
+  rate_limit: RateLimit$zodSchema.optional(),
 });

package/src/models/createworkspaceop.ts

@@ -0,0 +1,158 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { AuthError, AuthError$zodSchema } from "./autherror.js";
+import { BadRequest, BadRequest$zodSchema } from "./badrequest.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+import { Workspace, Workspace$zodSchema } from "./workspace.js";
+import {
+  WorkspaceCreate,
+  WorkspaceCreate$zodSchema,
+} from "./workspacecreate.js";
+
+export type CreateWorkspaceRequest = {
+  xClientId: string;
+  WorkspaceCreate: WorkspaceCreate;
+};
+
+export const CreateWorkspaceRequest$zodSchema: z.ZodType<
+  CreateWorkspaceRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  WorkspaceCreate: WorkspaceCreate$zodSchema,
+  xClientId: z.string(),
+});
+
+export type CreateWorkspacePath = string | number;
+
+export const CreateWorkspacePath$zodSchema: z.ZodType<
+  CreateWorkspacePath,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.string(),
+  z.number(),
+]);
+
+export type CreateWorkspaceIssue = {
+  code: string;
+  path: Array<string | number>;
+  message?: string | undefined;
+};
+
+export const CreateWorkspaceIssue$zodSchema: z.ZodType<
+  CreateWorkspaceIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  message: z.string().optional(),
+  path: z.array(z.union([
+    z.string(),
+    z.number(),
+  ])),
+});
+
+export type CreateWorkspaceError = {
+  issues: Array<CreateWorkspaceIssue>;
+  name: string;
+};
+
+export const CreateWorkspaceError$zodSchema: z.ZodType<
+  CreateWorkspaceError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  issues: z.array(z.lazy(() => CreateWorkspaceIssue$zodSchema)),
+  name: z.string(),
+});
+
+/**
+ * The validation error(s)
+ */
+export type CreateWorkspaceUnprocessableEntityResponseBody = {
+  success: boolean;
+  error: CreateWorkspaceError;
+};
+
+export const CreateWorkspaceUnprocessableEntityResponseBody$zodSchema:
+  z.ZodType<
+    CreateWorkspaceUnprocessableEntityResponseBody,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    error: z.lazy(() => CreateWorkspaceError$zodSchema),
+    success: z.boolean(),
+  }).describe("The validation error(s)");
+
+export const CreateWorkspaceType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export type CreateWorkspaceType = z.infer<typeof CreateWorkspaceType$zodSchema>;
+
+export const CreateWorkspaceCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+export type CreateWorkspaceCode = z.infer<typeof CreateWorkspaceCode$zodSchema>;
+
+/**
+ * Missing scope
+ */
+export type CreateWorkspaceForbiddenResponseBody = {
+  status_code: number;
+  type: CreateWorkspaceType;
+  code: CreateWorkspaceCode;
+  message: string;
+};
+
+export const CreateWorkspaceForbiddenResponseBody$zodSchema: z.ZodType<
+  CreateWorkspaceForbiddenResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: CreateWorkspaceCode$zodSchema,
+  message: z.string(),
+  status_code: z.number(),
+  type: CreateWorkspaceType$zodSchema,
+}).describe("Missing scope");
+
+export type CreateWorkspaceResponse = {
+  ContentType: string;
+  StatusCode: number;
+  RawResponse: Response;
+  Workspace?: Workspace | undefined;
+  bad_request?: BadRequest | undefined;
+  auth_error?: AuthError | undefined;
+  fourHundredAndThreeApplicationJsonObject?:
+    | CreateWorkspaceForbiddenResponseBody
+    | undefined;
+  fourHundredAndTwentyTwoApplicationJsonObject?:
+    | CreateWorkspaceUnprocessableEntityResponseBody
+    | undefined;
+  rate_limit?: RateLimit | undefined;
+};
+
+export const CreateWorkspaceResponse$zodSchema: z.ZodType<
+  CreateWorkspaceResponse,
+  z.ZodTypeDef,
+  unknown
+> = 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(() =>
+    CreateWorkspaceForbiddenResponseBody$zodSchema
+  ).optional(),
+  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
+    CreateWorkspaceUnprocessableEntityResponseBody$zodSchema
+  ).optional(),
+  rate_limit: RateLimit$zodSchema.optional(),
+});

package/src/models/deletefileop.ts

@@ -3,7 +3,11 @@
  */
 
 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";
 
 export type DeleteFileRequest = { id: string; xClientId: string };
 
@@ -16,21 +20,6 @@ export const DeleteFileRequest$zodSchema: z.ZodType<
   xClientId: z.string(),
 });
 
-/**
- * Rate limit exceeded. Slow down requests or retry after the time specified in the rate limit response headers
- */
-export type DeleteFileTooManyRequestsResponseBody = { message: string };
-
-export const DeleteFileTooManyRequestsResponseBody$zodSchema: z.ZodType<
-  DeleteFileTooManyRequestsResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  message: z.string(),
-}).describe(
-  "Rate limit exceeded. Slow down requests or retry after the time specified in the rate limit response headers",
-);
-
 export type DeleteFilePath = string | number;
 
 export const DeleteFilePath$zodSchema: z.ZodType<
@@ -89,33 +78,54 @@ export const DeleteFileUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("Invalid id error");
 
+export const DeleteFileType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export type DeleteFileType = z.infer<typeof DeleteFileType$zodSchema>;
+
+export const DeleteFileCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+export type DeleteFileCode = z.infer<typeof DeleteFileCode$zodSchema>;
+
 /**
- * File not found
+ * Missing scope
  */
-export type DeleteFileNotFoundResponseBody = { message: string };
+export type DeleteFileForbiddenResponseBody = {
+  status_code: number;
+  type: DeleteFileType;
+  code: DeleteFileCode;
+  message: string;
+};
 
-export const DeleteFileNotFoundResponseBody$zodSchema: z.ZodType<
-  DeleteFileNotFoundResponseBody,
+export const DeleteFileForbiddenResponseBody$zodSchema: z.ZodType<
+  DeleteFileForbiddenResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  code: DeleteFileCode$zodSchema,
   message: z.string(),
-}).describe("File not found");
+  status_code: z.number(),
+  type: DeleteFileType$zodSchema,
+}).describe("Missing scope");
 
 export type DeleteFileResponse = {
   ContentType: string;
   StatusCode: number;
   RawResponse: Response;
   DeleteResponse?: DeleteResponse | undefined;
-  fourHundredAndFourApplicationJsonObject?:
-    | DeleteFileNotFoundResponseBody
+  bad_request?: BadRequest | undefined;
+  auth_error?: AuthError | undefined;
+  fourHundredAndThreeApplicationJsonObject?:
+    | DeleteFileForbiddenResponseBody
     | undefined;
+  not_found?: NotFound | undefined;
   fourHundredAndTwentyTwoApplicationJsonObject?:
     | DeleteFileUnprocessableEntityResponseBody
     | undefined;
-  fourHundredAndTwentyNineApplicationJsonObject?:
-    | DeleteFileTooManyRequestsResponseBody
-    | undefined;
+  rate_limit?: RateLimit | undefined;
 };
 
 export const DeleteFileResponse$zodSchema: z.ZodType<
@@ -127,13 +137,14 @@ export const DeleteFileResponse$zodSchema: z.ZodType<
   DeleteResponse: DeleteResponse$zodSchema.optional(),
   RawResponse: z.instanceof(Response),
   StatusCode: z.number().int(),
-  fourHundredAndFourApplicationJsonObject: z.lazy(() =>
-    DeleteFileNotFoundResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyNineApplicationJsonObject: z.lazy(() =>
-    DeleteFileTooManyRequestsResponseBody$zodSchema
+  auth_error: AuthError$zodSchema.optional(),
+  bad_request: BadRequest$zodSchema.optional(),
+  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
+    DeleteFileForbiddenResponseBody$zodSchema
   ).optional(),
   fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
     DeleteFileUnprocessableEntityResponseBody$zodSchema
   ).optional(),
+  not_found: NotFound$zodSchema.optional(),
+  rate_limit: RateLimit$zodSchema.optional(),
 });

package/src/models/deletetaskop.ts

@@ -3,9 +3,13 @@
  */
 
 import * as z from "zod";
+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 { Task, Task$zodSchema } from "./task.js";
 
-export type DeleteTaskRequest = { id: string };
+export type DeleteTaskRequest = { id: string; xClientId: string };
 
 export const DeleteTaskRequest$zodSchema: z.ZodType<
   DeleteTaskRequest,
@@ -13,6 +17,7 @@ export const DeleteTaskRequest$zodSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string(),
+  xClientId: z.string(),
 });
 
 export type DeleteTaskPath = string | number;
@@ -73,30 +78,54 @@ export const DeleteTaskUnprocessableEntityResponseBody$zodSchema: z.ZodType<
   success: z.boolean(),
 }).describe("Invalid id error");
 
+export const DeleteTaskType$zodSchema = z.enum([
+  "auth_error",
+]);
+
+export type DeleteTaskType = z.infer<typeof DeleteTaskType$zodSchema>;
+
+export const DeleteTaskCode$zodSchema = z.enum([
+  "missing_scope",
+]);
+
+export type DeleteTaskCode = z.infer<typeof DeleteTaskCode$zodSchema>;
+
 /**
- * Task not found
+ * Missing scope
  */
-export type DeleteTaskNotFoundResponseBody = { message: string };
+export type DeleteTaskForbiddenResponseBody = {
+  status_code: number;
+  type: DeleteTaskType;
+  code: DeleteTaskCode;
+  message: string;
+};
 
-export const DeleteTaskNotFoundResponseBody$zodSchema: z.ZodType<
-  DeleteTaskNotFoundResponseBody,
+export const DeleteTaskForbiddenResponseBody$zodSchema: z.ZodType<
+  DeleteTaskForbiddenResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  code: DeleteTaskCode$zodSchema,
   message: z.string(),
-}).describe("Task not found");
+  status_code: z.number(),
+  type: DeleteTaskType$zodSchema,
+}).describe("Missing scope");
 
 export type DeleteTaskResponse = {
   ContentType: string;
   StatusCode: number;
   RawResponse: Response;
   Task?: Task | undefined;
-  fourHundredAndFourApplicationJsonObject?:
-    | DeleteTaskNotFoundResponseBody
+  bad_request?: BadRequest | undefined;
+  auth_error?: AuthError | undefined;
+  fourHundredAndThreeApplicationJsonObject?:
+    | DeleteTaskForbiddenResponseBody
     | undefined;
+  not_found?: NotFound | undefined;
   fourHundredAndTwentyTwoApplicationJsonObject?:
     | DeleteTaskUnprocessableEntityResponseBody
     | undefined;
+  rate_limit?: RateLimit | undefined;
 };
 
 export const DeleteTaskResponse$zodSchema: z.ZodType<
@@ -108,10 +137,14 @@ export const DeleteTaskResponse$zodSchema: z.ZodType<
   RawResponse: z.instanceof(Response),
   StatusCode: z.number().int(),
   Task: Task$zodSchema.optional(),
-  fourHundredAndFourApplicationJsonObject: z.lazy(() =>
-    DeleteTaskNotFoundResponseBody$zodSchema
+  auth_error: AuthError$zodSchema.optional(),
+  bad_request: BadRequest$zodSchema.optional(),
+  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
+    DeleteTaskForbiddenResponseBody$zodSchema
   ).optional(),
   fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
     DeleteTaskUnprocessableEntityResponseBody$zodSchema
   ).optional(),
+  not_found: NotFound$zodSchema.optional(),
+  rate_limit: RateLimit$zodSchema.optional(),
 });