@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/listfilesop.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 { PaginatedFiles, PaginatedFiles$zodSchema } from "./paginatedfiles.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
@@ -15,24 +15,18 @@ export type ListFilesRequest = {
   xClientId: string;
 };
 
-export const ListFilesRequest$zodSchema: z.ZodType<
-  ListFilesRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  cursor: z.string().optional(),
-  limit: z.number().default(20),
-  workspaceId: z.string().optional(),
-  xClientId: z.string(),
-});
+export const ListFilesRequest$zodSchema: z.ZodType<ListFilesRequest> = z.object(
+  {
+    cursor: z.string().optional(),
+    limit: z.number().default(20),
+    workspaceId: z.string().optional(),
+    xClientId: z.string(),
+  },
+);
 
 export type ListFilesPath = string | number;
 
-export const ListFilesPath$zodSchema: z.ZodType<
-  ListFilesPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const ListFilesPath$zodSchema: z.ZodType<ListFilesPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -43,11 +37,7 @@ export type ListFilesIssue = {
   message?: string | undefined;
 };
 
-export const ListFilesIssue$zodSchema: z.ZodType<
-  ListFilesIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const ListFilesIssue$zodSchema: z.ZodType<ListFilesIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -58,11 +48,7 @@ export const ListFilesIssue$zodSchema: z.ZodType<
 
 export type ListFilesError = { issues: Array<ListFilesIssue>; name: string };
 
-export const ListFilesError$zodSchema: z.ZodType<
-  ListFilesError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const ListFilesError$zodSchema: z.ZodType<ListFilesError> = z.object({
   issues: z.array(z.lazy(() => ListFilesIssue$zodSchema)),
   name: z.string(),
 });
@@ -76,83 +62,120 @@ export type ListFilesUnprocessableEntityResponseBody = {
 };
 
 export const ListFilesUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  ListFilesUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListFilesUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => ListFilesError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
-export const ListFilesStatusCode$zodSchema = z.literal(403);
+export const ListFilesForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type ListFilesForbiddenStatusCode = ClosedEnum<
+  typeof ListFilesForbiddenStatusCode
+>;
+
+export const ListFilesForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type ListFilesStatusCode = z.infer<typeof ListFilesStatusCode$zodSchema>;
+export const ListFilesForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type ListFilesForbiddenType = ClosedEnum<typeof ListFilesForbiddenType>;
 
-export const ListFilesType$zodSchema = z.enum([
+export const ListFilesForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type ListFilesType = z.infer<typeof ListFilesType$zodSchema>;
+export const ListFilesForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type ListFilesForbiddenCode = ClosedEnum<typeof ListFilesForbiddenCode>;
 
-export const ListFilesCode$zodSchema = z.enum([
+export const ListFilesForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type ListFilesCode = z.infer<typeof ListFilesCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type ListFilesForbiddenResponseBody = {
-  status_code: ListFilesStatusCode;
-  type: ListFilesType;
-  code: ListFilesCode;
+  status_code: ListFilesForbiddenStatusCode;
+  type: ListFilesForbiddenType;
+  code: ListFilesForbiddenCode;
   message: string;
 };
 
 export const ListFilesForbiddenResponseBody$zodSchema: z.ZodType<
-  ListFilesForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListFilesForbiddenResponseBody
 > = z.object({
-  code: ListFilesCode$zodSchema,
+  code: ListFilesForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: ListFilesStatusCode$zodSchema,
-  type: ListFilesType$zodSchema,
+  status_code: ListFilesForbiddenStatusCode$zodSchema,
+  type: ListFilesForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type ListFilesResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  PaginatedFiles?: PaginatedFiles | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListFilesForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListFilesUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const ListFilesStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type ListFilesStatusCode400 = ClosedEnum<typeof ListFilesStatusCode400>;
+
+export const ListFilesStatusCode400$zodSchema = z.literal(400);
+
+export const ListFilesBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type ListFilesBadRequestType = ClosedEnum<
+  typeof ListFilesBadRequestType
+>;
+
+export const ListFilesBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const ListFilesCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type ListFilesCodeMissingClientID = ClosedEnum<
+  typeof ListFilesCodeMissingClientID
+>;
+
+export const ListFilesCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type ListFilesBadRequestResponseBody = {
+  status_code: ListFilesStatusCode400;
+  type: ListFilesBadRequestType;
+  code: ListFilesCodeMissingClientID;
+  message: string;
 };
 
-export const ListFilesResponse$zodSchema: z.ZodType<
-  ListFilesResponse,
-  z.ZodTypeDef,
-  unknown
+export const ListFilesBadRequestResponseBody$zodSchema: z.ZodType<
+  ListFilesBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  PaginatedFiles: PaginatedFiles$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListFilesForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListFilesUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: ListFilesCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: ListFilesStatusCode400$zodSchema,
+  type: ListFilesBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type ListFilesResponse =
+  | ListFilesBadRequestResponseBody
+  | AuthError
+  | ListFilesForbiddenResponseBody
+  | RateLimit
+  | PaginatedFiles
+  | ListFilesUnprocessableEntityResponseBody;
+
+export const ListFilesResponse$zodSchema: z.ZodType<ListFilesResponse> = z
+  .union([
+    z.lazy(() => ListFilesBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => ListFilesForbiddenResponseBody$zodSchema),
+    RateLimit$zodSchema,
+    PaginatedFiles$zodSchema,
+    z.lazy(() => ListFilesUnprocessableEntityResponseBody$zodSchema),
+  ]);

package/src/models/listtasksop.ts

@@ -3,14 +3,26 @@
  */
 
 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 { PaginatedTasks, PaginatedTasks$zodSchema } from "./paginatedtasks.js";
 import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
 
 /**
  * The sort field of the results
  */
+export const ListTasksSort = {
+  CreatedAt: "createdAt",
+  UpdatedAt: "updatedAt",
+  DueDate: "dueDate",
+  Status: "status",
+  Title: "title",
+} as const;
+/**
+ * The sort field of the results
+ */
+export type ListTasksSort = ClosedEnum<typeof ListTasksSort>;
+
 export const ListTasksSort$zodSchema = z.enum([
   "createdAt",
   "updatedAt",
@@ -19,18 +31,23 @@ export const ListTasksSort$zodSchema = z.enum([
   "title",
 ]).describe("The sort field of the results");
 
-export type ListTasksSort = z.infer<typeof ListTasksSort$zodSchema>;
-
 /**
  * The order of the results based on the sort field
  */
+export const ListTasksOrder = {
+  Asc: "asc",
+  Desc: "desc",
+} as const;
+/**
+ * The order of the results based on the sort field
+ */
+export type ListTasksOrder = ClosedEnum<typeof ListTasksOrder>;
+
 export const ListTasksOrder$zodSchema = z.enum([
   "asc",
   "desc",
 ]).describe("The order of the results based on the sort field");
 
-export type ListTasksOrder = z.infer<typeof ListTasksOrder$zodSchema>;
-
 export type ListTasksRequest = {
   limit?: number | undefined;
   cursor?: string | undefined;
@@ -41,27 +58,25 @@ export type ListTasksRequest = {
   xClientId: string;
 };
 
-export const ListTasksRequest$zodSchema: z.ZodType<
-  ListTasksRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  cursor: z.string().optional(),
-  limit: z.number().default(20),
-  order: ListTasksOrder$zodSchema.default("desc"),
-  parentId: z.string().optional(),
-  sort: ListTasksSort$zodSchema.default("createdAt"),
-  workspaceId: z.string().optional(),
-  xClientId: z.string(),
-});
+export const ListTasksRequest$zodSchema: z.ZodType<ListTasksRequest> = z.object(
+  {
+    cursor: z.string().optional(),
+    limit: z.number().default(20),
+    order: ListTasksOrder$zodSchema.default("desc").describe(
+      "The order of the results based on the sort field",
+    ),
+    parentId: z.string().optional(),
+    sort: ListTasksSort$zodSchema.default("createdAt").describe(
+      "The sort field of the results",
+    ),
+    workspaceId: z.string().optional(),
+    xClientId: z.string(),
+  },
+);
 
 export type ListTasksPath = string | number;
 
-export const ListTasksPath$zodSchema: z.ZodType<
-  ListTasksPath,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
+export const ListTasksPath$zodSchema: z.ZodType<ListTasksPath> = z.union([
   z.string(),
   z.number(),
 ]);
@@ -72,11 +87,7 @@ export type ListTasksIssue = {
   message?: string | undefined;
 };
 
-export const ListTasksIssue$zodSchema: z.ZodType<
-  ListTasksIssue,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const ListTasksIssue$zodSchema: z.ZodType<ListTasksIssue> = z.object({
   code: z.string(),
   message: z.string().optional(),
   path: z.array(z.union([
@@ -87,11 +98,7 @@ export const ListTasksIssue$zodSchema: z.ZodType<
 
 export type ListTasksError = { issues: Array<ListTasksIssue>; name: string };
 
-export const ListTasksError$zodSchema: z.ZodType<
-  ListTasksError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const ListTasksError$zodSchema: z.ZodType<ListTasksError> = z.object({
   issues: z.array(z.lazy(() => ListTasksIssue$zodSchema)),
   name: z.string(),
 });
@@ -105,83 +112,120 @@ export type ListTasksUnprocessableEntityResponseBody = {
 };
 
 export const ListTasksUnprocessableEntityResponseBody$zodSchema: z.ZodType<
-  ListTasksUnprocessableEntityResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListTasksUnprocessableEntityResponseBody
 > = z.object({
   error: z.lazy(() => ListTasksError$zodSchema),
   success: z.boolean(),
 }).describe("The validation error(s)");
 
-export const ListTasksStatusCode$zodSchema = z.literal(403);
+export const ListTasksForbiddenStatusCode = {
+  FourHundredAndThree: 403,
+} as const;
+export type ListTasksForbiddenStatusCode = ClosedEnum<
+  typeof ListTasksForbiddenStatusCode
+>;
+
+export const ListTasksForbiddenStatusCode$zodSchema = z.literal(403);
 
-export type ListTasksStatusCode = z.infer<typeof ListTasksStatusCode$zodSchema>;
+export const ListTasksForbiddenType = {
+  AuthError: "auth_error",
+} as const;
+export type ListTasksForbiddenType = ClosedEnum<typeof ListTasksForbiddenType>;
 
-export const ListTasksType$zodSchema = z.enum([
+export const ListTasksForbiddenType$zodSchema = z.enum([
   "auth_error",
 ]);
 
-export type ListTasksType = z.infer<typeof ListTasksType$zodSchema>;
+export const ListTasksForbiddenCode = {
+  MissingScope: "missing_scope",
+} as const;
+export type ListTasksForbiddenCode = ClosedEnum<typeof ListTasksForbiddenCode>;
 
-export const ListTasksCode$zodSchema = z.enum([
+export const ListTasksForbiddenCode$zodSchema = z.enum([
   "missing_scope",
 ]);
 
-export type ListTasksCode = z.infer<typeof ListTasksCode$zodSchema>;
-
 /**
  * Missing scope
  */
 export type ListTasksForbiddenResponseBody = {
-  status_code: ListTasksStatusCode;
-  type: ListTasksType;
-  code: ListTasksCode;
+  status_code: ListTasksForbiddenStatusCode;
+  type: ListTasksForbiddenType;
+  code: ListTasksForbiddenCode;
   message: string;
 };
 
 export const ListTasksForbiddenResponseBody$zodSchema: z.ZodType<
-  ListTasksForbiddenResponseBody,
-  z.ZodTypeDef,
-  unknown
+  ListTasksForbiddenResponseBody
 > = z.object({
-  code: ListTasksCode$zodSchema,
+  code: ListTasksForbiddenCode$zodSchema,
   message: z.string(),
-  status_code: ListTasksStatusCode$zodSchema,
-  type: ListTasksType$zodSchema,
+  status_code: ListTasksForbiddenStatusCode$zodSchema,
+  type: ListTasksForbiddenType$zodSchema,
 }).describe("Missing scope");
 
-export type ListTasksResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  PaginatedTasks?: PaginatedTasks | undefined;
-  bad_request?: BadRequest | undefined;
-  auth_error?: AuthError | undefined;
-  fourHundredAndThreeApplicationJsonObject?:
-    | ListTasksForbiddenResponseBody
-    | undefined;
-  fourHundredAndTwentyTwoApplicationJsonObject?:
-    | ListTasksUnprocessableEntityResponseBody
-    | undefined;
-  rate_limit?: RateLimit | undefined;
+export const ListTasksStatusCode400 = {
+  FourHundred: 400,
+} as const;
+export type ListTasksStatusCode400 = ClosedEnum<typeof ListTasksStatusCode400>;
+
+export const ListTasksStatusCode400$zodSchema = z.literal(400);
+
+export const ListTasksBadRequestType = {
+  BadRequest: "bad_request",
+} as const;
+export type ListTasksBadRequestType = ClosedEnum<
+  typeof ListTasksBadRequestType
+>;
+
+export const ListTasksBadRequestType$zodSchema = z.enum([
+  "bad_request",
+]);
+
+export const ListTasksCodeMissingClientID = {
+  MissingClientId: "missing_client_id",
+} as const;
+export type ListTasksCodeMissingClientID = ClosedEnum<
+  typeof ListTasksCodeMissingClientID
+>;
+
+export const ListTasksCodeMissingClientID$zodSchema = z.enum([
+  "missing_client_id",
+]);
+
+/**
+ * Missing client ID
+ */
+export type ListTasksBadRequestResponseBody = {
+  status_code: ListTasksStatusCode400;
+  type: ListTasksBadRequestType;
+  code: ListTasksCodeMissingClientID;
+  message: string;
 };
 
-export const ListTasksResponse$zodSchema: z.ZodType<
-  ListTasksResponse,
-  z.ZodTypeDef,
-  unknown
+export const ListTasksBadRequestResponseBody$zodSchema: z.ZodType<
+  ListTasksBadRequestResponseBody
 > = z.object({
-  ContentType: z.string(),
-  PaginatedTasks: PaginatedTasks$zodSchema.optional(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  auth_error: AuthError$zodSchema.optional(),
-  bad_request: BadRequest$zodSchema.optional(),
-  fourHundredAndThreeApplicationJsonObject: z.lazy(() =>
-    ListTasksForbiddenResponseBody$zodSchema
-  ).optional(),
-  fourHundredAndTwentyTwoApplicationJsonObject: z.lazy(() =>
-    ListTasksUnprocessableEntityResponseBody$zodSchema
-  ).optional(),
-  rate_limit: RateLimit$zodSchema.optional(),
-});
+  code: ListTasksCodeMissingClientID$zodSchema,
+  message: z.string(),
+  status_code: ListTasksStatusCode400$zodSchema,
+  type: ListTasksBadRequestType$zodSchema,
+}).describe("Missing client ID");
+
+export type ListTasksResponse =
+  | ListTasksBadRequestResponseBody
+  | AuthError
+  | ListTasksForbiddenResponseBody
+  | RateLimit
+  | PaginatedTasks
+  | ListTasksUnprocessableEntityResponseBody;
+
+export const ListTasksResponse$zodSchema: z.ZodType<ListTasksResponse> = z
+  .union([
+    z.lazy(() => ListTasksBadRequestResponseBody$zodSchema),
+    AuthError$zodSchema,
+    z.lazy(() => ListTasksForbiddenResponseBody$zodSchema),
+    RateLimit$zodSchema,
+    PaginatedTasks$zodSchema,
+    z.lazy(() => ListTasksUnprocessableEntityResponseBody$zodSchema),
+  ]);