@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/createtaskop.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 { 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 };
 
-export const CreateTaskRequest$zodSchema: z.ZodType<
-  CreateTaskRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  TaskCreate: TaskCreate$zodSchema,
-  xClientId: z.string(),
-});
+export const CreateTaskRequest$zodSchema: z.ZodType<CreateTaskRequest> = z
+  .object({
+    TaskCreate: TaskCreate$zodSchema.describe("Task create"),
+    xClientId: z.string(),
+  });
 
 export type CreateTaskPath = string | number;
 
-export const CreateTaskPath$zodSchema: z.ZodType<
-  CreateTaskPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const CreateTaskPath$zodSchema: z.ZodType<CreateTaskPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -37,11 +30,7 @@ export type CreateTaskIssue = {
   message?: string | undefined;
 };
 
-export const CreateTaskIssue$zodSchema: z.ZodType<
-  CreateTaskIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const CreateTaskIssue$zodSchema: z.ZodType<CreateTaskIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -52,11 +41,7 @@ export const CreateTaskIssue$zodSchema: z.ZodType<
 
 export type CreateTaskError = { issues: Array<CreateTaskIssue>; name: string };
 
-export const CreateTaskError$zodSchema: z.ZodType<
-  CreateTaskError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const CreateTaskError$zodSchema: z.ZodType<CreateTaskError> = z.object({
   issues: z.array(z.lazy(() => CreateTaskIssue$zodSchema)),
   name: z.string(),
 });
@@ -70,85 +55,126 @@ export type CreateTaskUnprocessableEntityResponseBody = {
 };
 
 export const CreateTaskUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  CreateTaskUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateTaskUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => CreateTaskError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
-export const CreateTaskStatusCode$zodSchema = z.literal(403);
+export const CreateTaskForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateTaskForbiddenStatusCode = ClosedEnum<
+  typeof CreateTaskForbiddenStatusCode
+>;
+
+export const CreateTaskForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type CreateTaskStatusCode = z.infer<
-  typeof CreateTaskStatusCode$zodSchema
+export const CreateTaskForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateTaskForbiddenType = ClosedEnum<
+  typeof CreateTaskForbiddenType
 >;
 
-export const CreateTaskType$zodSchema = z.enum([
+export const CreateTaskForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateTaskType = z.infer<typeof CreateTaskType$zodSchema>;
+export const CreateTaskForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateTaskForbiddenCode = ClosedEnum<
+  typeof CreateTaskForbiddenCode
+>;
 
-export const CreateTaskCode$zodSchema = z.enum([
+export const CreateTaskForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateTaskCode = z.infer<typeof CreateTaskCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type CreateTaskForbiddenResponseBody = {
-  status_code: CreateTaskStatusCode;
-  type: CreateTaskType;
-  code: CreateTaskCode;
+  status_code: CreateTaskForbiddenStatusCode;
+  type: CreateTaskForbiddenType;
+  code: CreateTaskForbiddenCode;
   message: string;
 };
 
 export const CreateTaskForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateTaskForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateTaskForbiddenResponseBody
 > = z.object({
-  code: CreateTaskCode$zodSchema,
+  code: CreateTaskForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: CreateTaskStatusCode$zodSchema,
-  type: CreateTaskType$zodSchema,
+  status_code: CreateTaskForbiddenStatusCode$zodSchema,
+  type: CreateTaskForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type CreateTaskResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  Task?: Task | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | CreateTaskForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | CreateTaskUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const CreateTaskStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type CreateTaskStatusCode400 = ClosedEnum<
+  typeof CreateTaskStatusCode400
+>;
+
+export const CreateTaskStatusCode400$zodSchema = z.literal(400);
+
+export const CreateTaskBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateTaskBadRequestType = ClosedEnum<
+  typeof CreateTaskBadRequestType
+>;
+
+export const CreateTaskBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const CreateTaskCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type CreateTaskCodeMissingClientID = ClosedEnum<
+  typeof CreateTaskCodeMissingClientID
+>;
+
+export const CreateTaskCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type CreateTaskBadRequestResponseBody = {
+  status_code: CreateTaskStatusCode400;
+  type: CreateTaskBadRequestType;
+  code: CreateTaskCodeMissingClientID;
+  message: string;
 };
 
-export const CreateTaskResponse$zodSchema: z.ZodType<
-  CreateTaskResponse,
-  z.ZodTypeDef,
-  unknown
+export const CreateTaskBadRequestResponseBody$zodSchema: z.ZodType<
+  CreateTaskBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  Task: Task$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(),
-});
+  code: CreateTaskCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: CreateTaskStatusCode400$zodSchema,
+  type: CreateTaskBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type CreateTaskResponse =
+  | Task
+  | CreateTaskBadRequestResponseBody
+  | AuthError
+  | CreateTaskForbiddenResponseBody
+  | RateLimit
+  | CreateTaskUnprocessableEntityResponseBody;
+
+export const CreateTaskResponse$zodSchema: z.ZodType<CreateTaskResponse> = z
+  .union([
+    Task$zodSchema,
+    z.lazy(() => CreateTaskBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => CreateTaskForbiddenResponseBody$zodSchema),
+    RateLimit$zodSchema,
+    z.lazy(() => CreateTaskUnprocessableEntityResponseBody$zodSchema),
+  ]);

package/src/models/createworkspacememberop.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 { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 import {
   WorkspaceMember,
@@ -22,11 +22,11 @@ export type CreateWorkspaceMemberRequest = {
 };
 
 export const CreateWorkspaceMemberRequest$zodSchema: z.ZodType<
-  CreateWorkspaceMemberRequest,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberRequest
 > = z.object({
-  WorkspaceMemberCreate: WorkspaceMemberCreate$zodSchema,
+  WorkspaceMemberCreate: WorkspaceMemberCreate$zodSchema.describe(
+    "Workspace member create",
+  ),
   id: z.string(),
   xClientId: z.string(),
 });
@@ -34,9 +34,7 @@ export const CreateWorkspaceMemberRequest$zodSchema: z.ZodType<
 export type CreateWorkspaceMemberPath = string | number;
 
 export const CreateWorkspaceMemberPath$zodSchema: z.ZodType<
-  CreateWorkspaceMemberPath,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberPath
 > = z.union([
   z.string(),
   z.number(),
@@ -49,9 +47,7 @@ export type CreateWorkspaceMemberIssue = {
 };
 
 export const CreateWorkspaceMemberIssue$zodSchema: z.ZodType<
-  CreateWorkspaceMemberIssue,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberIssue
 > = z.object({
   code: z.string(),
   message: z.string().optional(),
@@ -67,9 +63,7 @@ export type CreateWorkspaceMemberError = {
 };
 
 export const CreateWorkspaceMemberError$zodSchema: z.ZodType<
-  CreateWorkspaceMemberError,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberError
 > = z.object({
   issues: z.array(z.lazy(() => CreateWorkspaceMemberIssue$zodSchema)),
   name: z.string(),
@@ -84,90 +78,128 @@ export type CreateWorkspaceMemberUnprocessableEntityResponseBody = {
 };
 
 export const CreateWorkspaceMemberUnprocessableEntityResponseBody$zodSchema:
-  z.ZodType<
-    CreateWorkspaceMemberUnprocessableEntityResponseBody,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
+  z.ZodType<CreateWorkspaceMemberUnprocessableEntityResponseBody> = z.object({
     error: z.lazy(() => CreateWorkspaceMemberError$zodSchema),
     success: z.boolean(),
   }).describe("The validation error(s)");
 
-export const CreateWorkspaceMemberStatusCode$zodSchema = z.literal(403);
+export const CreateWorkspaceMemberForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateWorkspaceMemberForbiddenStatusCode = ClosedEnum<
+  typeof CreateWorkspaceMemberForbiddenStatusCode
+>;
+
+export const CreateWorkspaceMemberForbiddenStatusCode$zodSchema = z.literal(
+  403,
+);
 
-export type CreateWorkspaceMemberStatusCode = z.infer<
-  typeof CreateWorkspaceMemberStatusCode$zodSchema
+export const CreateWorkspaceMemberForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateWorkspaceMemberForbiddenType = ClosedEnum<
+  typeof CreateWorkspaceMemberForbiddenType
 >;
 
-export const CreateWorkspaceMemberType$zodSchema = z.enum([
+export const CreateWorkspaceMemberForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateWorkspaceMemberType = z.infer<
-  typeof CreateWorkspaceMemberType$zodSchema
+export const CreateWorkspaceMemberForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateWorkspaceMemberForbiddenCode = ClosedEnum<
+  typeof CreateWorkspaceMemberForbiddenCode
 >;
 
-export const CreateWorkspaceMemberCode$zodSchema = z.enum([
+export const CreateWorkspaceMemberForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateWorkspaceMemberCode = z.infer<
-  typeof CreateWorkspaceMemberCode$zodSchema
->;
-
 /**
  * Missing scope
  */
 export type CreateWorkspaceMemberForbiddenResponseBody = {
-  status_code: CreateWorkspaceMemberStatusCode;
-  type: CreateWorkspaceMemberType;
-  code: CreateWorkspaceMemberCode;
+  status_code: CreateWorkspaceMemberForbiddenStatusCode;
+  type: CreateWorkspaceMemberForbiddenType;
+  code: CreateWorkspaceMemberForbiddenCode;
   message: string;
 };
 
 export const CreateWorkspaceMemberForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateWorkspaceMemberForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateWorkspaceMemberForbiddenResponseBody
 > = z.object({
-  code: CreateWorkspaceMemberCode$zodSchema,
+  code: CreateWorkspaceMemberForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: CreateWorkspaceMemberStatusCode$zodSchema,
-  type: CreateWorkspaceMemberType$zodSchema,
+  status_code: CreateWorkspaceMemberForbiddenStatusCode$zodSchema,
+  type: CreateWorkspaceMemberForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type CreateWorkspaceMemberResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  WorkspaceMember?: WorkspaceMember | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | CreateWorkspaceMemberForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | CreateWorkspaceMemberUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const CreateWorkspaceMemberStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type CreateWorkspaceMemberStatusCode400 = ClosedEnum<
+  typeof CreateWorkspaceMemberStatusCode400
+>;
+
+export const CreateWorkspaceMemberStatusCode400$zodSchema = z.literal(400);
+
+export const CreateWorkspaceMemberBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateWorkspaceMemberBadRequestType = ClosedEnum<
+  typeof CreateWorkspaceMemberBadRequestType
+>;
+
+export const CreateWorkspaceMemberBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const CreateWorkspaceMemberCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type CreateWorkspaceMemberCodeMissingClientID = ClosedEnum<
+  typeof CreateWorkspaceMemberCodeMissingClientID
+>;
+
+export const CreateWorkspaceMemberCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type CreateWorkspaceMemberBadRequestResponseBody = {
+  status_code: CreateWorkspaceMemberStatusCode400;
+  type: CreateWorkspaceMemberBadRequestType;
+  code: CreateWorkspaceMemberCodeMissingClientID;
+  message: string;
 };
 
-export const CreateWorkspaceMemberResponse$zodSchema: z.ZodType<
-  CreateWorkspaceMemberResponse,
-  z.ZodTypeDef,
-  unknown
+export const CreateWorkspaceMemberBadRequestResponseBody$zodSchema: z.ZodType<
+  CreateWorkspaceMemberBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  WorkspaceMember: WorkspaceMember$zodSchema.optional(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    CreateWorkspaceMemberForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    CreateWorkspaceMemberUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: CreateWorkspaceMemberCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: CreateWorkspaceMemberStatusCode400$zodSchema,
+  type: CreateWorkspaceMemberBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type CreateWorkspaceMemberResponse =
+  | WorkspaceMember
+  | CreateWorkspaceMemberBadRequestResponseBody
+  | AuthError
+  | CreateWorkspaceMemberForbiddenResponseBody
+  | RateLimit
+  | CreateWorkspaceMemberUnprocessableEntityResponseBody;
+
+export const CreateWorkspaceMemberResponse$zodSchema: z.ZodType<
+  CreateWorkspaceMemberResponse
+> = z.union([
+  WorkspaceMember$zodSchema,
+  z.lazy(() => CreateWorkspaceMemberBadRequestResponseBody$zodSchema),
+  AuthError$zodSchema,
+  z.lazy(() => CreateWorkspaceMemberForbiddenResponseBody$zodSchema),
+  RateLimit$zodSchema,
+  z.lazy(() => CreateWorkspaceMemberUnprocessableEntityResponseBody$zodSchema),
+]);