@steuerboard/mcp 0.3.4 → 0.4.0

package/src/models/completesessionbody.ts

@@ -3,10 +3,21 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 
 /**
  * Explicit completion outcome picked by the client: 'complete' (everything provided), 'incomplete' (will provide the rest later), 'incomplete_finished' (cannot provide the rest; clientNote explains).
  */
+export const Outcome = {
+  Complete: "complete",
+  Incomplete: "incomplete",
+  IncompleteFinished: "incomplete_finished",
+} as const;
+/**
+ * Explicit completion outcome picked by the client: 'complete' (everything provided), 'incomplete' (will provide the rest later), 'incomplete_finished' (cannot provide the rest; clientNote explains).
+ */
+export type Outcome = ClosedEnum<typeof Outcome>;
+
 export const Outcome$zodSchema = z.enum([
   "complete",
   "incomplete",
@@ -15,18 +26,15 @@ export const Outcome$zodSchema = z.enum([
   "Explicit completion outcome picked by the client: 'complete' (everything provided), 'incomplete' (will provide the rest later), 'incomplete_finished' (cannot provide the rest; clientNote explains).",
 );
 
-export type Outcome = z.infer<typeof Outcome$zodSchema>;
-
 export type CompleteSessionBody = {
   clientNote?: string | undefined;
   outcome?: Outcome | undefined;
 };
 
-export const CompleteSessionBody$zodSchema: z.ZodType<
-  CompleteSessionBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  clientNote: z.string().optional(),
-  outcome: Outcome$zodSchema.optional(),
-});
+export const CompleteSessionBody$zodSchema: z.ZodType<CompleteSessionBody> = z
+  .object({
+    clientNote: z.string().optional(),
+    outcome: Outcome$zodSchema.optional().describe(
+      "Explicit completion outcome picked by the client: 'complete' (everything provided), 'incomplete' (will provide the rest later), 'incomplete_finished' (cannot provide the rest; clientNote explains).",
+    ),
+  });

package/src/models/completesessionresponse.ts

@@ -7,9 +7,7 @@ import * as z from "zod";
 export type CompleteSessionResponse = { success: boolean };
 
 export const CompleteSessionResponse$zodSchema: z.ZodType<
-  CompleteSessionResponse,
-  z.ZodTypeDef,
-  unknown
+  CompleteSessionResponse
 > = z.object({
   success: z.boolean(),
 });

package/src/models/conflict.ts

@@ -3,23 +3,33 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+export const ConflictStatusCode = {
+  FourHundredAndNine: 409,
+} as const;
+export type ConflictStatusCode = ClosedEnum<typeof ConflictStatusCode>;
 
 export const ConflictStatusCode$zodSchema = z.literal(409);
 
-export type ConflictStatusCode = z.infer<typeof ConflictStatusCode$zodSchema>;
+export const ConflictType = {
+  Conflict: "conflict",
+} as const;
+export type ConflictType = ClosedEnum<typeof ConflictType>;
 
 export const ConflictType$zodSchema = z.enum([
   "conflict",
 ]);
 
-export type ConflictType = z.infer<typeof ConflictType$zodSchema>;
+export const ConflictCode = {
+  Conflict: "conflict",
+} as const;
+export type ConflictCode = ClosedEnum<typeof ConflictCode>;
 
 export const ConflictCode$zodSchema = z.enum([
   "conflict",
 ]);
 
-export type ConflictCode = z.infer<typeof ConflictCode$zodSchema>;
-
 export type Conflict = {
   status_code: ConflictStatusCode;
   type: ConflictType;
@@ -27,10 +37,9 @@ export type Conflict = {
   message: string;
 };
 
-export const Conflict$zodSchema: z.ZodType<Conflict, z.ZodTypeDef, unknown> = z
-  .object({
-    code: ConflictCode$zodSchema,
-    message: z.string(),
-    status_code: ConflictStatusCode$zodSchema,
-    type: ConflictType$zodSchema,
-  });
+export const Conflict$zodSchema: z.ZodType<Conflict> = z.object({
+  code: ConflictCode$zodSchema,
+  message: z.string(),
+  status_code: ConflictStatusCode$zodSchema,
+  type: ConflictType$zodSchema,
+});

package/src/models/createclientop.ts

@@ -3,17 +3,14 @@
  */
 
 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 { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type CreateClientPath = string | number;
 
-export const CreateClientPath$zodSchema: z.ZodType<
-  CreateClientPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const CreateClientPath$zodSchema: z.ZodType<CreateClientPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -24,32 +21,26 @@ export type CreateClientIssue = {
   message?: string | undefined;
 };
 
-export const CreateClientIssue$zodSchema: z.ZodType<
-  CreateClientIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  message: z.string().optional(),
-  path: z.array(z.union([
-    z.string(),
-    z.number(),
-  ])),
-});
+export const CreateClientIssue$zodSchema: z.ZodType<CreateClientIssue> = z
+  .object({
+    code: z.string(),
+    message: z.string().optional(),
+    path: z.array(z.union([
+      z.string(),
+      z.number(),
+    ])),
+  });
 
 export type CreateClientError = {
   issues: Array<CreateClientIssue>;
   name: string;
 };
 
-export const CreateClientError$zodSchema: z.ZodType<
-  CreateClientError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  issues: z.array(z.lazy(() => CreateClientIssue$zodSchema)),
-  name: z.string(),
-});
+export const CreateClientError$zodSchema: z.ZodType<CreateClientError> = z
+  .object({
+    issues: z.array(z.lazy(() => CreateClientIssue$zodSchema)),
+    name: z.string(),
+  });
 
 /**
  * The validation error(s)
@@ -60,32 +51,37 @@ export type CreateClientUnprocessableEntityResponseBody = {
 };
 
 export const CreateClientUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  CreateClientUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateClientUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => CreateClientError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
+export const CreateClientStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateClientStatusCode = ClosedEnum<typeof CreateClientStatusCode>;
+
 export const CreateClientStatusCode$zodSchema = z.literal(403);
 
-export type CreateClientStatusCode = z.infer<
-  typeof CreateClientStatusCode$zodSchema
->;
+export const CreateClientType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateClientType = ClosedEnum<typeof CreateClientType>;
 
 export const CreateClientType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateClientType = z.infer<typeof CreateClientType$zodSchema>;
+export const CreateClientCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateClientCode = ClosedEnum<typeof CreateClientCode>;
 
 export const CreateClientCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateClientCode = z.infer<typeof CreateClientCode$zodSchema>;
-
 /**
  * Missing scope
  */
@@ -97,9 +93,7 @@ export type CreateClientForbiddenResponseBody = {
 };
 
 export const CreateClientForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateClientForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateClientForbiddenResponseBody
 > = z.object({
   code: CreateClientCode$zodSchema,
   message: z.string(),
@@ -114,14 +108,11 @@ export type CreateClientResponse =
   | RateLimit
   | CreateClientUnprocessableEntityResponseBody;
 
-export const CreateClientResponse$zodSchema: z.ZodType<
-  CreateClientResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  Client$zodSchema,
-  AuthError$zodSchema,
-  z.lazy(() => CreateClientForbiddenResponseBody$zodSchema),
-  RateLimit$zodSchema,
-  z.lazy(() => CreateClientUnprocessableEntityResponseBody$zodSchema),
-]);
+export const CreateClientResponse$zodSchema: z.ZodType<CreateClientResponse> = z
+  .union([
+    Client$zodSchema,
+    AuthError$zodSchema,
+    z.lazy(() => CreateClientForbiddenResponseBody$zodSchema),
+    RateLimit$zodSchema,
+    z.lazy(() => CreateClientUnprocessableEntityResponseBody$zodSchema),
+  ]);

package/src/models/createfileop.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 import { AuthError, AuthError$zodSchema } from "./autherror.js";
 import { FileT, FileT$zodSchema } from "./file.js";
 import { FileCreate, FileCreate$zodSchema } from "./filecreate.js";
@@ -10,22 +11,15 @@ import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 export type CreateFileRequest = { xClientId: string; FileCreate: FileCreate };
 
-export const CreateFileRequest$zodSchema: z.ZodType<
-  CreateFileRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  FileCreate: FileCreate$zodSchema,
-  xClientId: z.string(),
-});
+export const CreateFileRequest$zodSchema: z.ZodType<CreateFileRequest> = z
+  .object({
+    FileCreate: FileCreate$zodSchema.describe("The file to upload"),
+    xClientId: z.string(),
+  });
 
 export type CreateFilePath = string | number;
 
-export const CreateFilePath$zodSchema: z.ZodType<
-  CreateFilePath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const CreateFilePath$zodSchema: z.ZodType<CreateFilePath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -36,11 +30,7 @@ export type CreateFileIssue = {
   message?: string | undefined;
 };
 
-export const CreateFileIssue$zodSchema: z.ZodType<
-  CreateFileIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const CreateFileIssue$zodSchema: z.ZodType<CreateFileIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -51,11 +41,7 @@ export const CreateFileIssue$zodSchema: z.ZodType<
 
 export type CreateFileError = { issues: Array<CreateFileIssue>; name: string };
 
-export const CreateFileError$zodSchema: z.ZodType<
-  CreateFileError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const CreateFileError$zodSchema: z.ZodType<CreateFileError> = z.object({
   issues: z.array(z.lazy(() => CreateFileIssue$zodSchema)),
   name: z.string(),
 });
@@ -69,38 +55,45 @@ export type CreateFileUnprocessableEntityResponseBody = {
 };
 
 export const CreateFileUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  CreateFileUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateFileUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => CreateFileError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
+export const CreateFileRequestEntityTooLargeStatusCode = {
+  FourHundredAndThirteen: 413,
+} as const;
+export type CreateFileRequestEntityTooLargeStatusCode = ClosedEnum<
+  typeof CreateFileRequestEntityTooLargeStatusCode
+>;
+
 export const CreateFileRequestEntityTooLargeStatusCode$zodSchema = z.literal(
   413,
 );
 
-export type CreateFileRequestEntityTooLargeStatusCode = z.infer<
-  typeof CreateFileRequestEntityTooLargeStatusCode$zodSchema
+export const CreateFileRequestEntityTooLargeType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateFileRequestEntityTooLargeType = ClosedEnum<
+  typeof CreateFileRequestEntityTooLargeType
 >;
 
 export const CreateFileRequestEntityTooLargeType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type CreateFileRequestEntityTooLargeType = z.infer<
-  typeof CreateFileRequestEntityTooLargeType$zodSchema
+export const CreateFileRequestEntityTooLargeCode = {
+  PayloadTooLarge: "payload_too_large",
+} as const;
+export type CreateFileRequestEntityTooLargeCode = ClosedEnum<
+  typeof CreateFileRequestEntityTooLargeCode
 >;
 
 export const CreateFileRequestEntityTooLargeCode$zodSchema = z.enum([
   "payload_too_large",
 ]);
 
-export type CreateFileRequestEntityTooLargeCode = z.infer<
-  typeof CreateFileRequestEntityTooLargeCode$zodSchema
->;
-
 /**
  * Payload too large
  */
@@ -112,9 +105,7 @@ export type CreateFileRequestEntityTooLargeResponseBody = {
 };
 
 export const CreateFileRequestEntityTooLargeResponseBody$zodSchema: z.ZodType<
-  CreateFileRequestEntityTooLargeResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateFileRequestEntityTooLargeResponseBody
 > = z.object({
   code: CreateFileRequestEntityTooLargeCode$zodSchema,
   message: z.string(),
@@ -122,28 +113,37 @@ export const CreateFileRequestEntityTooLargeResponseBody$zodSchema: z.ZodType<
   type: CreateFileRequestEntityTooLargeType$zodSchema,
 }).describe("Payload too large");
 
+export const CreateFileForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type CreateFileForbiddenStatusCode = ClosedEnum<
+  typeof CreateFileForbiddenStatusCode
+>;
+
 export const CreateFileForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type CreateFileForbiddenStatusCode = z.infer<
-  typeof CreateFileForbiddenStatusCode$zodSchema
+export const CreateFileForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type CreateFileForbiddenType = ClosedEnum<
+  typeof CreateFileForbiddenType
 >;
 
 export const CreateFileForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type CreateFileForbiddenType = z.infer<
-  typeof CreateFileForbiddenType$zodSchema
+export const CreateFileForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type CreateFileForbiddenCode = ClosedEnum<
+  typeof CreateFileForbiddenCode
 >;
 
 export const CreateFileForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type CreateFileForbiddenCode = z.infer<
-  typeof CreateFileForbiddenCode$zodSchema
->;
-
 /**
  * Missing scope
  */
@@ -155,9 +155,7 @@ export type CreateFileForbiddenResponseBody = {
 };
 
 export const CreateFileForbiddenResponseBody$zodSchema: z.ZodType<
-  CreateFileForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  CreateFileForbiddenResponseBody
 > = z.object({
   code: CreateFileForbiddenCode$zodSchema,
   message: z.string(),
@@ -165,28 +163,37 @@ export const CreateFileForbiddenResponseBody$zodSchema: z.ZodType<
   type: CreateFileForbiddenType$zodSchema,
 }).describe("Missing scope");
 
+export const CreateFileStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type CreateFileStatusCode400 = ClosedEnum<
+  typeof CreateFileStatusCode400
+>;
+
 export const CreateFileStatusCode400$zodSchema = z.literal(400);
 
-export type CreateFileStatusCode400 = z.infer<
-  typeof CreateFileStatusCode400$zodSchema
+export const CreateFileBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type CreateFileBadRequestType = ClosedEnum<
+  typeof CreateFileBadRequestType
 >;
 
 export const CreateFileBadRequestType$zodSchema = z.enum([
   "bad_request",
 ]);
 
-export type CreateFileBadRequestType = z.infer<
-  typeof CreateFileBadRequestType$zodSchema
+export const CreateFileCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type CreateFileCodeMissingClientID = ClosedEnum<
+  typeof CreateFileCodeMissingClientID
 >;
 
 export const CreateFileCodeMissingClientID$zodSchema = z.enum([
   "missing_client_id",
 ]);
 
-export type CreateFileCodeMissingClientID = z.infer<
-  typeof CreateFileCodeMissingClientID$zodSchema
->;
-
 /**
  * Missing client ID
  */
@@ -198,9 +205,7 @@ export type CreateFileResponseBodyMissingClientID = {
 };
 
 export const CreateFileResponseBodyMissingClientID$zodSchema: z.ZodType<
-  CreateFileResponseBodyMissingClientID,
-  z.ZodTypeDef,
-  unknown
+  CreateFileResponseBodyMissingClientID
 > = z.object({
   code: CreateFileCodeMissingClientID$zodSchema,
   message: z.string(),
@@ -217,16 +222,13 @@ export type CreateFileResponse =
   | RateLimit
   | CreateFileUnprocessableEntityResponseBody;
 
-export const CreateFileResponse$zodSchema: z.ZodType<
-  CreateFileResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  FileT$zodSchema,
-  z.lazy(() => CreateFileResponseBodyMissingClientID$zodSchema),
-  AuthError$zodSchema,
-  z.lazy(() => CreateFileForbiddenResponseBody$zodSchema),
-  z.lazy(() => CreateFileRequestEntityTooLargeResponseBody$zodSchema),
-  RateLimit$zodSchema,
-  z.lazy(() => CreateFileUnprocessableEntityResponseBody$zodSchema),
-]);
+export const CreateFileResponse$zodSchema: z.ZodType<CreateFileResponse> = z
+  .union([
+    FileT$zodSchema,
+    z.lazy(() => CreateFileResponseBodyMissingClientID$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => CreateFileForbiddenResponseBody$zodSchema),
+    z.lazy(() => CreateFileRequestEntityTooLargeResponseBody$zodSchema),
+    RateLimit$zodSchema,
+    z.lazy(() => CreateFileUnprocessableEntityResponseBody$zodSchema),
+  ]);