@steuerboard/mcp 0.3.3 → 0.4.0

package/src/models/collectsessionbytoken.ts

@@ -0,0 +1,452 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+export const CollectSessionByTokenStatus = {
+  Created: "created",
+  Active: "active",
+  PendingReview: "pending_review",
+  Completed: "completed",
+  Cancelled: "cancelled",
+} as const;
+export type CollectSessionByTokenStatus = ClosedEnum<
+  typeof CollectSessionByTokenStatus
+>;
+
+export const CollectSessionByTokenStatus$zodSchema = z.enum([
+  "created",
+  "active",
+  "pending_review",
+  "completed",
+  "cancelled",
+]);
+
+export const Channel = {
+  CollectUi: "collectUi",
+} as const;
+export type Channel = ClosedEnum<typeof Channel>;
+
+export const Channel$zodSchema = z.enum([
+  "collectUi",
+]);
+
+export type ChannelConfig = {
+  channel: Channel;
+  brandingColor?: string | undefined;
+  logoUrl?: string | undefined;
+  pinProtected?: boolean | undefined;
+  submitButtonLabel?: string | undefined;
+  locale?: string | undefined;
+};
+
+export const ChannelConfig$zodSchema: z.ZodType<ChannelConfig> = z.object({
+  brandingColor: z.string().optional(),
+  channel: Channel$zodSchema,
+  locale: z.string().default("de"),
+  logoUrl: z.string().optional(),
+  pinProtected: z.boolean().default(false),
+  submitButtonLabel: z.string().default("Submit"),
+});
+
+export const EvaluationMode = {
+  Individual: "individual",
+  Batch: "batch",
+  BulkMatch: "bulk_match",
+} as const;
+export type EvaluationMode = ClosedEnum<typeof EvaluationMode>;
+
+export const EvaluationMode$zodSchema = z.enum([
+  "individual",
+  "batch",
+  "bulk_match",
+]);
+
+export const CollectSessionByTokenType = {
+  FileUpload: "file_upload",
+  FormField: "form_field",
+  Signature: "signature",
+  Confirmation: "confirmation",
+} as const;
+export type CollectSessionByTokenType = ClosedEnum<
+  typeof CollectSessionByTokenType
+>;
+
+export const CollectSessionByTokenType$zodSchema = z.enum([
+  "file_upload",
+  "form_field",
+  "signature",
+  "confirmation",
+]);
+
+export const ItemStatus = {
+  Pending: "pending",
+  Submitted: "submitted",
+  Fulfilled: "fulfilled",
+  Rejected: "rejected",
+} as const;
+export type ItemStatus = ClosedEnum<typeof ItemStatus>;
+
+export const ItemStatus$zodSchema = z.enum([
+  "pending",
+  "submitted",
+  "fulfilled",
+  "rejected",
+]);
+
+export const TypeConfirmation = {
+  Confirmation: "confirmation",
+} as const;
+export type TypeConfirmation = ClosedEnum<typeof TypeConfirmation>;
+
+export const TypeConfirmation$zodSchema = z.enum([
+  "confirmation",
+]);
+
+export type ConfigConfirmation = {
+  type: TypeConfirmation;
+  confirmationText: string;
+  requiresExplicitConsent?: boolean | undefined;
+};
+
+export const ConfigConfirmation$zodSchema: z.ZodType<ConfigConfirmation> = z
+  .object({
+    confirmationText: z.string(),
+    requiresExplicitConsent: z.boolean().default(true),
+    type: TypeConfirmation$zodSchema,
+  });
+
+export const TypeSignature = {
+  Signature: "signature",
+} as const;
+export type TypeSignature = ClosedEnum<typeof TypeSignature>;
+
+export const TypeSignature$zodSchema = z.enum([
+  "signature",
+]);
+
+export type ConfigSignature = {
+  type: TypeSignature;
+  signerName: string;
+  signerEmail?: string | undefined;
+  documentRef?: string | undefined;
+};
+
+export const ConfigSignature$zodSchema: z.ZodType<ConfigSignature> = z.object({
+  documentRef: z.string().optional(),
+  signerEmail: z.string().optional(),
+  signerName: z.string(),
+  type: TypeSignature$zodSchema,
+});
+
+export const TypeFileUpload = {
+  FileUpload: "fileUpload",
+} as const;
+export type TypeFileUpload = ClosedEnum<typeof TypeFileUpload>;
+
+export const TypeFileUpload$zodSchema = z.enum([
+  "fileUpload",
+]);
+
+export type FileCount = { min?: number | undefined; max?: number | undefined };
+
+export const FileCount$zodSchema: z.ZodType<FileCount> = z.object({
+  max: z.int().optional(),
+  min: z.int().default(1),
+});
+
+export type MatchingHints = string | number;
+
+export const MatchingHints$zodSchema: z.ZodType<MatchingHints> = z.union([
+  z.string(),
+  z.number(),
+]);
+
+export type ConfigFileUpload = {
+  type: TypeFileUpload;
+  acceptedFileTypes?: Array<string> | undefined;
+  maxFileSizeMb?: number | undefined;
+  fileCount?: FileCount | undefined;
+  matchingHints?: { [k: string]: string | number } | undefined;
+};
+
+export const ConfigFileUpload$zodSchema: z.ZodType<ConfigFileUpload> = z.object(
+  {
+    acceptedFileTypes: z.array(z.string()).optional(),
+    fileCount: z.lazy(() => FileCount$zodSchema).optional(),
+    matchingHints: z.record(
+      z.string(),
+      z.union([
+        z.string(),
+        z.number(),
+      ]),
+    ).optional(),
+    maxFileSizeMb: z.number().default(25),
+    type: TypeFileUpload$zodSchema,
+  },
+);
+
+export const TypeFormField = {
+  FormField: "formField",
+} as const;
+export type TypeFormField = ClosedEnum<typeof TypeFormField>;
+
+export const TypeFormField$zodSchema = z.enum([
+  "formField",
+]);
+
+export const FieldType = {
+  Text: "text",
+  Number: "number",
+  Date: "date",
+  Select: "select",
+  MultiSelect: "multiSelect",
+  Address: "address",
+  Phone: "phone",
+  Email: "email",
+  TaxId: "taxId",
+  Iban: "iban",
+} as const;
+export type FieldType = ClosedEnum<typeof FieldType>;
+
+export const FieldType$zodSchema = z.enum([
+  "text",
+  "number",
+  "date",
+  "select",
+  "multiSelect",
+  "address",
+  "phone",
+  "email",
+  "taxId",
+  "iban",
+]);
+
+export const FieldValidationType = {
+  Regex: "regex",
+  Min: "min",
+  Max: "max",
+  MinLength: "minLength",
+  MaxLength: "maxLength",
+  Custom: "custom",
+} as const;
+export type FieldValidationType = ClosedEnum<typeof FieldValidationType>;
+
+export const FieldValidationType$zodSchema = z.enum([
+  "regex",
+  "min",
+  "max",
+  "minLength",
+  "maxLength",
+  "custom",
+]);
+
+export type Value = string | number;
+
+export const Value$zodSchema: z.ZodType<Value> = z.union([
+  z.string(),
+  z.number(),
+]);
+
+export type FieldValidation = {
+  type: FieldValidationType;
+  value: string | number;
+  message?: string | undefined;
+};
+
+export const FieldValidation$zodSchema: z.ZodType<FieldValidation> = z.object({
+  message: z.string().optional(),
+  type: FieldValidationType$zodSchema,
+  value: z.union([
+    z.string(),
+    z.number(),
+  ]),
+});
+
+export const Condition = {
+  Equals: "equals",
+  NotEmpty: "notEmpty",
+  NotEquals: "notEquals",
+} as const;
+export type Condition = ClosedEnum<typeof Condition>;
+
+export const Condition$zodSchema = z.enum([
+  "equals",
+  "notEmpty",
+  "notEquals",
+]);
+
+export type FieldDependsOn = {
+  collectItemId: string;
+  condition: Condition;
+  value?: string | undefined;
+};
+
+export const FieldDependsOn$zodSchema: z.ZodType<FieldDependsOn> = z.object({
+  collectItemId: z.string(),
+  condition: Condition$zodSchema,
+  value: z.string().optional(),
+});
+
+export type ConfigFormField = {
+  type: TypeFormField;
+  fieldType: FieldType;
+  fieldRequired?: boolean | undefined;
+  fieldPlaceholder?: string | undefined;
+  fieldOptions?: Array<string> | undefined;
+  fieldValidation?: Array<FieldValidation> | undefined;
+  fieldDependsOn?: FieldDependsOn | undefined;
+};
+
+export const ConfigFormField$zodSchema: z.ZodType<ConfigFormField> = z.object({
+  fieldDependsOn: z.lazy(() => FieldDependsOn$zodSchema).optional(),
+  fieldOptions: z.array(z.string()).optional(),
+  fieldPlaceholder: z.string().optional(),
+  fieldRequired: z.boolean().default(true),
+  fieldType: FieldType$zodSchema,
+  fieldValidation: z.array(z.lazy(() => FieldValidation$zodSchema)).optional(),
+  type: TypeFormField$zodSchema,
+});
+
+export type Config =
+  | ConfigFormField
+  | ConfigSignature
+  | ConfigConfirmation
+  | ConfigFileUpload;
+
+export const Config$zodSchema: z.ZodType<Config> = z.union([
+  z.lazy(() => ConfigFormField$zodSchema),
+  z.lazy(() => ConfigSignature$zodSchema),
+  z.lazy(() => ConfigConfirmation$zodSchema),
+  z.lazy(() => ConfigFileUpload$zodSchema),
+]);
+
+export type ItemSubmission = {
+  id: string;
+  status: string;
+  fileName: string | null;
+  fileSize: number | null;
+  rejectionReason: string | null;
+};
+
+export const ItemSubmission$zodSchema: z.ZodType<ItemSubmission> = z.object({
+  fileName: z.string().nullable(),
+  fileSize: z.number().nullable(),
+  id: z.string(),
+  rejectionReason: z.string().nullable(),
+  status: z.string(),
+});
+
+export type Item = {
+  id: string;
+  type: CollectSessionByTokenType;
+  description: string;
+  status: ItemStatus;
+  sortOrder: number;
+  config:
+    | ConfigFormField
+    | ConfigSignature
+    | ConfigConfirmation
+    | ConfigFileUpload;
+  groupId: string | null;
+  submissions: Array<ItemSubmission>;
+};
+
+export const Item$zodSchema: z.ZodType<Item> = z.object({
+  config: z.union([
+    z.lazy(() => ConfigFormField$zodSchema),
+    z.lazy(() => ConfigSignature$zodSchema),
+    z.lazy(() => ConfigConfirmation$zodSchema),
+    z.lazy(() => ConfigFileUpload$zodSchema),
+  ]),
+  description: z.string(),
+  groupId: z.string().nullable(),
+  id: z.string(),
+  sortOrder: z.int(),
+  status: ItemStatus$zodSchema,
+  submissions: z.array(z.lazy(() => ItemSubmission$zodSchema)),
+  type: CollectSessionByTokenType$zodSchema,
+});
+
+export type CollectSessionByTokenSubmission = {
+  id: string;
+  status: string;
+  fileName: string | null;
+  fileSize: number | null;
+  rejectionReason: string | null;
+};
+
+export const CollectSessionByTokenSubmission$zodSchema: z.ZodType<
+  CollectSessionByTokenSubmission
+> = z.object({
+  fileName: z.string().nullable(),
+  fileSize: z.number().nullable(),
+  id: z.string(),
+  rejectionReason: z.string().nullable(),
+  status: z.string(),
+});
+
+export type SubmissionSummary = {
+  total: number;
+  pending: number;
+  processing: number;
+  matched: number;
+  proposed: number;
+};
+
+export const SubmissionSummary$zodSchema: z.ZodType<SubmissionSummary> = z
+  .object({
+    matched: z.int(),
+    pending: z.int(),
+    processing: z.int(),
+    proposed: z.int(),
+    total: z.int(),
+  });
+
+export type Group = {
+  id: string;
+  label: string;
+  description: string | null;
+  sortOrder: number;
+  evaluationMode: EvaluationMode;
+  repeatable: boolean;
+  minInstances: number;
+  maxInstances: number | null;
+  items: Array<Item>;
+  submissions?: Array<CollectSessionByTokenSubmission> | undefined;
+  submissionSummary?: SubmissionSummary | undefined;
+};
+
+export const Group$zodSchema: z.ZodType<Group> = z.object({
+  description: z.string().nullable(),
+  evaluationMode: EvaluationMode$zodSchema,
+  id: z.string(),
+  items: z.array(z.lazy(() => Item$zodSchema)),
+  label: z.string(),
+  maxInstances: z.int().nullable(),
+  minInstances: z.int(),
+  repeatable: z.boolean(),
+  sortOrder: z.int(),
+  submissionSummary: z.lazy(() => SubmissionSummary$zodSchema).optional(),
+  submissions: z.array(z.lazy(() => CollectSessionByTokenSubmission$zodSchema))
+    .optional(),
+});
+
+export type CollectSessionByToken = {
+  id: string;
+  description: string;
+  status: CollectSessionByTokenStatus;
+  channelConfig: ChannelConfig;
+  groups: Array<Group>;
+};
+
+export const CollectSessionByToken$zodSchema: z.ZodType<CollectSessionByToken> =
+  z.object({
+    channelConfig: z.lazy(() => ChannelConfig$zodSchema),
+    description: z.string(),
+    groups: z.array(z.lazy(() => Group$zodSchema)),
+    id: z.string(),
+    status: CollectSessionByTokenStatus$zodSchema,
+  });

package/src/models/completecollectsessionop.ts

@@ -0,0 +1,95 @@
+/*
+ * 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 {
+  CompleteSessionBody,
+  CompleteSessionBody$zodSchema,
+} from "./completesessionbody.js";
+import {
+  CompleteSessionResponse,
+  CompleteSessionResponse$zodSchema,
+} from "./completesessionresponse.js";
+import { RateLimit, RateLimit$zodSchema } from "./ratelimit.js";
+
+export type CompleteCollectSessionRequest = {
+  token: string;
+  CompleteSessionBody?: CompleteSessionBody | undefined;
+};
+
+export const CompleteCollectSessionRequest$zodSchema: z.ZodType<
+  CompleteCollectSessionRequest
+> = z.object({
+  CompleteSessionBody: CompleteSessionBody$zodSchema.optional().describe(
+    "Completion details",
+  ),
+  token: z.string(),
+});
+
+export const CompleteCollectSessionStatusCode = {
+  FourHundredAndFour: 404,
+} as const;
+export type CompleteCollectSessionStatusCode = ClosedEnum<
+  typeof CompleteCollectSessionStatusCode
+>;
+
+export const CompleteCollectSessionStatusCode$zodSchema = z.literal(404);
+
+export const CompleteCollectSessionType = {
+  NotFound: "not_found",
+} as const;
+export type CompleteCollectSessionType = ClosedEnum<
+  typeof CompleteCollectSessionType
+>;
+
+export const CompleteCollectSessionType$zodSchema = z.enum([
+  "not_found",
+]);
+
+export const CompleteCollectSessionCode = {
+  CollectTokenNotFound: "collect_token_not_found",
+} as const;
+export type CompleteCollectSessionCode = ClosedEnum<
+  typeof CompleteCollectSessionCode
+>;
+
+export const CompleteCollectSessionCode$zodSchema = z.enum([
+  "collect_token_not_found",
+]);
+
+/**
+ * Collect session not found. The token may be invalid or revoked.
+ */
+export type CompleteCollectSessionResponseBody = {
+  status_code: CompleteCollectSessionStatusCode;
+  type: CompleteCollectSessionType;
+  code: CompleteCollectSessionCode;
+  message: string;
+};
+
+export const CompleteCollectSessionResponseBody$zodSchema: z.ZodType<
+  CompleteCollectSessionResponseBody
+> = z.object({
+  code: CompleteCollectSessionCode$zodSchema,
+  message: z.string(),
+  status_code: CompleteCollectSessionStatusCode$zodSchema,
+  type: CompleteCollectSessionType$zodSchema,
+}).describe("Collect session not found. The token may be invalid or revoked.");
+
+export type CompleteCollectSessionResponse =
+  | CompleteCollectSessionResponseBody
+  | BadRequest
+  | RateLimit
+  | CompleteSessionResponse;
+
+export const CompleteCollectSessionResponse$zodSchema: z.ZodType<
+  CompleteCollectSessionResponse
+> = z.union([
+  z.lazy(() => CompleteCollectSessionResponseBody$zodSchema),
+  BadRequest$zodSchema,
+  RateLimit$zodSchema,
+  CompleteSessionResponse$zodSchema,
+]);

package/src/models/completesessionbody.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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",
+  "incomplete_finished",
+]).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).",
+);
+
+export type CompleteSessionBody = {
+  clientNote?: string | undefined;
+  outcome?: Outcome | undefined;
+};
+
+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

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type CompleteSessionResponse = { success: boolean };
+
+export const CompleteSessionResponse$zodSchema: z.ZodType<
+  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,
+});